NamS의 iOS일기

[Swift] WWDC 25 App Intent 알아보기 (feat. 단축어)

냄수 — Wed, 29 Jul 2026 17:45:56 +0900

애플 인텔리전스를 활용하기위해 먼저 앱인텐트에 대해서 알아보려합니다

App Intents

App Intents는 시스템 전체 및 모든 Apple 플랫폼에서 앱의 발견 가능성, 가시성, 기능을 확장해 주는 프레임워크입니다

앱을 열지 않은 사용자에게도 풍부한 경험을 제공할 수 있도록 합니다

앱 인텐트로 두 가지 유형의 값을 만들 수 있습니다

상수 값 집합을 가진 타입에는 AppEnum

동적 타입에는 AppEntity를 사용합니다

앱 단축어는 앱 인텐트를 강조해 더 쉽게 접근하고 발견할 수 있도록 합니다

Spotlight 검색이나 Siri 사용, 동작 버튼 구성과 같은 상황에서 표시됩니다

supportedModes 속성을 foreground로 설정하여 인텐트가 실행되기 전에 앱을 열도록 할수있음

앱을 설치한 후 인텐트는 단축어에서 찾을 수 있습니다
새 단축어를 만들고 탐색 인텐트를 추가할 수 있음
단축어를 실행하면 앱이 포그라운드로 이동하고 Landmarks 뷰가 바로 표시됨

AppEnum사용

AppEnum을 사용하려면 몇 가지 요건만 충족하면 됩니다

문자열로부터 인스턴스화가 가능해야 하므로 String 원본 값을 추가
typeDisplayRepresentation은 타입을 전체적으로 설명
caseDisplayRepresentation은 enum의 각 case를 설명

@Parameter 속성을 추가하여 인텐트 매개변수로 만들 수 있음
인텐트 매개변수는 인텐트의 입력으로 사용

단축어로 돌아가면 NavigationOption이 편집 가능한 매개변수로 표시되고
인텐트를 실행하면 섹션을 선택하라고 단축어가 요청합니다

아이콘을 추가하려면 DisplayRepresentation 이니셜라이저가 사용

각 case에 대해 기호를 추가가능

인텐트는 ParameterSummary라는 유동적인 문장 형식으로 구성가능

ParameterSummary는 동작과 관련 매개변수를 사용자가 읽기 편한 방식으로 설명합니다

매개변수에 맞춤화된 title을 추가하여 이해하기 힘든 문장도 해결할 수 있습니다

앱의 동작을 인텐트로 모델링하면 사용자가 강력한 단축어와 자동화를 만들 수 있습니다

앱에서 매우 중요한 인텐트는 앱이 설치된 순간부터 제공되어야 합니다

앱 단축어를 채택하여 제공할 수 있습니다
앱 단축어는 사용자가 설정하지 않아도 단축어 앱에 표시되며 특히 단 몇 줄의 코드만으로 빌드할 수 있어서 유용함

AppShortcutsProvider를 통해 앱 단축어를 제공합니다

앱에서는 모든 앱 단축어를 포함하는 단일 Provider를 정의해야 합니다

매개변수 없이 phrase를 제공하면 shortTitle, systemImageName 기반으로 앱 단축어가 생성 → Navigate 버튼

AppEnum을 포함한 phrase를 제공하면 case마다 앱 단축어가 생성 → Landmarks,Map,Collections 버튼

Siri나 Spotlight를 통해 인텐트를 실행할 수 있습니다
앱 단축어를 빌드하면 사용자가 인텐트를 쉽게 찾을 수 있습니다

struct LandmarksShortcuts: AppShortcutsProvider {
    static var appShortcuts: [AppShortcut] {
        AppShortcut(
            intent: NavigateIntent(),
            phrases: [
                "Navigate in \(.applicationName)",
                "\(.applicationName)에서 이동",
            ],
            shortTitle: "Navigate",
            systemImageName: "arrow.turn.down.right"
        )

        // navigationOption의 case 수만큼 앱 단축어가 만들어진다 (Landmarks / Map / Collections)
        AppShortcut(
            intent: NavigateIntent(),
            phrases: [
                "Open \(\.$navigationOption) in \(.applicationName)"
            ],
            shortTitle: "Open Section",
            systemImageName: "square.grid.2x2"
        )

        AppShortcut(
            intent: FindNextLandmarkIntent(),
            phrases: [
                "Find my next landmark in \(.applicationName)",
                "\(.applicationName) 다음 여행지 추천",
            ],
            shortTitle: "Next Landmark",
            systemImageName: "sparkles"
        )
    }
}

실제로 위와같이 제공하면

섹션이 구분돼서 표시됩니다

AppEntity사용

AppEntity는 식별 가능해야 하므로 ID를 추가합니다

이 식별자는 영구적이어야 하며 이 ID를 통해 엔티티의 인스턴스를 조회할 수 있어야 합니다

@ComputedProperty 속성을 사용해서 엔티티 속성에 Getter를 추가할 수 있습니다

타입 간에 값을 복사하는 대신 데이터 모델을 따를 수 있음

ComputedProperty매크로는 $로 시작하는 prefix 변수를 생성합니다

name같은경우 $name 때문에 나중에 \LandmarkEntity.$name으로 키패스를 사용할 수 있습니다.

AppEnum처럼 AppEntity도 타입 및 타입 인스턴스에 대한 Representation이 필요합니다

AppEnum이 알려진 값을 갖는 반면 AppEntity는 동적입니다

앱에 있는 랜드마크의 수는 달라질 수 있습니다

쿼리는 시스템이 엔티티에 대해 추론하는 방법입니다

이는 다양한 질문을 답하며 진행됩니다

첫 번째 유형의 질문은 “어떤 엔티티가 존재하나요?”입니다

쿼리는 이 질문에 답변하고 일치하는 엔티티의 컬렉션을 반환합니다

@Dependency 속성을 사용하여 쿼리에 종속성을 삽입할 수 있습니다 공유된 AppDependencyManager를 사용하여 종속성을 등록해야 합니다

struct FindNextLandmarkIntent: AppIntent {
    static let title: LocalizedStringResource = "Find Next Landmark"
    static let description = IntentDescription("아직 방문하지 않은 랜드마크 하나를 추천합니다.")

    @Dependency var store: LandmarkStore

    func perform() async throws -> some IntentResult
        & ReturnsValue<LandmarkEntity>
        & ProvidesDialog
        & ShowsSnippetView
    {
        ...
        return .result(
            value: entity,
            dialog: "다음은 \(pick.name)이 어떨까요?",
            view: LandmarkSnippet(entity: entity)
        )
    }
}


struct LandmarkSnippet: View {
    let entity: LandmarkEntity

    var body: some View {
        HStack(spacing: 16) {
            Image(systemName: entity.landmark.symbol)
                .font(.system(size: 44))
                .foregroundStyle(.tint)
            VStack(alignment: .leading, spacing: 4) {
                Text(entity.landmark.name).font(.headline)
                Text(entity.landmark.continent).font(.subheadline).foregroundStyle(.secondary)
                Text(entity.landmark.summary).font(.caption)
            }
            Spacer()
        }
        .padding()
    }
}

perform 메서드에 LandmarkEntity의 ReturnsValue를 추가합니다
인텐트 매개변수로 사용된 타입은 인텐트에서 반환될 수도 있습니다
반환된 값은 여러 단계의 단축어에서처럼 다른 인텐트의 입력으로 사용할 수 있습니다

대화상자와 뷰 스니펫도 반환되도록 설정하겠습니다 → ProvidesDialog & ShowsSnippetView

왼쪽이미지 - 실행시킨 뷰는 LandMarkSnippet뷰를 제공한것이고

struct LandmarkEntity: IndexedEntity {
    var displayRepresentation: DisplayRepresentation {
        DisplayRepresentation(
            title: "\(landmark.name) - IndexEntity",
            subtitle: "\(landmark.continent)",
            image: .init(systemName: landmark.symbol)
        )
    }
}

오른쪽이미지 - 단축어에서 미리보기는 LandmarkEntity의 displayRepresentation를 보여줍니다

Transferable 프로토콜을 사용하여 엔티티의 imageRepresentation을 선언할 수 있습니다
Transferable은 타입의 다양한 데이터 표현을 선언적으로 설명하는 방법입니다

이러한 representation은 앱 간에 데이터를 공유하는 데 사용될 수 있습니다

데이터를 타입의 TransferRepresentation 일부로 제공하면
단축어에서 엔티티의 imageRepresentation을 표시하도록 선택할 수 있습니다

단축어를 실행하면 랜드마크의 이미지가 표시됩니다

imageRepresentation 선언 시 누릴 수 있는 이점중 하나로
사진을 촬영하는 모든 동작의 입력으로 이 이미지 값을 사용할 수 있습니다

다른 앱에 있는 사진도 활용할 수 있습니다

Spotlight는 여러 앱에서 작동하는 강력한 시맨틱 검색을 제공합니다

엔티티를 Spotlight에 제공하면 시스템이 콘텐츠를 이해하는 범위가 확장됩니다

Spotlight가 엔티티를 인덱싱하도록 IndexedEntity 프로토콜을 채택

IndexedEntity는 Core Spotlight 속성 집합을 포함하는 AppEntity임

OpenIntent 프로토콜을 채택한 인텐트는 실행 전에 앱을 자동으로 엽니다
그러므로 SupportedMode를 추가하지 않아도 됨

OpenIntent에는 target 매개변수가 있어야 합니다

Spotlight에서 엔티티를 누르면 해당 엔티티와 일치하는 OpenIntent가 실행됩니다

내비게이션을 위해 특별히 설계된 새로운 TargetContentProvidingIntent 프로토콜을 채택할 수 있습니다

이 인텐트에는 perform 메서드가 필요하지 않습니다

대신 뷰에 onAppIntentExecution 를 추가할 수 있습니다

쿼리를 사용하여 랜드마크를 제공할 수 있습니다

EntityQuery에 선택적인 suggestedEntities 메서드를 사용

엔티티가 모두 메모리에 들어갈 경우 모든 엔티티를 반환하기 위해 EnumerableEntityQuery를 사용할 수 있습니다

TargetContentProvidingIntent예시

일반적인 네비게이션을위한 앱인텐트

struct NavigateIntent: AppIntent, TargetContentProvidingIntent {
    static let title: LocalizedStringResource = "Navigate"
    static let description = IntentDescription("앱의 특정 섹션을 엽니다.")

    @Parameter(title: "Section")
    var navigationOption: NavigationOption

    /// ParameterSummary — 액션을 사람이 읽는 문장으로 만든다.
    static var parameterSummary: some ParameterSummary {
        Summary("Navigate to \(\.$navigationOption)")
    }

    init() {}
    init(navigationOption: NavigationOption) { self.navigationOption = navigationOption }
}

title: 노출되는 타이틀

description: i버튼을 눌렀을때 나타나는 설명

OpenIntent 예시

시스템적인 네비게이션을위한 앱인텐트

struct OpenLandmarkIntent: OpenIntent, TargetContentProvidingIntent {
    static let title: LocalizedStringResource = "Open Landmark"

    @Parameter(title: "Landmark")
    var target: LandmarkEntity

    init() {}
    init(target: LandmarkEntity) { self.target = target }
}

AppIntent로 데이터 수정 하는 예시

struct MarkVisitedIntent: AppIntent {
    static let title: LocalizedStringResource = "Mark Landmarks Visited"

    @Parameter(title: "Landmarks")
    var landmarks: [LandmarkEntity]

    @Parameter(title: "Visited", default: true)
    var visited: Bool

    static var parameterSummary: some ParameterSummary {
        Summary("Set \(\.$landmarks) visited to \(\.$visited)")
    }

    @Dependency var store: LandmarkStore

    func perform() async throws -> some IntentResult & ProvidesDialog {
        let ids = landmarks.map(\.id)
        await store.setVisited(ids: ids, visited: visited)
        await store.note("\(ids.count)개 방문 상태 = \(visited)")
        return .result(dialog: "\(ids.count)개 랜드마크를 업데이트했습니다.")
    }
}

Entity 및 Query

struct LandmarkEntity: IndexedEntity {
    /// 영구적이어야 하는 식별자. 이 ID로 인스턴스를 되찾을 수 있어야 한다.
    var id: Int

    /// ponytail: 값을 복사하지 않고 데이터 모델을 그대로 들고 간다.
    /// @ComputedProperty가 이 모델을 읽어 프로퍼티를 노출한다.
    var landmark: Landmark

    init(_ landmark: Landmark) {
        self.id = landmark.id
        self.landmark = landmark
    }

    @ComputedProperty(title: "Name", indexingKey: \.displayName)
    var name: String { landmark.name }

    @ComputedProperty(title: "Continent")
    var continent: String { landmark.continent }

    @ComputedProperty(title: "Summary", indexingKey: \.contentDescription)
    var summary: String { landmark.summary }

    @ComputedProperty(title: "Visited")
    var visited: Bool { landmark.visited }

    /// 타입 전체를 설명
    static let typeDisplayRepresentation = TypeDisplayRepresentation(
        name: "Landmark",
        numericFormat: "\(placeholder: .int) landmarks"
    )

    /// 인스턴스 하나를 설명 (Shortcuts 피커, Siri, Spotlight에서 이 모습으로 보인다)
    var displayRepresentation: DisplayRepresentation {
        DisplayRepresentation(
            title: "\(landmark.name) - IndexEntity",
            subtitle: "\(landmark.continent)",
            image: .init(systemName: landmark.symbol)
        )
    }

    static var defaultQuery = LandmarkQuery()
}

AppEntity를 생성하면 defaultQuery를 기본적으로 제공해야함

쿼리를 제공하면

이런식으로 설명이노출됨

개발자가 컨트롤할 수 있는건 설명뿐

static let findIntentDescription: IntentDescription? = IntentDescription("조건에 맞는 랜드마크를 찾습니다.")

findIntentDescription에 설명을 커스텀할 수 있습니다.

기본만 제공하면 왼쪽처럼 indexingKey를 제공한 이름만 목록에 노출됨

반면에

EnumerableEntityQuery에서는 allEntities에 제공된 만큼

extension LandmarkQuery: EntityPropertyQuery {
    typealias ComparatorMappingType = (Landmark) -> Bool

    static var properties = QueryProperties {
        Property(\LandmarkEntity.$name) {
            ContainsComparator { value in { $0.name.localizedCaseInsensitiveContains(value) } }
            EqualToComparator { value in { $0.name == value } }
        }
        Property(\LandmarkEntity.$continent) {
            EqualToComparator { value in { $0.continent == value } }
        }
        Property(\LandmarkEntity.$visited) {
            EqualToComparator { value in { $0.visited == value } }
        }
    }
}

EntityPropertyQuery에서는 properties에 정의한 만큼

오른쪽화면같이 목록에 노출됨

마찬가지로 아무것도 제공안하면 왼쪽같이 모든필터가 선택가능하지만

EntityPropertyQuery에서

EqualToComparator, ContainsComparator와 같이 비교 타입을 제공하면 그 목록만 노출됨

앱 인텐트로 앱을 빌드하면 코드가 Source of Truth가 됩니다

앱 인텐트에는 설정이나 구성 파일이 필요하지 않습니다

Swift 소스 코드는 빌드 시점에 읽혀 앱 인텐트의 representation을 생성하게 됩니다

이 representation은 앱이나 프레임워크 내부에 저장됩니다

앱이 설치된 후 시스템은 이 데이터를 사용하여 앱을 실행하지 않고도 앱의 기능을 이해합니다

인텐트의 이름은 해당 동작의 고유한 식별자가 됩니다

인텐트의 title은 사용자가 인텐트를 구분할 수 있도록 하며

perform 메서드의 return 시그니처는 인텐트의 결과를 렌더링하는 방법을 설명합니다

프로세스는 실행 시점이 아닌 빌드 시점에 진행되므로 특정 값은 상수 값으로 제공되어야 합니다

App Intent는 앱의 동작 하나를 시스템에 등록하는 함수 하나로 앱이 실행중이 아니여도 시스템이 알고있습니다.

이 인텐트는

Siri, Spotlight 검색, 위젯, 동작 버튼, 제어 센터, 자동화, 단축어 에 사용합니다

따라서 단축어는 App Intent를 소비하는 기능중 하나입니다

[SwiftUI] iPad Layout 대응시 고려할점

냄수 — Tue, 30 Jun 2026 20:33:40 +0900

아이폰앱을 아이패드로 대응할때

화면크기 때문에 고려해야할 점에 대해 알아보려합니다

@Environment(\.horizontalSizeClass)

ViewTahtFits

NavigationSplitView

inspector

@Environment(\.horizontalSizeClass)

현재 뷰가 그려지는 가로 폭의 종류를 알려줍니다.

- 개발자가 직접 분기

- 화면 크기, 멀티윈도우 창에 맞는 크기로 알아서 적용

아이폰에서 값은

세로일때 = compact

가로일때 = regular

타입으로 나옵니다.

아이패드에서 값은

세로,가로 풀 사이즈 일때 = regular

멀티윈도우로 사이즈조절시 = compact

비율대로 넓어지는 UI인경우
화면이 넓어지면 2열로 변경되는 대응을 할수있습니다.

struct SizeClassDemo: View {
    @Environment(\.horizontalSizeClass) private var hSizeClass

    // 현재 상태를 화면에 보여주기 위한 보조 계산 프로퍼티들
    private var isRegular: Bool { hSizeClass == .regular }
    private var stateText: String { isRegular ? "regular" : "compact" }
    private var bannerColor: Color { isRegular ? .blue : .orange }

    var body: some View {
        VStack(spacing: 16) {
            // 현재 horizontalSizeClass 값을 알려주는 상단 배너 (상태별 배경색이 다르다)
            banner

            // 핵심 분기: 같은 콘텐츠를 폭에 따라 다르게 배치한다.
            if isRegular {
                // 넓은 화면: 목록 / 상세를 좌우로 나란히 (HStack)
                HStack(alignment: .top, spacing: 16) {
                    listPane
                    detailPane
                }
            } else {
                // 좁은 화면: 동일 콘텐츠를 위아래로 쌓는다 (VStack)
                VStack(spacing: 16) {
                    listPane
                    detailPane
                }
            }

            Spacer()
        }
        .padding()
        .navigationTitle("SizeClass 분기")
    }
}

ViewTahtFits

공간에 맞는 뷰를 선택합니다.

사용가능한 공간을 측정해, 자식을 위->아래(코드상위치) 순서로 시도하고

넘치지 않고 들어 맞는 첫번째 자식만 렌더링합니다.

- 프레임워크가 알아서 선택(if없음)

- 화면크기, 멀티윈도우 창 대응가능

- 컨테이너 뷰 크기에 대응가능 -> frame 고정시

화면 폭/회전/dynamic type등으로 공간이 달라질때, 코드분기없이 공간에 맞는 레이아웃을 자동으로 선택하고 싶을때 사용

struct ViewThatFitsDemo: View {
    // 컨테이너 폭을 직접 조절해 가며 어떤 후보가 선택되는지 관찰한다.
    @State private var width: CGFloat = 400

    var body: some View {
        VStack(spacing: 24) {
            // 현재 폭을 숫자로 표시 — 슬라이더를 움직이며 레이아웃 전환 지점을 확인한다.
            VStack(spacing: 12) {
                Text("컨테이너 폭: \(Int(width)) pt")
                    .font(.headline)
                    .monospacedDigit()
                Slider(value: $width, in: 0...700)
            }
            .padding(.horizontal)

            ViewThatFits(in: .horizontal) {
                // (1) 넓은 레이아웃: 아이콘 + 긴 텍스트 + 버튼 (가장 큰 후보)
                
                HStack(spacing: 12) {
                    Image(systemName: "wifi")
                    Text("네트워크에 연결되었습니다 연결되었습니다 연결되었습니다")
                        .lineLimit(1)
                    Button("관리") {}
                        .buttonStyle(.borderedProminent)
                }
                .candidateStyle(tint: .blue, caption: "넓은 레이아웃")

                // (2) 중간: 아이콘 + 짧은 텍스트
                HStack(spacing: 8) {
                    Image(systemName: "wifi")
                    Text("연결됨")
                        .lineLimit(1)
                }
                .candidateStyle(tint: .green, caption: "중간")

                // (3) 폴백: 아이콘만 (가장 작은 후보 — 항상 들어맞음)
                Image(systemName: "wifi")
                    .candidateStyle(tint: .orange, caption: "아이콘만")
            }
            .frame(width: width)

            Spacer()
        }
        .padding(.top, 24)
        .navigationTitle("ViewThatFits")
    }
}

ViewThatFits vs HorizontalSizeClass

실제 픽셀폭 -> ViewThatFit사용

가로길이가 600이던 1300이던 regular이기 때문에 iPad 풀스크린 세로는 구분 불가능 -> ViewThatFit으로 구분해서 사용

화면 전체 패러다임 전환, 시스템 레벨의 큰 의미 -> HorizontalSizeClass 사용

배타적으로 사용하지않고 큰 구조를 HorizontalSizeClass를 사용하고

그 안에서 디테일은 ViewThatFit으로 처리 하는 식으로 같이사용

NavigationSplitView

2단, 3단 메뉴 옵션이 존재

- side/content/detail 3단 일땐

메뉴가 side, content 2개로 이뤄져있고 메뉴를 뎁스로 하나 더 열 수 있는 구조

- 이때 만약 balanced스타일이라면 content, detail이 화면내에 존재하고 sidebar가 메뉴로 나옴

- compact모드일땐 메뉴 스타일 상관없이 동작방식이 모두 같음

- NavigationSplitViewStyle.prominentDetail: 컨텐츠 사이즈 그대로, 딤처럼 그 위에 사이드바 나옴

- NavigationSplitViewStyle.balanced: 컨텐츠가 좁아지고 사이드바 나옴(컨텐츠와 메뉴가 동등한 레벨)

2단 - balanced 스타일

주황색 - compact모드

2단 - prominentDetail 스타일

3단 - balanced 스타일

3단 - prominentDetail 스타일

inspector(isPresented: )

우측 인스펙터 패널

regular 폭(iPad) 에서는 본문 우측에 컬럼으로 붙고

compact 폭(iPhone)에서는 자동으로 sheet형식으로 적응해 표시됨

(아이폰 가로모드에서는 확인가능)

sheet과 배경색도 다르고 가로모드 햇을때 대응도 달라서 같은 용도로 사용하면 안됩니다.

.popover

아이폰

- compact: sheet으로 노출

- regular: sheet으로 노출

아이패드

- compact: sheet으로 변경되서 노출

- regular: 말풍선

.presentationCompactAdaptation(.popover) 사용시
아이폰에서도, 아이패드에서도 compact에서도 모두 말풍선으로 강제적용됨

.presentationDetents

- medium - 화면절반

- large - 전체높이

- fraction() - 화면 비율(0~1)로 지정한 커스텀 높이

- height() - 포인트 단위 고정 높이

presentationDragIndicator - 손잡이 노출옵션

presentationBackgroundInteraction - 배경과 상호작용 옵션

이옵션보다 작은 크기로 펼치면 배경 상호작용은 막힘(배경 딤처리도 달라짐)

ex) option이 medium인 경우 large일 때 배경선택해서 창닫기 가능 (상호 작용되는 경우 뒷배경 회색 딤처리)

[Swift] BGContinuedProcessingTask 백그라운드 작업

냄수 — Fri, 29 May 2026 22:11:38 +0900

백그라운드에서 작업을 돌릴 수 있는 타입에대해 알아보려합니다

백그라운드 전환 이후에도 작업을 계속 수행하고 시스템은 UI를 통해 진행 상황을 표시를 지원합니다

- 버튼 클릭이나 다른 제스처처럼 항상 명확한 사용자 행동으로 시작됩니다

- 각 작업은 즉각적이고 명확한 목표를 가지고 있습니다 (파일 내보내기 SNS 콘텐츠 게시 연결된 액세서리 업데이트 등)

- 이러한 작업은 측정 가능한 진행률을 가지고 있으며 작업이 완료됐을 때 무엇을 의미하는지 알 수 있습니다

시스템은 리소스 부족과 같은 런타임 상황에 따라 백그라운드 작업을 갑작스럽게 종료할 수 있습니다.

구현 시에는 이 작업이 준수하는 ProgressReporting 프로토콜을 사용하여 진행 상황을 보고해야 합니다.

리소스가 부족해지면 시스템은 진행 상황이 거의 없거나 전혀 없는 작업의 종료를 우선적으로 처리합니다

BGContinuedProcessingTask
- 즉시 시작 / 진행률 UI 자동 / 사용자가 기다리는 작업이라 시스템이 우호적(런타임 넉넉) / GPU·CPU·네트워크 사용 가능
- iOS 26+ 전용 / 반드시 포그라운드 사용자 액션에서 제출(서버·백그라운드 트리거 ❌) / progress 필수 / 무한은 아님(자원 압박 시 expirationHandler로 회수) / 사용자에게 보이는 작업에만 적합

기존에 쓰던 백그라운드 방식과 비교해볼까요?

  BGProcessingTask
  - 수 분 이상 긴 작업 / "충전 중·네트워크 필요" 조건 지정 가능 / 무거운 유지보수에 최적
  - 실행 시점을 시스템이 결정(즉시성 없음, 보통 밤/충전) / UI 없음 / 사용자 인지 못 함

  BGAppRefreshTask
  - 사용 패턴 학습해 "열어볼 만한 때" 갱신 / 콘텐츠 신선도 유지에 적합
  - 매우 짧음(~30s) / 시점·실행 보장 안 됨 / UI 없음

- Background Push Notifications: 서버가 원할때 푸시로 백그라운드 업데이트 진행, BGAppRefreshTask의 푸시버전

beginBackgroundTask (구형)
  - 모든 버전 / 간단 / 즉시
  - 수십 초 / 긴 작업 불가 / UI 없음 → continued가 사실상 현대적 대체재

  Background URLSession
  - 앱이 종료돼도 전송 지속, 시스템이 재시도/관리
  - 순수 다운/업로드 전용 — 임의 연산은 못 함

플로우

info.plist정의 - UIBackgroundModes키 [processing] BGTaskSchedulerPermittedIdentifiers: [식별자 identifier]
Permitted background task scheduler identifiers 배열에 새 값을 추가하고 앱 번들 ID로 시작되도록 합니다.
정적인 식별자 외에도 동적 접미사를 지원하는 와일드카드 형식을 지원합니다
BGTaskScheduler.shared.register 로 id, 큐, 작업 등록
BGContinuedProcessingTaskRequest 생성 후 BGTaskScheduler.shared.submit 제출하면 작업시작
진행 속도가 예상보다 느릴 경우 시스템은 사용자에게 작업을 계속할지 묻게 됩니다
필요한 작업 마지막에 setTaskCompleted로 작업완료 알림

키워드

BGContinuedProcessingTaskRequest

init - 제출요청 id, 시스템 UI에 최초노출될 타이틀 지정

request.strategy

실행시 전략으로 2가지가 있습니다

queue(기본): 본적으로 지속적 처리 작업을 즉시 실행할 수 없을 경우 시스템이 queue에 작업을 추가합니다
즉시 실행 불가시 큐 사용해서 가능할때까지 대기합니다
fail: 해당 작업이 당장 시작되어야만 유용할때.
작업을 queue에 넣는 대신 즉시 실행할 수 없으면 제출을 실패하게 할 수 있습니다
이를 통해 앱은 즉각적인 피드백을 받고 상황을 적절히 처리할 수 있습니다

BGContinuedProcessingTask

.progress.totalUnitCount

현재 진행 상황에 대한 추적 대상 작업 단위의 총 수

.progress.completedUnitCount

시스템UI, Live Activity, Dynamic Island용 진행률 갱신

.updateTitle(, subtitle: )

시스템UI, Live Activity, Dynamic Island용 제목 갱신

.expirationHandler

작업의 백그라운드 시간이 만료되기 직전에 호출되는 핸들러입니다.

정리/중단 된경우 처리

.setTaskCompleted(success: )

작업종료를 시스템에 알림(성공/실패)

예시코드

// 등록코드 
nonisolated func registerHandler() {
    BGTaskScheduler.shared.register(
        forTaskWithIdentifier: Self.taskIdentifier,
        using: Self.workQueue
    ) { [self] task in
        guard let task = task as? BGContinuedProcessingTask else {
            task.setTaskCompleted(success: false)
            return
        }
        // workQueue 위에서 동기적으로 작업을 수행한다.
        performWork(task)
    }
}

// 사용자가 시작버튼 (Ex: 업로드 버튼)

func start() {
    // 최초 시스템 UI 노출 타이틀지정
    let request = BGContinuedProcessingTaskRequest(
        identifier: Self.taskIdentifier,
        title: "긴 작업 진행 중",
        subtitle: "백그라운드로 전환해도 계속 진행됩니다"
    )
    // 즉시 실행할 수 없으면 큐잉 (다른 옵션: .fail = 즉시 불가 시 제출 실패)
    request.strategy = .queue

    do {
        try BGTaskScheduler.shared.submit(request)
    } catch {
        statusMessage = "작업 제출 실패: \(error.localizedDescription)"
    }
}

// 작업코드
nonisolated private func performWork(_ task: BGContinuedProcessingTask) {
    let total: Int64 = 600

    // 진행률 보고는 BGContinuedProcessingTask 에서 필수.
    task.progress.totalUnitCount = total
    
    // 만료(시스템 회수/강제 종료) 시 루프를 중단시키기 위한 플래그.
    let isCancelled = Locked(false)
    task.expirationHandler = {
        isCancelled.set(true)
    }

    publishStatus("작업 시작")

    var step: Int64 = 0
    while step < total {
        if isCancelled.get() {
            task.setTaskCompleted(success: false)
            return
        }

        // 1초 단위의 더미 작업 시뮬레이션
        Thread.sleep(forTimeInterval: 1.0)
        step += 1

        // 시스템 UI(Live Activity / Dynamic Island)용 진행률 + 제목 갱신
        task.progress.completedUnitCount = step
        task.updateTitle("긴 작업 진행 중", subtitle: "\(step)/\(total)초 완료")
        
    }
    task.setTaskCompleted(success: true)

    // 로컬 푸시 알림
    sendCompletionNotification()
}

스크린샷

[Swift] Protocol Buffer (Protobuf)

냄수 — Tue, 28 Apr 2026 21:24:17 +0900

protobuf를 쓸일이 생겨서 학습한 내용을 정리해보려합니다

Protobuf가 무엇이고

왜 쓰며

어떻게 동작하는지 간단하게 알아보겠습니다

Protocol buffer란?

Google에서 개발하고 오픈소스로 공개한 데이터 직렬화 시스템

구조화된 데이터를 스키마(.proto) 로 정의하고

이를 기반으로 각 언어의 객체 형태와 작고 빠른 바이너리 형식으로 직렬화 / 역직렬화할 수 있게 해주는 프레임워크

입니다.

직렬화란

메모리 안의 객체나 데이터를 저장하거나 전송 할 수 있는 형태로 변환하는 걸 말해요

swift에서는 아래처럼 통신할때 많이사용해본 경험이 있으시죠?

let jsonData = try JSONSerialization.data(withJSONObject: ...)

이런것을 protobuf는 json처럼 text형태가아니라 이진 바이너리 데이터로 주고받는 직렬화를 사용합니다

그럼 왜 이렇게 쓰는걸까요?

- 서버와 앱이 같은 데이터 구조를 서로 다르게 해석하는 문제

- 수동 JSON 파싱에서 생기는 타입 불일치와 런타임 에러

- JSON, XML와 같은 텍스트 기반 포맷의 크기와 파싱 비용 문제

- 구버전/신버전 호환성 문제

와 같은 문제를 해결하기 위해서 고안됐습니다.

특징

경량화된 바이너리 포맷

텍스트가 아닌 바이너리 형식으로 전송과 저장공간 측면에서 효율적

빠른 직렬화 / 역직렬화

JSON 대비 처리속도가 빠르고 성능이 중요한 환경에서 유리

스키마 기반 구조

.proto 파일에 구조와 타입을 명시하여 서버와 클라이언트가 같은 데이터 구조를 가져갈 수 있음

다양한 언어 지원

.proto 파일하나로 swift, kotlin, go, python, 등 코드 생성 가능

코드 자동생성

스키마 기반으로 각 언어 코드 자동생성으로 개발 생산성 높아짐

호환성

새 필드 추가시 구버전에서는 해당 필드 무시하고 동작하여 구버전 클라이언트 호환이 가능함

간단하게 어떻게 동작하는지 알아볼게요

동작

컴파일러 설치 - 컴파일러인 protoc 설치

⬇️

스키마 정의 - .proto 파일에 데이터 구조정의(syntax, package, message, field 정보)

⬇️

코드 생성 - protoc 사용해서 각 언어 코드로 변환

⬇️

직렬화 - 객체를 protobuf 형식의 바이너리 데이터로 변환

⬇️

데이터 전송

⬇️

역직렬화 - 전달받은 데이터를 동일한 .proto 스키마를 기준으로 다시 객체로 변환

스키마

어떤 종류의 타입들이 있는지 알아볼게요

syntax

protobuf 문법 버전 지정

proto2, proto3이 있고

최신이 3이라 보통 3을 많이사용하고있어요

package

네임스페이스로 사용

프로젝트가 커졌을때 중복을 방지합니다.

message

protobuf에서 데이터를 표현하는 기본 단위

swift에서 구조체와 비슷한 개념

message Person {
    int32 id = 1;          // 정수형 ID(필드 번호 1)
    string name = 2;        // 이름(필드 번호 2)
    string email = 3;       // 이메일(필드 번호 3)
    bool is_active = 4;     // 활성화 여부(필드 번호 4)
    repeated int32 scores = 5; // 여러 개의 정수형 점수(필드 번호 5)
}

각 필드는 필드 번호를 갖고

직렬화 된 바이너리 데이터에서 필드를 식별하기위한 번호로 message내에서 유니크해야함

대응 되는 타입은 문서를 보고 맞춰서 사용하면 됩니다.

https://github.com/apple/swift-protobuf/blob/main/Documentation/API.md

swift-protobuf/Documentation/API.md at main · apple/swift-protobuf

Plugin and runtime library for using protobuf with Swift - apple/swift-protobuf

github.com

이제 바이너리 데이터 구성을 한번 살펴볼까요?

구성

크게 tag와 payload 데이터로 이뤄집니다.

여기서 wire type이란 데이터가 어떻게 인코딩 되었는지 알려주는 태그로

6개중 2개는 디프리케이트되서 이제 4개를 사용합니다.

parser는 wire type을 보고 데이터 유형에따라서 이 뒤를 몇 바이트로 읽는지 판단하게됩니다.

wire type중 제일 많이 사용하는

VARINT 방식과 LEN방식에 대해서만 알아보도록할게요

VARINT 타입 - Vairable Integer

정수를 가변 길이로 저장

각 바이트의 맨 앞 1비트(MSB, 최상위비트)는 "계속/끝"을 표시하는 플래그

나머지 7비트들만 이어 붙인다는 규칙이 존재함

위 그림만 봐서는 이해가안가니까 더 자세히 계산해보겠습니다.

field_number가 1이고

field_number에 3비트를 쉬프트하는건 공식문서에서 하는 계산식이기 떄문에 그대로 따라줍니다.

varint는 wire type 0이므로

1000이랑 0과 or연산해서

00001000 -> tag값인 08 값을 얻었습니다.

다시한번 복습하면

tag + payload로 이뤄지므로

payload 즉 이제 데이터를 넣어줄차례입니다.

a = 150이엿으니

2진수로 변경하고 -> 7비트씩 구분합니다 -> 순서를 앞뒤로 바꿔주고 -> MSB에 알맞게 1과 0을 넣어줍니다

그렇게해서 다시 계산하면 십진수로 150과 1이나오는데

이걸 16진수로 변경하면 96과 01이 결과적으로 나오게됩니다.

따라서 최종 데이터는 08 96 01 이됩니다.

LEN타입 - Length-delimited

태그 바로뒤에 varint로 데이터 길이 지정해서 쓰고 뒤에 실제 데이터를 저장하는 방식

varint와 다르게 정해진 데이터 길이만큼만 뒤에 데이터가 존재합니다.

tag + length + payload 형태입니다.

field number 2에 testing값을 len으로 작성할거니까

2 << 3 에 len 타입은 2이므로

2 << 3 | 2 가 됩니다.

tag값으로는 16진수로 12를 얻을 수 있습니다.

그다음에는 varint와 다르게 데이터의 길이를 나타내는 값을 제공합니다

testing은 UTF-8로 7바이트이므로 길이 7을 나타냅니다

따라서 07입니다.

그뒤에는 UTF-8로 변환한 testing값을 넣어주면됩니다.

따라서 최종 데이터는 12 07 [74 65 73 74 69 6e 67] 형태가됩니다.

JSON으로 만들면 대괄호, 따옴표, 콤마, 텍스트 포맷위한 데이터를 다 포함해서 더 용량이 크고

바이너리 데이터로 만들면 이런 불필요한 데이터는 줄일 수 있어서

JSON으로 만들었을때보다 데이터 용량이 작은 장점이 있기 때문에

gRPC의 데이터 전송방법으로 쓰이고

실시간 스트리밍이나 고성능이 필요한곳에서 많이 적용되고있습니다.

사용예시

이 protobuf를 프로젝트에서 사용하는 방법은 2가지가 있습니다.

1. 라이브러리 받아서 사용하기

2. 직접 파서만들어서 사용하기

라이브러리를 사용하는경우엔

https://github.com/apple/swift-protobuf/tree/main

GitHub - apple/swift-protobuf: Plugin and runtime library for using protobuf with Swift

Plugin and runtime library for using protobuf with Swift - apple/swift-protobuf

github.com

가이드에 맞게 쉽게 사용할 수 있습니다.

애플의 공식지원이라 안전합니다.

직접 파서를 만드는 경우엔

바이너리 디코딩과 인코딩 시키는 함수작성이 필요합니다.

private func readVarint(_ data: Data, offset: inout Int) throws -> UInt64 {
    var result: UInt64 = 0
    var shift = 0
    while offset < data.count {
        let byte = data[offset]; offset += 1
        if shift > 63 { throw UpdateError.parseError("varint overflow") }
        result |= UInt64(byte & 0x7F) << shift
        if byte & 0x80 == 0 { return result }
        shift += 7
    }
    throw UpdateError.parseError("예상치 못한 데이터 끝")
}

비트를 다루는 연산이기때문에 함수가 좀 어렵게 느껴집니다.

shift: 현재 조각이 최종 숫자의 몇번째 7비트 구간인지 의미

offset = 0, data[0] = 0x96
이라면 
byte = 0x96
offset은 1증가
데이터를 소비하면서 전진하는 방식

shift > 63: UInt64범위 체크

byte & 0x7F
0x7F -> 01111111
AND연산하면 하위 7비트만 남고 맨앞비트제거
MSB버리고 실제 payload만 꺼내는 과정임

<< shift
꺼낸 7비트를 최종 숫자 올바른 위치로 이동 (재배열 역순임)
첫번재면 shift = 0, 두번째면 shift = 7
[세번째 조각 7비트][두번째 조각 7비트][첫 조각 7비트]

result |= 
현재 값에 이번에 읽은 7비트 조각 합침

이런 과정이 있습니다...

(읽기만 하는경우엔 디코딩 함수만 있어도 무방합니다.)

그리고 struct나 enum 모델도 직접 정의합니다.

proto파일이 있다면 그대로 컴파일을 돌리면 되서 편하지만

히스토리 부재로 proto 파일이 따로없다면 모델을 직접 정의해서 써야합니다

라이브러리의 유무는 직렬화와 역직렬화를 편하게 제공해주는것에서 큰차이가 있습니다.

라이브러리 사용법

마지막으로 라이브러리 사용방법을 간단하게 알아볼게요!

1. Xcode에서 SPM을 연결해줍니다

실행파일도 같이 딸려오는데 none으로 설정해서 무시하셔도됩니다(따로 설치합니다)

2. protoc를 설치해줍니다

brew install swift-protobuf

3. Xcode Build Setting에서 User Script Sandboxing 값 확인 > no 설정

(설정안하면 권한때문에 스크립트 실행이 막힙니다)

4. Build Phases 작성, Compile Sources 전 단계로 적용

전 프로젝트폴더에 testStruct.proto 파일로 구조를 정의해뒀습니다.

이 파일을 스크립트에서 작성해줬기때문에 여러분이 생성한 파일이름으로 커스텀해주세요

  export PATH="/opt/homebrew/bin:$PATH"

  OUT_DIR="${SRCROOT}/Practice_protobuf/Generated"
  mkdir -p "${OUT_DIR}"

  protoc \
    --proto_path="${SRCROOT}" \
    --swift_out="${OUT_DIR}" \
    "${SRCROOT}/testStruct.proto"

5. 빌드

빌드하면 위와같이 파일이 생성됩니다.

왼쪽의 proto파일이 오른쪽같이 swift코드로 변환됩니다

이 코드를 어떻게사용하냐면

func test() {
    let namsoo = NamSoo.with {
        $0.age = 32
        $0.job = "iOS Developer"
    }
    do {
        let binaryData = try namsoo.serializedData()    // 직렬화
        let decodeData = try NamSoo(serializedBytes: binaryData)    // 역직렬화
        let jsonData = try namsoo.jsonUTF8Data()    // json직렬화
        let decodeFromJson = try NamSoo(jsonUTF8Data: jsonData)     // json역직렬화
    } catch {
        print(error)
    }
}

처럼 간편하게 사용할 수 있습니다.

공식문서

https://protobuf.dev/programming-guides/encoding/

Encoding

Explains how Protocol Buffers encodes data to files or to the wire.

protobuf.dev

[iOS] AI 기본 개념부터 온디바이스까지 정리해보기

냄수 — Tue, 31 Mar 2026 21:22:27 +0900

AI를 공부하려고 하면 생각보다 용어가 한번에 많이 나옵니다.

머신러닝, 딥러닝, 모델, 추론, Transformer, 양자화, Core ML, Foundation Models...

이번 글에서는 기본개념을 알아보고 iOS에는 어떻게 연결되고
앞으로는 어떻게 쓰면좋을지 고민과정을 작성해보려합니다.

AI 핵심 개념과 키워드
모델은 어떻게 사용하는가
iOS에서는 어떻게 연결되는가
Python 방식과 Create ML 방식
성능최적화
나는 지금 AI를 어떻게 쓰고 있는가

(아래부터 글은 제가 정리한 자료조사를 기반으로 AI가 작성해준 글입니다.... )

AI 핵심 개념

머신러닝 (Machine Learning)

데이터를 보고 패턴을 학습해서 예측하거나 분류하는 방법입니다.

예를 들어
메일이 스팸인지 분류하거나
사용자에게 상품을 추천하는 문제를 풀 때 사용할 수 있습니다.

보통 전통적인 머신러닝에서는
사람이 어떤 특징(feature)을 넣을지 설계하는 비중이 상대적으로 컸습니다.

딥러닝 (Deep Learning)

딥러닝은 머신러닝의 한 종류입니다.

대량의 데이터와 많은 연산을 이용해서
모델이 복잡한 패턴을 스스로 학습하도록 하는 방식입니다.

이미지 인식, 음성 인식, 번역, LLM 같은 생성형 AI도
대부분 딥러닝 기반이라고 보면 됩니다.

모델 (Model)

모델은 학습이 끝난 결과물입니다.

조금 단순하게 말하면
AI의 “뇌”처럼 생각할 수 있습니다.

예를 들어 사진을 넣었을 때
“이건 고양이일 확률이 90%다”
같은 결과를 내놓는게 모델입니다.

학습 vs 추론 (Training vs Inference)

학습

데이터를 이용해서 모델 파라미터를 조정하는 과정
시간이 오래 걸리고 연산량이 큼
쉽게 말하면 배우는 단계

추론

학습이 끝난 모델로 실제 입력에 대한 결과를 반환하는 과정
서비스에서 우리가 주로 사용하는 단계
예: 사용자의 음성을 텍스트로 바꾸기

iOS 개발자 입장에서는 대부분 학습보다 추론을 더 많이 다루게 됩니다.

앱에서는 이미 만들어진 모델을 넣고
그 모델이 실제 입력에 대해 어떤 결과를 내는지 사용하는 경우가 많기 때문입니다.

모델은 어떻게 사용하는가

앱 개발에서는 보통 모델을 직접 학습시키기보다
이미 학습된 모델을 가져와 사용하는 경우가 많습니다.

Core ML 모델 포맷

애플 생태계에서는 .mlmodel, .mlpackage 형태의 모델을
Xcode에 넣어서 사용할 수 있습니다.

이미지 분류, 텍스트 처리, 음성, 예측 등
여러 작업을 Core ML 기반으로 연결할 수 있습니다.

모델 변환

실제로는 Python 환경에서 모델을 학습한 뒤
coremltools 같은 도구를 사용해서
Core ML 형식으로 변환하는 흐름이 자주 나옵니다.

즉,

Python에서 학습
-> 모델 변환
-> Xcode에 포함
-> 앱에서 추론

이런 식입니다.

ONNX

ONNX는 모델을 다른 환경으로 옮기기 쉽게 하려는 중간 표준 형식입니다.

모델 학습 프레임워크와 실행 환경이 다를 수 있기 때문에
중간 포맷을 거쳐 Core ML 쪽으로 가져오는 경우도 있습니다.

TensorFlow Lite

크로스플랫폼이나 이미 TFLite 모델을 쓰고 있는 환경이라면
TensorFlow Lite 기반으로 앱에 넣어 사용하는 방법도 있습니다.

iOS에서는 어떻게 연결되는가

Core ML이란?

Core ML은
앱이 모델을 사용할 수 있도록 해주는 상위 ML 프레임워크입니다.

입출력 관리, 모델 로드, 컴파일, 실행 경로 선택 같은 부분을 맡습니다.

즉
모델 자체를 만드는 도구라기보다
앱에서 모델을 안정적으로 실행하게 해주는 런타임 인터페이스에 가깝습니다.

Foundation Models

최근 애플은 Foundation Models 프레임워크를 통해
온디바이스 언어 모델에 접근하는 인터페이스를 제공하고 있습니다.

이 프레임워크는 Apple Intelligence를 지원하는 기기와 설정 여부에 따라 사용 가능 여부가 달라지고,
세션 기반으로 모델을 호출하며, 생성 옵션이나 구조화된 응답 형태를 다룰 수 있습니다.

개발자 입장에서는
기존처럼 직접 모델 파일을 넣어 쓰는 방식과는 조금 다르게,
애플이 제공하는 시스템 모델 능력을 앱 기능으로 연결하는 방식으로 볼 수 있습니다.

CPU / GPU / ANE

CoreML은 조건에따라 적절한 장치를 사용합니다

간단히 보면:

CPU: 제어 흐름, 범용 처리, 호환성
GPU: 병렬 연산에 유리
ANE: AI 추론에 특화된 연산 가속

전체 흐름

대략적인 구조는 이런 느낌입니다.

Your App
-> Vision / Natural Language / Speech / SoundAnalysis
-> Core ML
 -> .mlmodel / .mlpackage
 -> MLModel runtime
 -> Input / Output abstraction
 -> Compute planning
 -> CPU / GPU / Neural Engine execution
-> Low-level foundations

Python 방식과 Create ML 방식

Python 중심 방식

모델 설계부터 학습, 평가, 변환, 배포까지 전부 직접 다루는 흐름입니다.

문제 정의
데이터 수집/정리
모델 선택
학습 설정
평가
저장/변환
배포 최적화

자유도는 높지만
그만큼 복잡합니다.

Create ML

Create ML은 많은 부분을 자동화해주는 편입니다.

복잡한 연구보다
기능 구현이 목적일 때 빠르게 시도해보기에 좋습니다.

즉,

내가 AI 연구자가 되려는건 아니고
특정 기능을 앱에 넣고 싶다

이런 상황에서는 Create ML이 훨씬 실용적일 수 있습니다.

성능 최적화

온디바이스 AI는 매력적입니다.

응답이 빠르고
네트워크가 없어도 동작할 수 있고
개인정보를 서버로 보내지 않아도 되는 경우가 많습니다

하지만 그만큼
모델 크기, 메모리, 발열, 배터리, 앱 용량 같은 현실적인 문제가 따라옵니다.

그래서 온디바이스 AI는 결국 최적화가 핵심입니다.

Quantization (양자화)

개념
- 모델 숫자표현을 더 작은 정밀도로 변경하는 방법
- float32 -> int8, float16처럼 더 작은형식으로 변경
- 목적: 모델크기감소, 메모리 사용량감소, 추론속도 향상
- 온디바이스에서는 제한된 자원 안에서 모델을 실행해야하므로 매우 중요한 최적화 방식
원리
- 모델 가중치와 활성값은 정밀한 실수로 저장되는 경우가 많음
- 하지만 실제 추론에서는 항상 높은 정밀도가 필요한 것은 아님
- 따라서 더 적은 비트로 표현해도 성능 손실은 작게 유지하면서 계산량과 메모리 사용량을 줄일 수 있음
- 저장해야 하는 데이터 크기가 줄어들기 때문에 앱 용량과 로딩 비용에도 도움이 됨
활용
- 스마트폰, 임베디드 기기 등 자원이 제한된 환경에서 매우 자주 사용
- transformer, cnn처럼 큰 모델을 기기에서 실행할 때 특히 중요
- 추론 속도 개선, 전력 소모 감소, 메모리 절약 측면에서 효과적
- 다만 양자화를 너무 강하게하면 정확도 저하가 발생할 수 있어서 적절한 균형이 중요

Pruning (가지치기)

개념
- 모델 안에서 중요도가 낮은 연결, 가중치, 레이어 일부를 제거하는 방법
- 덜 중요한 부분을 잘라내서 모델을 더 가볍고 효율적으로 만듬
- 불필요한 계산을 줄여서 온디바이스 환경에 맞게 단순화하는 작업이라고 볼 수 있음
원리
- 실제로 학습이 끝난 모델에는 결과에 큰 영향을 주지 않는 가중치가 존재할 수 있음
- 이런 요소를 제거해도 전체 성능이 크게 떨어지지 않는 경우가 있음
- pruning 이후 필요하면 다시 fine-tuning을 해서 성능을 회복함
- 즉, 모델이 가진 여유분을 줄여 더 효율적인 구조로 다시 정리하는 방식
활용
- 구조적으로 잘라낸 pruning은 실제 기기 속도개선에 더 도움되는편
- 모델 크기축소, 계산량감소, 메모리절약에 사용
- 온디바이스에서는 발열과 배터리 부담을 줄이는 데에도 의미가 있음
- 단순히 작게 만드는 것보다 실제 실행 효율이 좋아지는 방향으로 적용하는 것이 중요

Model Compression

개념
- 모델을 더 작고 효율적으로 만드는 전체기법 묶음
- 양자화, pruning, distillation 등의 방식이 포함될 수 있음
- 온디바이스에서 실행 가능한 수준으로 모델을 다듬는 전체 전략이라고 볼 수 있음
원리
- 원본 모델 성능을 최대한 유지하면서 용량, 연산량을 줄이는 방향으로 변형
- 같은 일을 더 적은 자원으로 수행하게 만드는 것
- 단순히 모델을 줄이는 것이 아니라, 속도·메모리·전력·정확도 사이에서 균형을 맞추는 과정
활용
- 온디바이스에서 필수개념
- 앱크기제한, 메모리제한, 발열문제 줄이는데 중요
- 대형모델 -> 소형모델 변경시 핵심
- 실제 서비스에서는 사용자 경험을 유지하면서 배포 가능한 형태로 만드는 데 사용됨

Latency vs Accuracy trade-off

더 빠르게 응답할수록 정확도가 떨어질수도있고, 높은 정확도를 추구할수록 모델이 무거워 느려질수 있는 트레이드오프관계
온디바이스에서는 특히 응답속도가 사용자 경험에 직접 영향을 줌
예를 들어 카메라 객체인식이나 음성인식은 정확도도 중요하지만, 늦게 반응하면 사용성이 크게 떨어짐
따라서 여러 모델후보를 비교해서 적정 균형점을 찾는 것이 중요
서비스에서는 항상 최고 정확도보다, 충분히 좋은 정확도와 빠른 응답을 함께 만족하는 지점을 찾게됨

Batch vs Real-time inference

batch 추론 - 여러 입력을 한번에 묶어서 처리
- 서버로그분석, 대용량 이미지분류, 야간 일괄처리 등에 적합
- 처리 효율은 좋지만 즉각적인 응답이 필요한 상황과는 맞지않음
real time 추론 - 입력이 들어올때마다 즉시처리
- 카메라 객체인식, 음성비서, 키보드 자동완성등에 사용
- 사용자 입력에 바로 반응해야하므로 속도와 지연시간이 매우 중요
온디바이스는 대체로 real-time 이 많이사용됨
그래서 모델 정확도뿐 아니라 실행속도, 메모리 사용량, 발열까지 함께 고려해야함

그래서 이 시점의 나는 지금 AI를 어떻게 사용하고 있는가

크게 3가지로 나누어서 사용하고있습니다

개발영역과 생산성영역과 검색영역입니다.

개발

에이전트를 역할별로 나눠서 사용
- UI 구현
- 아키텍처, 성능, 보안, 스타일 검사
스킬
- 모듈 추가
- 코드 구현
- 코드 검사

개발 생산성

작업 스케줄 관리 - 옵시디언 연동
문서 작성 - 작업기반으로 작성
AI 에이전트가 수행한 작업을 md 파일로 정리
웹훅을 통해 메신저로 요약 연결

검색

개념 검색
정보 분석 및 정리
필요한 코드 초안 작성
버그 원인 탐색

Next...

26년 최근들어 하네스 라는 방식의 에이전트 팀을 이용한

에이전트끼리 워크플로우를 통해서 아웃풋을 내도록하는 방식이 화두가 되고있어요

하네스란

- 에이전트 팀 시스템을 활용하여 복잡한 작업을 전문 에이전트 팀으로 분해·조율하는 아키텍처 도구
- 궁극적으론 다른모델을써도 같은 아웃풋이나옴

가드레일을 통해 제어하고

기록과 피드백을통해 다듬어서

에이전트를 잘 운용할 수 있도록 관심이 몰리고있습니다.

이런 방식을 이용해서

명령어하나로

리드 에이전트 -(명령)-> 개발 에이전트 -> 작업

-(명령)-> 문서 에이전트 -> 작업

-(명령)-> 검증 에이전트 -> 작업

이런 과정을 알아서 할 수 있는 환경을 만들어보고싶네요

이 과정에서

주의해야할점은 AI를 어디까지 믿어야하는가가 될거같아요

완전한 신뢰는 할 수 없으니 검증은 어떻게 해야할지에 대한 고민도 필요할것 같아요

[Swift] FoundationModels

냄수 — Thu, 26 Feb 2026 21:47:51 +0900

OnDevice LLM 프레임워크인 FoundationModels에 대해서 알아보려합니다

다른 LLM은 통신을 통한다던가 혹은 기기내에서 사용하도록 OnDevice형식을 취하려면 보안과 앱용량의 trade-off를 고민했어야했는데

apple의 FoundationModels는 운영체제에 이미 존재해서 앱용량이 늘어나지 않는다고하네요

핵심타입들을 알아보고

냉장고 내에있는 재료를 통해 어떤 음식을 만들수잇는지 요청하는 데모앱을 만들어보려합니다

FoundationModels?

파운데이션 모델 프레임워크는 애플 인텔리전스를 구동하는 애플의 온디바이스 대규모 언어 모델에 대한 접근을 제공하여 사용자의 특정 사용 사례에 맞는 지능형 작업을 수행할 수 있도록 지원합니다.
텍스트 기반 온디바이스 모델은 패턴을 식별하여 사용자가 요청한 내용에 적합한 새로운 텍스트를 생성할 수 있으며, 특수한 작업을 수행하기 위해 사용자가 작성한 코드를 호출하는 결정을 내릴 수 있습니다.

파운데이션 모델 프레임워크는 두 가지 기본 안전 계층을 갖추고 있으며, 프레임워크는 다음을 활용합니다
- 민감한 주제를 신중하게 처리하도록 훈련된 온디바이스 언어 모델.
- 자해, 폭력, 성인 콘텐츠 등 유해하거나 민감한 콘텐츠가 모델 입력 및 출력에서 차단되도록 설계된 가드레일.

기기 내 언어 모델은 모든 요청을 처리하기에 적합하지 않을 수 있으며 특정 주제에 대한 요청을 거부할 수 있습니다. 문자열 응답을 생성할 때 모델이 요청을 거부하면 "죄송합니다, 도와드릴 수 없습니다"와 같이 거절로 시작하는 메시지를 생성합니다.

모델 사용 가능 여부는 다음과 같은 기기 요소에 따라 달라집니다:
- 기기가 Apple Intelligence를 지원해야 합니다.
- 기기의 설정에서 Apple Intelligence가 켜져 있어야 합니다.

SystemLanguageModel.default.availability 를 이용해서 사용가능/불가능 케이스 대응가능합니다

LanguageModelSession

모델 사용 가능 여부를 확인한 후, 모델을 호출하기 위해 LanguageModelSession 객체를 생성합니다.
단일 회화 상호작용의 경우 모델을 호출할 때마다 새 세션을 생성합니다:

다중 턴 상호작용(모델이 생성한 내용에 대한 일부 지식을 유지하는 경우)에서는 모델을 호출할 때마다 동일한 세션을 재사용합니다.

프레임워크를 사용하는 앱을 테스트할 때는 Xcode Instruments를 활용하여 요청 수행 시간 등 수행한 요청에 대한 정보를 더 자세히 파악할 수 있습니다.
요청을 수행할 때 LanguageModelSession 동안 모델이 수행한 작업을 설명하는 기록 항목에 접근할 수 있습니다.

또한 프롬프트에 대한 최상의 결과를 얻으려면 다양한 생성 옵션을 실험해야합니다.

GenerationOptions는 모델의 런타임 매개변수에 영향을 미치며, 요청할 때마다 이를 맞춤 설정할 수 있습니다.

UseCase

general - 기본 모델은 질문 답변 및 창의적 콘텐츠 생성 등 광범위한 텍스트 기반 작업, 일반적 상황에서 최상의 성능을 내도록 최적화됨
contentTagging - 주제 태그 생성, 콘텐츠 분류, 텍스트에서 특정 엔티티(예: 인물, 장소) 추출 등의 텍스트의 구조를 분석하고 특정 정보를 추출하거나 분류하는데 특화된 모델

GenerationOptions

sampling - 출력토큰 선택하는 방식

greedy선택한 경우 같은세션상태에서 같은프롬프트 입력시 항상 같은 출력(같은 버전 온디바이스 모델이면)

temperature - 출력의 다양성 조정 (높을수록 다른 결과 생성)

maximumResponseTokens - 너무 긴 응답 제한

Generable

모델이 프롬프트에 응답할 때 사용하는 프로토콜 타입

Swift 구조체나 열거형에 Generable 매크로를 주석 처리하여 모델이 프롬프트에 응답할 때 해당 유형의 인스턴스를 생성할 수 있도록 합니다

결과로 비구조적 자연어를 출력하는데 사람은 읽기쉽지만 뷰에 적용하기힘들어서 Json, csv 형식으로 변환후 사용해서

오류발생가능성이 있는데 이에 대한 해결책

GenerationGuide

Generable 유형의 속성 허용 값에 영향을 미칠 수 있도록 합니다.

@Guide 매크로로 사용

범위, 갯수제한, 패턴, 등

프로퍼티의 설명을 제공함으로써 정확도를 높일 수 있습니다.

모든 곳에 붙인다면 이 데이터도 모델이 읽어야 하는 데이터이므로 토큰 낭비와 처리속도에 영향이 있을수 있습니다.

헷갈릴만한 지점에 필요한곳만 붙여사용하는것이 좋습니다.

간단한 예제를 만들어봅시다

냉장고에 있는 재료들로 레시피를 추천해주는 기능입니다.

Session을 만들어주고

응답을 받는 방법은 2가지가 있습니다.

response(to: ) 한번에 완성된 응답받기

streamResponse(to: ) 토큰단위로 스트리밍

이때 @Generable을 사용하면 원하는 타입의 구조체로 받을 수 있습니다.

아래코드는

모델을 정의하고

세션을 설정하고

세션에 프롬프트를 입력하고

스트리밍으로 결과를 받는 과정입니다.

@Generable(description: "식재료")
struct Ingredient {
    let name: String
}

@Generable(description: "AI가 제안할 결과 레시피")
struct Recipe: Codable {
    @Guide(description: "요리이름")
    let title: String
    @Guide(description: "냉장고에 없는 추가로 필요한 재료만 리스트업")
    let ingredientsNeeded: [String]
    let instructions: [String]
    @Guide(description: "쉬움, 보통, 어려움 중 하나 선택")
    let difficulty: String
    let estimatedTime: Int // 분 단위
}

let instructions = """
    당신은 냉장고에 있는 재료로 요리를 추천해주는 전문 셰프 어시스턴트입니다.
        
        역할:
        - 사용자가 제공한 재료만으로 만들 수 있는 현실적인 레시피를 추천합니다
        - 소금, 후추, 식용유, 간장, 된장 등 기본 양념은 항상 있다고 가정합니다
        - 가정집 주방 기준으로 실현 가능한 레시피만 제안합니다
        - 조리 단계는 초보자도 따라할 수 있도록 구체적으로 설명합니다
        - 한국어로 응답합니다
        
        레시피 선정 기준:
        - 다양한 난이도(Easy / Medium / Hard)의 레시피를 균형있게 추천합니다
        - 재료 낭비 없이 가능한 많은 재료를 활용합니다
        - 영양 균형을 고려합니다
        - 요리이름에 냉장고 단어를 제외합니다.
        - 냉장고 속에 없는건 사용하지 않습니다.
    """

func makeSession() async {
    let session = LanguageModelSession(instructions: instructions)
    session.prewarm()
    self.session = session
    
    let stream = session.streamResponse(
        to: "냉장고에 있는 재료로 만들 수 있는 요리는?",
        generating: Recipe.self
    )
    do {
        for try await token in stream {
            print("token.content", token.content)
            self.displayText = token.content.instructions ?? []
            self.title = token.content.title ?? ""
        }
    } catch {
        print(error)
    }
}

실행결과를 보면

(id: FoundationModels.GenerationID(value: "0A90B228-5192-4EE1-B9AE-FF96715453CF"), title: Optional("간장 볶음밥"), ingredientsNeeded: nil, instructions: nil, difficulty: nil, estimatedTime: nil)
(id: FoundationModels.GenerationID(value: "0A90B228-5192-4EE1-B9AE-FF96715453CF"), title: Optional("간장 볶음밥"), ingredientsNeeded: Optional(["밥"]), instructions: nil, difficulty: nil, estimatedTime: nil)
(id: FoundationModels.GenerationID(value: "0A90B228-5192-4EE1-B9AE-FF96715453CF"), title: Optional("간장 볶음밥"), ingredientsNeeded: Optional(["밥"]), instructions: Optional(["냉장고에서 밥"]), difficulty: nil, estimatedTime: nil)
(id: FoundationModels.GenerationID(value: "0A90B228-5192-4EE1-B9AE-FF96715453CF"), title: Optional("간장 볶음밥"), ingredientsNeeded: Optional(["밥"]), instructions: Optional(["냉장고에서 밥을 꺼내 놓는다.", "밥 위에 간장과"]), difficulty: nil, estimatedTime: nil)
(id: FoundationModels.GenerationID(value: "0A90B228-5192-4EE1-B9AE-FF96715453CF"), title: Optional("간장 볶음밥"), ingredientsNeeded: Optional(["밥"]), instructions: Optional(["냉장고에서 밥을 꺼내 놓는다.", "밥 위에 간장과 식용유를 두르고 잘 섞는다."]), difficulty: nil, estimatedTime: nil)
(id: FoundationModels.GenerationID(value: "0A90B228-5192-4EE1-B9AE-FF96715453CF"), title: Optional("간장 볶음밥"), ingredientsNeeded: Optional(["밥"]), instructions: Optional(["냉장고에서 밥을 꺼내 놓는다.", "밥 위에 간장과 식용유를 두르고 잘 섞는다.", "밥을 냄비에 담고 끓인다"]), difficulty: nil, estimatedTime: nil)
(id: FoundationModels.GenerationID(value: "0A90B228-5192-4EE1-B9AE-FF96715453CF"), title: Optional("간장 볶음밥"), ingredientsNeeded: Optional(["밥"]), instructions: Optional(["냉장고에서 밥을 꺼내 놓는다.", "밥 위에 간장과 식용유를 두르고 잘 섞는다.", "밥을 냄비에 담고 끓인다.", "밥이 익으면 소금과 후추"]), difficulty: nil, estimatedTime: nil)
(id: FoundationModels.GenerationID(value: "0A90B228-5192-4EE1-B9AE-FF96715453CF"), title: Optional("간장 볶음밥"), ingredientsNeeded: Optional(["밥"]), instructions: Optional(["냉장고에서 밥을 꺼내 놓는다.", "밥 위에 간장과 식용유를 두르고 잘 섞는다.", "밥을 냄비에 담고 끓인다.", "밥이 익으면 소금과 후추로 간을 맞춘다."]), difficulty: Optional(""), estimatedTime: nil)
(id: FoundationModels.GenerationID(value: "0A90B228-5192-4EE1-B9AE-FF96715453CF"), title: Optional("간장 볶음밥"), ingredientsNeeded: Optional(["밥"]), instructions: Optional(["냉장고에서 밥을 꺼내 놓는다.", "밥 위에 간장과 식용유를 두르고 잘 섞는다.", "밥을 냄비에 담고 끓인다.", "밥이 익으면 소금과 후추로 간을 맞춘다."]), difficulty: Optional("Easy"), estimatedTime: Optional(10))

냉장고에 밥이있어도 밥을 없다고 인식하고 필요한 재료라고 추가하거나

또다른 결과로는 냉장고에 없는 재료를 마음대로 추가해서 작성하는 기대하지않은 결과가 발생합니다

이럴때 질문에 좀더 특수화된 도구를 추가할 수 있습니다.(혹은 프롬프트를 더 자세하고 상세하게 입력해도 가능합니다)

Tool프로토콜을 준수해서 정의해줄 수 있습니다.

Tool

AI모델이 사용자 요청분석후 답변 작성대신 요청해결을 위해서 도구가 필요하다고 판단하는 과정입니다.

간단하게 프로세스를 적용해보면

사용자: 오늘 뭐 만들까?

모델: 정의된 tool 호출

도구: 냉장고에 있는 재료반환

모델: 요리 추천 및 부족한 재료 파악

도구를 만들어서 넣어주면 필요할때 가져다 쓴다라고 했지만

생각보다 도구가 호출이 항상되지 않더라구요

구조를 변경하고 조건을 변경해서 적용한 코드입니다.

let instructions = """
    당신은 요리 레시피를 추천해주는 전문 셰프 어시스턴트입니다.

    반드시 지켜야 할 규칙:
    1. 레시피 추천 전 반드시 get_ingredients 도구를 호출하여 사용 가능한 재료를 먼저 확인하세요.
    2. get_ingredients 도구가 반환한 재료만 사용합니다.
    3. 요리 이름(title)에 반드시 실제 요리 이름을 사용하세요 (예: 감자볶음, 순두부찌개, 햄볶음밥).
    4. 조리 단계는 초보자도 따라할 수 있도록 구체적으로 설명합니다.
    5. 한국어로 응답합니다.
    6. 만들 수 있는 요리가 없다면 현재 재료로는 만들 수 없다고 말해줍니다.
    """


let prompt = "사용 가능한 재료를 먼저 확인한 후, 그 재료들로만 만들 수 있는 요리를 하나 추천해줘"


@Generable(description: "식재료")
struct Ingredient: Hashable {
    let name: String
}

@Generable(description: "AI가 제안할 결과 레시피")
struct Recipe {
    @Guide(description: "실제 요리 이름을 사용. 예: 감자볶음, 순두부찌개, 햄볶음밥")
    let title: String
    @Guide(description: "요리에 필요한 재료")
    let ingredients: [String]
    @Guide(description: "조리 단계 목록. get_ingredients 도구로 확인한 재료만 사용")
    let instructions: [String]
    @Guide(description: "쉬움, 보통, 어려움 중 하나 선택")
    let difficulty: String
}

모델 정의와 프롬프트를 다시 정의했고

응답으로 사용할 구조체타입들도 더 상세하게 정의했습니다.

struct FridgeIngredientsTool: Tool {
    var name: String { "get_ingredients" }
    var description: String {
        "사용 가능한 재료 목록을 조회합니다. 레시피 추천 전 반드시 먼저 호출해야 하며, 이 도구가 반환한 재료만 레시피에 사용할 수 있습니다."
    }

    // 앱의 재료 저장소를 참조
    var ingredients: Set<String>
    
    init(ingredients: [Ingredient]) {
        self.ingredients = Set(ingredients.map { $0.name })
    }

    @Generable
    struct Arguments {
        @Guide(description: "레시피로 만들 요리")
        let food: String
    }

    // 언어 모델은 이 도구를 활용하고자 할 때 이 메서드를 호출합니다.
    func call(arguments: Arguments) async throws -> String {
        let list = ingredients.map { "\($0)" }.joined(separator: ",")
        print(" ", #function, "\nlist", arguments)
        return """
            사용 가능한 재료 목록 (이 재료만 레시피에 사용 가능):
            \(list)

            위 목록에 없는 재료는 레시피에 포함하지 마세요.
            """
    }
}

도구는 위와 같이만들었는데

이렇게 정의를해도 없는 재료를 넣는과정이있는데

도구가 호출되면 정상적으로 정의된 재료내에서 요리를하는데

도구가 호출되지 않으면 없는재료를 추가해서 만드는것 같습니다.

써본결과

지침과 프롬프트를 잘 다듬어서 테스트하면서 기대하는 대답이 나오는지 확인이 필요한것 같습니다.

도구가 호출되지 않는다면 Arguments 가이드와 설명을 좀더 다듬어 보는걸 추천합니다.

수정시 "절대 하지마세요", "주의"와 같이 강제로 부정적인 느낌의 명령은

Apple FoundationModels의 안전 가드레일(guardrail)이 발동되서 에러를 발생시킬 수 있으니 조심해야합니다.

Arguments의 정의에 따라서도 응답의 질이 달라지고

call 함수의 필터를 통해서도 질이 달라집니다.

지금까지 적용한 동작흐름은 아래와 같습니다.

모델지침으로 세션 생성

⬇️

세션 prewarm

⬇️

세션에 프롬프트 입력

⬇️

AI가 필요한 도구선택후 호출 (Argument로 AI가 선택한 요리 값 전달)

⬇️

call함수에서 현재 냉장고(뷰모델 배열 데이터)에 있는 재료들 반환 및 추가적인 프롬프트 적용

⬇️

도구에서 반환받은 재료를 바탕으로 Recipe타입에 맞게 모델화

⬇️

stream으로 Recipe모델 받아옴

⬇️

뷰로 노출

소스없는 순두부찌개를 만들어서

만능소스를 추가해줬더니 더맛잇게 만드네요
(순두부찌개에 김을 넣네요... 첨봤...)

잘다듬어서 Tool로 정의한 도구가 정상적으로 호출되고 가지고있는 재료들만으로 요리를 만들지만

가끔씩은 구조가 정확하지않아서

decodingFailure(FoundationModels.LanguageModelSession.GenerationError.Context(debugDescription: "Failed to extract content", underlyingErrors: []))

에러를 반환하기도합니다.

하지만 재실행하면 정상적인 결과를 얻을 수 있습니다.

(더 다듬어서 에러도 발생하지 않도록 해야합니다.)

계속 실행해봅시다 ~

도구가 잘호출되지만

순두부찌개에 밥을 넣어서 끓이는걸 볼 수 있습니다... 이건 순두부찌개 죽인데...

또한 김치가 없지만 김치찌개를 추천하고 김치를 사용해버립니다.

강제로 김치를 제거해보니 김으로 대치해서 레시피를 작성합니다

김이 있다고 김치라고 생각하는것 같네요

  call(arguments:) 
list Arguments(food: "김치찌개")
  call(arguments:) 
list Arguments(food: "순두부김밥")
  call(arguments:) 
list Arguments(food: "김밥")
  call(arguments:) 
list Arguments(food: "김밥")
content: PartiallyGenerated(id: FoundationModels.GenerationID(value: "E9D6948E-1AF8-400D-88EA-D33014AB36E3"), title: Optional("김밥"), ingredients: Optional([""]), instructions: nil, difficulty: nil)
content: PartiallyGenerated(id: FoundationModels.GenerationID(value: "E9D6948E-1AF8-400D-88EA-D33014AB36E3"), title: Optional("김밥"), ingredients: Optional(["밥", "김"]), instructions: Optional([""]), difficulty: nil)
content: PartiallyGenerated(id: FoundationModels.GenerationID(value: "E9D6948E-1AF8-400D-88EA-D33014AB36E3"), title: Optional("김밥"), ingredients: Optional(["밥", "김"]), instructions: Optional(["밥을 김에 말아주세요.", "햄"]), difficulty: nil)
content: PartiallyGenerated(id: FoundationModels.GenerationID(value: "E9D6948E-1AF8-400D-88EA-D33014AB36E3"), title: Optional("김밥"), ingredients: Optional(["밥", "김"]), instructions: Optional(["밥을 김에 말아주세요.", "햄을 넣어주세요."]), difficulty: Optional(""))
content: PartiallyGenerated(id: FoundationModels.GenerationID(value: "E9D6948E-1AF8-400D-88EA-D33014AB36E3"), title: Optional("김밥"), ingredients: Optional(["밥", "김"]), instructions: Optional(["밥을 김에 말아주세요.", "햄을 넣어주세요."]), difficulty: Optional("쉬움"))

같은 김밥인데 왜 하나는 건너뛰고 하나는 되는건지 궁금해서 디버깅해보니

이렇게 같은 김치찌개여도 필요하다고 생각하는 재료를 다르게 생각합니다

그와중에 김밥에 김과 김치를 사용하는군요...

아직 성능이 의심스럽습니다...

정리하면 FoundationModel을 사용하기위해서 아래는 기본적으로 필요합니다.

LLM

- LanguageModelSession의 지침 정의

- Tool 정의(Arguments, call함수)

- 응답 모델로 사용할 Generable과 Guide정의

사용자

- 프롬프트 정의

- response방식 선택(stream, 단일)

간단하게 FoundationModel을 사용해봤는데요

하는 과정에서 겪은 이슈들로는

- 도구가 호출이 안될때가 많음 -> 프롬프트와 지침으로 도구사용을 유도할 수 있도록 잘 작성해야할 것 같아요

- 다른 데이터로 명령을 수행함 -> ai가 상상해서 행동하지않도록 좀더 자세한 예시와 명령을 해야할 것 같아요

[Swift] Core Image Filter

냄수 — Tue, 27 Jan 2026 22:46:12 +0900

이미지에 필터를 적용하는 작업을 해볼겁니다

Core Image를 사용합니다.

제일 쉬운 블러를 빠르게 적용해보고
(이건 UIKit에서도 제공해서 적용하긴쉽긴하지만 커스텀하기엔 더 low level인 Core Image 좋습니다.)

모자이크와 색감필터 효과들도 적용해보려합니다

Core Image란?

Core Image는 정지 영상 및 동영상에 대한 실시간에 가까운 처리를 제공하도록 설계된 이미지 처리 및 분석 기술입니다.

Core Graphics, Core Video, Image I/O 프레임워크의 이미지 데이터 유형을 기반으로 작동하며, GPU 또는 CPU 렌더링 경로를 사용합니다.

Core Image는 사용하기 쉬운 애플리케이션 프로그래밍 인터페이스(API)를 제공함으로써 저수준 그래픽 처리의 세부 사항을 숨깁니다.

GPU의 성능을 활용하기 위해 OpenGL, OpenGL ES 또는 Metal의 세부 사항을 알 필요도 없으며, 멀티코어 처리의 이점을 얻기 위해 Grand Central Dispatch(GCD)에 대해 알 필요도 없습니다.

Core Image가 세부 사항을 처리해 줍니다.

앞으로 사용하게될 CIImage는 이미지가 아니라 이미지를 생성하는데 필요한 정보입니다.

https://developer.apple.com/library/archive/documentation/GraphicsImaging/Conceptual/CoreImaging/ci_intro/ci_intro.html#//apple_ref/doc/uid/TP30001185

About Core Image

About Core Image Core Image is an image processing and analysis technology designed to provide near real-time processing for still and video images. It operates on image data types from the Core Graphics, Core Video, and Image I/O frameworks, using either

developer.apple.com

https://developer.apple.com/library/archive/documentation/GraphicsImaging/Reference/CoreImageFilterReference/index.html#//apple_ref/doc/filter/ci/CIBoxBlur

Core Image Filter Reference

developer.apple.com

필터 정보나 Core Image 가이드는 여기서 확인하세요!

CIFilter이란..?

CIImage → CIFilter → output CIImage → CIFilter → output CIImage → … 방식으로

CIImage에 효과를 적용하는데 사용하는 타입입니다.

2번째링크를 눌러서 필터종류중에 블러쪽을 보면 이렇게생겼습니다.

CIFilter를 만드는 방법은 2가지가 있습니다.

import CoreImage.CIFilterBuiltins

func applyBlur(originImage: CIImage) {
    let blurFilter = CIFilter.boxBlur()
    blurFilter.inputImage = originImage
    blurFilter.radius = 10
}

func applyBlur2(originImage: CIImage) {
    let filter = CIFilter(name: "CIBoxBlur")
    filter?.setValue(originImage, forKey: kCIInputImageKey) // 적용할 이미지
    filter?.setValue(10, forKey: kCIInputRadiusKey) // 강도
}

1. import CoreImage.CIFilterBuiltins를 통해 CIFilter의 타입값으로 사용하는 방법

2. 직접 필터 문자열을 적용해서 kCI 상수값을 사용하는방법

결과는 똑같으니 취향에 맞게 사용하면 좋을거 같아요

만약에 여러 필터를 적용하고 싶다면??

체이닝을 통해서 적용 하면 됩니다.

모든 Core Image 필터는 출력 CIImage 객체를 생성하므로, 이 객체를 다른 필터의 입력으로 사용할 수 있습니다.

예를 들어, 그림 1-1에 표시된 필터 시퀀스는 이미지에 색상 효과를 적용한 다음, 광채 효과를 추가하고, 마지막으로 결과물에서 일부 영역을 잘라냅니다.

Core Image는 이와 같은 필터 체인의 적용을 최적화하여 결과를 빠르고 효율적으로 렌더링합니다.

체인 내 각 CIImage 객체는 완전히 렌더링된 이미지가 아니라, 단순히 렌더링을 위한 "레시피"에 불과합니다.

Core Image는 각 필터를 개별적으로 실행하여 볼 수 없는 중간 픽셀 버퍼를 렌더링하는 데 시간과 메모리를 낭비할 필요가 없습니다.

대신 Core Image는 필터를 단일 작업으로 결합하며, 다른 순서로 적용해도 동일한 결과를 더 효율적으로 생성할 수 있다면 필터의 순서를 재구성할 수도 있습니다.

그림 1-2는 그림 1-1의 예시 필터 체인을 더 정확하게 표현한 것입니다.

그림 1-2에서 크롭 작업이 마지막에서 첫 번째로 이동했음을 확인하십시오. 이 필터는 원본 이미지의 넓은 영역이 최종 출력에서 잘려나가는 결과를 초래합니다. 따라서 해당 픽셀에는 색상 및 선명도 필터를 적용할 필요가 없습니다. 크롭 작업을 먼저 수행함으로써 Core Image는 비용이 많이 드는 이미지 처리 작업이 최종 출력에 표시될 픽셀에만 적용되도록 보장합니다.

모든영역을 필터처리하는 연산이 비싸기때문에

크롭을 먼저 적용하고 필터처리해주는 작업을 개발자가 신경쓰지않아도

비용이 적은방향으로 자동으로 최적화가 이뤄진다고합니다

원하는 영역에 필터를 적용해보는 연습을위해서

블러필터를 구현해보고

이미지의 반만 크롭해서 적용후에

비교를위해서 가운데에 선을 그려보는 구현까지

시작해보겠습니다

    
    private func applyBlur(image: UIImage) -> UIImage {
        /// 기기 사이즈에 대응하는 이미지 가로길이
        let imageWidth: CGFloat = UIDevice.screenWidth
        /// 기기 사이즈에 대응하는 이미지 세로길이
        let imageHeight: CGFloat = imageWidth * image.size.height / image.size.width
        /// 이미지뷰의 사이즈
        let imageViewSize: CGSize = .init(width: imageWidth, height: imageHeight)
        /// 이미지 해상도
        let imageSize: CGSize = image.size
        let render = UIGraphicsImageRenderer(size: .init(width: imageWidth, height: imageHeight))
        
        let lineWidth: CGFloat = 3
        let lineColor = CGColor(red: 1, green: 0, blue: 0, alpha: 0.6)
        
        let newImage = render.image { context in
            image.draw(in: .init(origin: .zero, size: imageViewSize))
            /// 가로 반만 필터적용
            let halfWidthPixelRect: CGRect = .init(
                origin: .zero,
                size: .init(width: imageSize.width/2, height: imageSize.height)
            )
            let cropImage = blurWithCrop(
                image: image,
                cropPixel: halfWidthPixelRect
            )
            cropImage.draw(
                in: .init(
                    origin: .zero,
                    size: .init(width: imageWidth/2, height: imageHeight)
                )
            )
            
            // 필터적용 구분선
            context.cgContext.setStrokeColor(lineColor)
            context.cgContext.setLineWidth(lineWidth)
            context.cgContext.setLineDash(phase: 1, lengths: [10,10])
            context.cgContext.move(to: .init(x: imageWidth / 2, y: 0))
            context.cgContext.addLine(to: .init(x: imageWidth / 2, y: imageHeight))
            context.cgContext.strokePath()
        }
        
        return newImage
    }
    
    private func blurWithCrop(image: UIImage, cropPixel cropRect: CGRect) -> UIImage {
        if let cropImage = image.cgImage?.cropping(to: cropRect) {
            let blurImage = filterFactory.applyBlur(originImage: CIImage(cgImage: cropImage))
            return blurImage
        }
        return image
    }

// ImageFilter.swift 

final class ImageFilter {
    let ciContext: CIContext = .init()
    
    func applyBlur(originImage: CIImage) -> UIImage {
        let blurFilter = CIFilter.boxBlur()
        blurFilter.inputImage = originImage
        blurFilter.radius = 10
        
        if let ciImage = blurFilter.outputImage,
           let cgImage = ciContext.createCGImage(ciImage, from: ciImage.extent) {
            return UIImage(cgImage: cgImage)
        }
        
        return UIImage(ciImage: originImage)
    }
}

원본과 필터를 적용한 이미지입니다.

잘적용되는게 보이네요

이번엔 모자이크필터와 색상필터를 구현해서 적용해볼게요

여러 필터를 적용할수있도록 코드를 정리해서 적용해볼까요

// ViewModel.swift

@Observable
final class ViewModelOnlyFilter {
    enum FilterOption {
        case sepia
        case mosaic
        case blur
    }
    
    var maskImages: [UIImage] = []
    private var images: [UIImage] = []
   
    private let filterFactory = ImageFilter()
    
    init() {
        setupImage()
        maskImages = images.map {
            // 원하는 필터적용부분
            applyFilter(image: $0, filter: .blur)
        }
    }
    
    private func setupImage() {
        self.images = [
            UIImage(resource: ._8),
            UIImage(resource: ._10),
            UIImage(resource: .이미지6),
            UIImage(resource: .이미지1),
            UIImage(resource: .이미지2),
        ]
    }
    
    private func applyFilter(image: UIImage, filter: FilterOption) -> UIImage {
        /// 기기 사이즈에 대응하는 이미지 가로길이
        let imageWidth: CGFloat = UIDevice.screenWidth
        /// 기기 사이즈에 대응하는 이미지 세로길이
        let imageHeight: CGFloat = imageWidth * image.size.height / image.size.width
        /// 이미지뷰의 사이즈
        let imageViewSize: CGSize = .init(width: imageWidth, height: imageHeight)
        /// 이미지 해상도
        let imageSize: CGSize = image.size
        let render = UIGraphicsImageRenderer(size: .init(width: imageWidth, height: imageHeight))
        
        let lineWidth: CGFloat = 3
        let lineColor = CGColor(red: 1, green: 0, blue: 0, alpha: 0.6)
        
        /// 가로 반만 필터적용
        let halfWidthPixelRect: CGRect = .init(
            origin: .zero,
            size: .init(width: imageSize.width/2, height: imageSize.height)
        )
        let cropImage: UIImage = applyFilterWithCrop(
            image: image,
            cropPixel: halfWidthPixelRect,
            filter: filter
        )
        let newImage = render.image { context in
            image.draw(in: .init(origin: .zero, size: imageViewSize))
            cropImage.draw(
                in: .init(
                    origin: .zero,
                    size: .init(width: imageWidth/2, height: imageHeight)
                )
            )
            // 중앙 세로선 그리기
            context.cgContext.setStrokeColor(lineColor)
            context.cgContext.setLineWidth(lineWidth)
            context.cgContext.setLineDash(phase: 1, lengths: [10,10])
            context.cgContext.move(to: .init(x: imageWidth / 2, y: 0))
            context.cgContext.addLine(to: .init(x: imageWidth / 2, y: imageHeight))
            context.cgContext.strokePath()
        }
        
        return newImage
    }
    
    private func applyFilterWithCrop(
        image: UIImage,
        cropPixel cropRect: CGRect,
        filter: FilterOption
    ) -> UIImage {
        /// 필요영역만 크롭후 필터적용해서 그려주는 방법
        if let cropImage = image.cgImage?.cropping(to: cropRect) {
            /**
             UIKit, CoreImage 좌표다름 주의
             cgContext이용
             해상도는 원본이미지 Pixel사이즈기준으로 크롭해야해서 해상도 변경전 rect으로해야함 주의
             그릴땐 해상도 변경후 테두리좌표에 그려야함 주의
             */
            switch filter {
            case .sepia:
                return filterFactory.applySepiaTone(image: CIImage(cgImage: cropImage))
            case .mosaic:
                return filterFactory.applyPixelate(image: CIImage(cgImage: cropImage))
            case .blur:
                return filterFactory.applyBlur(image: CIImage(cgImage: cropImage))
            }
        }
        return image
    }
}

// ImageFilter.swift

final class ImageFilter {
    let ciContext: CIContext = .init()
    
    func applySepiaTone(image: CIImage) -> UIImage {
        let filter = CIFilter.sepiaTone()
        filter.inputImage = image
        filter.intensity = 0.8
        
        if let ciImage = filter.outputImage,
           let cgImage = ciContext.createCGImage(ciImage, from: ciImage.extent) {
            return UIImage(cgImage: cgImage)
        }
        
        return UIImage(ciImage: image)
    }
    
    func applyPixelate(image: CIImage) -> UIImage {
        let pixelateFilter = CIFilter.pixellate()
        pixelateFilter.inputImage = image
        pixelateFilter.scale = 7
        
        if let ciImage = pixelateFilter.outputImage,
           let cgImage = ciContext.createCGImage(ciImage, from: ciImage.extent) {
            return UIImage(cgImage: cgImage)
        }
        
        return UIImage(ciImage: image)
    }
    
    func applyBlur(image: CIImage) -> UIImage {
        let blurFilter = CIFilter.boxBlur()
        blurFilter.inputImage = image
        blurFilter.radius = 10
        
        if let ciImage = blurFilter.outputImage,
           let cgImage = ciContext.createCGImage(ciImage, from: ciImage.extent) {
            return UIImage(cgImage: cgImage)
        }
        
        return UIImage(ciImage: image)
    }
}

2025 회고

냄수 — Wed, 31 Dec 2025 23:13:59 +0900

25년 한 해를 돌아보면서 정리하는 시간을 가져보려합니다

# 월별 기록

1월

일이 적적한 시즌이라 스스로 일을 만들어내면서 했어요

이것저것 어색하거나 성능적인부분을 리팩토링하고

앱테스트시 컨트롤쉽도록 개발했어요

그 유명하다는 하이디라오를 처음가서 먹어봣어요

웨이팅을 몇시간전에 미리걸어두고 갔던 기억이나네요

2월

CRM도구를 연결하는 일을했어요

유다빈밴드 - 좋지아니한가 밴드합주를 했어요

매쉬업의 파트장을 맡게되서 면접관으로 참가했어요

3월

광고 SDK를 전체적으로 변경하는 일을했어요

매쉬업활동이 본격적으로 시작하면서

이 나이에..? 1달에 엠티를 2번이나 가게됬네요

WWDC 스터디와 모듈화 스터디를 진행했어요

4월

유다빈밴드 - 사포닌 같은 너 밴드합주를 했어요

건강검진을 받았어요

전회사보다 검진종목이 많이없어서 아쉬웠어요

매쉬업 프로젝트 아이디어회의를 많이 진행했어요

5월

심심해서 춤이나 춰볼까하다가

정말 제니 - like JENNIE 춤을 배우고 추게됬어요

클라이밍 기록을 잘안했었는데 기록을 시작했어요

본격적으로 뭔가 재밌고 흥미가 붙어서 자주하게 됬어요

6월

광고 이슈와 crash 이슈들을 해결했어요

매쉬업에서 해커톤도 하고 본격적인 프로젝트 개발을 했어요

WWDC25가 있던 달이에요 영상들을 챙겨보기 시작했어요

VisionOCR을 학습하면서 데모앱을 만들었어요

7월

WWDC가 나오고 새버전이 올라갈 예정임에따라서 미니멈타겟 상향을 고려하고

변경시 대응해야할 이슈들을 체크했어요

아이들 - 아픈건 딱 질색이니까 밴드합주를 진행했어요

8월

주변 친구들이 결혼을 많이하는 시즌이되고 있어요

청모를 가기 시작했어요

양양으로 서핑을 갔다왔어요

이때 인식이 좀 안좋기도했고 성수기 전이라 그런지 사람이 생각보다 없고 휑 했던거같아요(개꿀이였어요)

9월

음율 - 피차일반 밴드합주를 했어요

렛츠락페스티벌을 갔어요

한번쯤 도전해보고싶어서 살면서 처음 가본 페스티벌이였어요

DeviceActivity에 대해서 학습하면서 적용해볼수 있는 아이디어를 고민했어요

메시지필터에서 이벤트를 기록하려고 여러방법을 시도했지만 실패를 맛봤어요

클라이밍 첫핑크를 풀었어요(1~11단계중 7단계)

10월

KISA에서 소명서가 날라와서 대응하는 작업을했어요

이런부분도 날라오는구나.. 새로운 경험을 했어요

iOS26 디자인 대응을 했어요

흑백요리사에 나왔던 포노 부오노, 티엔미미 를 가봤어요

지출이 조금 크지만 후회없이 맛있게 먹은 좋은 경험이였어요

11월

딥링크를 구현했어요

크라임씬 방탈출을 했어요 재밌어서 1번 더 예약해서 1달에 2번에나 했어요

화담숲예약에 성공해서 단풍이 피크일때 갓다왔어요

렛스25에 갔다왔어요

확실히 컨퍼런스들이 죽어가고있는게 느껴졌어요..ㅠ

예전엔 예매하기 힘들었는데 지금은 남기도하고... 오는 사람들이 많이 줄었어요

하지만 적당히 있어서 쾌적한부분도 좋긴해요

30년인생 처음으로 파마를 해봤어요

살면서 한 번 해보고싶어서 큰 변화를 줘봤어요

결과는 망한거같아요... 다들 웃더라구요

12월

모자이크 기능관련 개발을 하고있어요

기획과 디자인 모두 주도적으로 참여한 경험이에요

운전해서 성심당을 가서 빵을 한가득 사왔어요

한로로 - 사랑하게 될거야 밴드합주를 했어요

매쉬업에서 첫 송년회를 했어요

준비를 너무잘해줘서 좋은 추억을 남긴거같아요

배구경기 관람을 했어요

이케아를 갔어요

서산으로 여행을 다녀왔어요

클라이밍 핑크깬지 3개월만에 첫보라를 풀었어요

# 커리어 회고

도전적인 일

해보지않은 기술들을 도전하며 회사 서비스내에 어떻게 녹여낼지 고민했어요

Core Image의 CIFilter의 기본개념과 적용을 할 수 있게됬어요

온디바이스 AI를 적용할 수있는 기술들을 학습했어요

Family Controls를 학습하고 앱잠금 및 스크린타임 차트를 구현했어요

아쉬운 일

올해도 회사에서 iOS 영향력이 너무 적다고 느껴졌어요

이것 저것 시도해서 영향력을 키워보려했지만 실패했어요

일이 줄어들다보니 나태해지는 경우가 있었어요

남는시간에 개발이 아니더라도 유익하게 시간을 보내도록

성장을 위한 글을 읽거나 강의를 들어야겠어요

# 인생 회고

경제

부동산책을 읽고 뭔가 무섭고 미지의 세계였던 부동산에 입문을 할 수 있게됬어요

더 공부하고 직접 임장을 다니면서 미래에 내집을 고르거나 투자안목을 길러보고 싶어요

돈을 모으면서 세금이 되게 다양하게 많은걸 느끼게 되는거같아요

내 돈을 잃지않도록 잘 관리하고 공부해야 할필요성을 많이느꼇어요

너무 방대해서 어떤것부터 해야할지 모르겟지만

제일 가까운 주식관련 세금부터 부동산 세금, 세금절약 하는 법을 찾아보려고해요

경제흐름을 파악하기위해 매일 뉴스를 찾아보고 지표들을 확인했어요

이를 주식과 비교했을때 맞을때도 아닐때도 있었어요

주관적으로 생각하고 뉴스가 뜨기전에 미리 투자할 수 있는 능력이 길러지도록 노력해보려해요

주식을 하면서 자산이 흩어지고 관리하기가 힘들어지는 과정들이 있어서

자산관리 해보는 습관도 길러보려고해요

취미

클라이밍을 한지 몇년이됫는데 올해 제일 많은 성장을 한거같아요

올해초만해도 파랑(5단계)였던거같은데 어느덧 꿀 보라(8단계)라는 걸 해보려고 탐내고있어요

클라이밍을 하면서 다치기도했지만 건강해지고 재밋게 운동해서 근육도 생기는거같아요

지금까지 크게기록을 하지않았는데 내년부터는 기록을 남겨보려고해요

밴드가 올해에 5곡을 합주했어요

유다빈밴드 - 좋지 아니한가

유다빈밴드 - 사포닌 같은 너

아이들 - 아픈건 딱 질색이니까

음율 - 피차일반

한로로 - 사랑하게 될거야

어렵기도했고 쉽기도했는데 예전에 비해서 의욕이 조금 떨어져서 연습량이 줄어든것을 느꼈어요

동기부여라던가 으쌰으쌰 분위기가 없어서 쳐질때도있는데 그래도 열정 있는 사람들이 있어서

다시 마음을 고쳐잡고 열심히 해야할 것같아요

미래

올해 특히나 찬바람이 많이불었죠(채용시장이 얼어붙고 구조조정도 많은 한해였어요..)

이런 과정을 보면서 회사에 의존된 상태라면

언제 어떻게될지 모르는데 회사를 벗어나면 스스로 뭘할 수 있지? 라는 생각을 하면서

개발자를 하다보니 많은 다양한 분야가 있음에도 생각하지 못해서 시야가 좁다는것도 느꼈고

좀 더 내가 좋아하는것 내가 직접 현금 흐름구조를 만들수 있는것들을 찾아보려고해요

# 2026 목표

유튜브에서 핑계고 시상식이 화제가 됬는데 저도 보면서

'무탈하다'라는 말이 정말 좋게 와닿았어서 인상적이였어요

26년을 무탈하게 보내면 좋을 것 같아요

정체된 커리어가 아니라 향상된 커리어를 만들어 가고싶어요

25년 자산을 정리하고 26년 자산을 비교했을때 최소 10% 불어난 상태로 만들고싶어요

나를 좀 더 알아가고 나를 자주 기록해보려고 해요

새로운 일들에 대해서 겁먹지말고 도전해보고 많은 경험을 해보고싶어요

[Swift] Vision FaceDetect

냄수 — Sat, 29 Nov 2025 13:18:19 +0900

사진에 있는 얼굴을 인식해서 위치를 특정하는 기능을 해보려합니다.

CoreImage의 CIDetector와 Vision의 VNDetectFaceRectanglesRequest를 사용하는 2가지 방법이있습니다.

iOS11부터 도입된 후자를 권장하고 더 강력한 기능을 제공합니다.

따라서 이번엔 VNDetectFaceRectanglesRequest를 이용한 코딩을 할예정입니다.

VNDetectFaceRectanglesRequest란?

이미지에서 얼굴을 찾도록 요청하는 타입입니다.

Vision을 쓰다보면 000Reqeust형식을 많이보게됩니다.

그 요청중 하나입니다.

final class FaceDetector {
    func detectFaceRectangles(image: UIImage) throws -> [VNFaceObservation]? {
        guard let image = image.cgImage else { return nil }
        let request = VNDetectFaceRectanglesRequest()
        
        request.revision = VNDetectFaceRectanglesRequestRevision3
        
        let handler = VNImageRequestHandler(cgImage: image)
        try handler.perform([request])
        let results = request.results
        return results
    }
}

요청을 만들고

결과값으로 VNFaceObservation을 반환받습니다.

VNFaceObservation란?

이미지에서 감지하는 얼굴 또는 얼굴 특징 정보입니다.

let observation = try detector.detectFaceRectangles(image: image)
var boundingBoxes: [CGRect] = []
observation?.forEach {
    print("description", $0.description)
    print("boundingBox", $0.boundingBox)
    print("faceCaptureQuality", $0.faceCaptureQuality)
    print("confidence", $0.confidence)
    print("landmarks", $0.landmarks)
    print("pitch", $0.pitch)
    print("roll", $0.roll)
    print("timeRange", $0.timeRange)
    print("uuid", $0.uuid)
    print("yaw", $0.yaw)
    
    boundingBoxes.append($0.boundingBox)
}

description <VNFaceObservation: 0x15ceac800> 484BBF54-1E67-404A-B45B-20BB5A7257BF VNDetectFaceRectanglesRequestRevision3 confidence=0.683225 boundingBox=[0.613351, 0.484306, 0.140112, 0.270106]

boundingBox (0.6133507490158081, 0.4843055307865143, 0.14011242985725403, 0.27010563015937805)

faceCaptureQuality nil

confidence 0.68322533

landmarks nil

pitch Optional(-0.317534)

roll Optional(1.027767)

timeRange CMTimeRange(start: __C.CMTime(value: 0, timescale: 1, flags: __C.CMTimeFlags(rawValue: 1), epoch: 0), duration: __C.CMTime(value: 0, timescale: 1, flags: __C.CMTimeFlags(rawValue: 1), epoch: 0))

uuid 484BBF54-1E67-404A-B45B-20BB5A7257BF

yaw Optional(-0.638136)

description - 요약정보

boundingBox - 감지된 얼굴의 위치와 크기를 나타내는 정규화된 좌표, 얼굴영역표시에 사용

CGRect좌표값으로 이미지의 상대적인 위치를 나타냄

사용시 뷰의 좌표계에 맞게 변환해서 사용해야함

Vision은 왼쪽하단이 원점(0,0)이고 UIKit/SwiftUI는 왼쪽상단이 원점이므로 Y축을 뒤집어서 사용해야함

boundingBox가 (0.6, 0.4, 0.1, 0.2)일때 <<< (x위치, y위치, 가로길이, 세로길이)

이미지 가로길이가 100, 세로길이가 100이라면

가로로 0.6지점인 60포인트부터 길이가 0.1인 10에 얼굴이 인식됫다는 것을 알려줍니다.

즉, 60~70 포인트에 얼굴이 포함됩니다.

세로는 0.4지점 40부터 세로길이 0.2인 20에 얼굴이 인식됬습니다.

즉, 40~60입니다.

이 정보를 종합하면 (60, 40), (70, 40), (70, 60), (60, 60)

이해를 돕기위해 그림을 그려봤어요 ㅎ...(그림에서 Y축 반전은 우선 신경쓰지 마세요 이해용입니다!)

CoreImage를 이용한 처리에는 좌표를 그대로 써도되서 무관하지만 보통 CGImage나 View로 그리기때문에 Y축은 각별히 신경써야합니다.

    func convert(boundingBox: CGRect, to bounds: CGRect) -> CGRect {
        let imageWidth = bounds.width
        let imageHeight = bounds.height
        
        let frame = CGRect(
            origin: CGPoint(
                x: boundingBox.origin.x * imageWidth,
                y: (1 - boundingBox.maxY) * imageHeight
            ),
            size: .init(
                width: boundingBox.width * imageWidth,
                height: boundingBox.height * imageHeight
            )
        )
        
        return frame
    }
    
    // CIImage용
    func ciImageRect(boundingBox: CGRect, to bounds: CGRect) -> CGRect {
        let imageWidth = bounds.width
        let imageHeight = bounds.height
        
        let frame = CGRect(
            origin: CGPoint(
                x: boundingBox.origin.x * imageWidth,
                y: boundingBox.origin.y * imageHeight
            ),
            size: .init(
                width: boundingBox.width * imageWidth,
                height: boundingBox.height * imageHeight
            )
        )
        
        return frame
    }

뷰좌표계로 컨버팅하는 함수를 이용했습니다.

x축은 비례로 좌표를 변환하고 y축은 뒤집어서 비례로 좌표를 변환했습니다.

faceCaptureQuality

감지된 얼굴이 얼마나 품질이 좋은지

가장 잘나온 사진 판별가능

face capture quality request시 제공

confidence

감지신뢰도 1에 가까울수록 신뢰성 높음

landmarks

눈,코,입,얼굴윤곽선 등 세부얼굴 특징점 정보

face landmark request시에만 제공됨

pitch

얼굴의 세로 회전각 (x축 기준으로 머리를 위아래로 움직일때 각도)

roll

얼굴의 회전정도 (z축)

timeRange

얼굴인식이 적용되는 비디오구간 정보(이미지는 존재x)

yaw

얼굴의 수평방향 회전 (y축, 고개를 좌우로 돌리는각도)

좌표를 계산해서 아래와같이 인식된 얼굴영역에 테두리를 그려볼수있습니다.

[Swift] Screen Time API(DeviceActivity)

냄수 — Mon, 27 Oct 2025 22:08:18 +0900

앞선 게시물에서 정리하지않은 Screen Time관련 기능중

DeviceActivity를 정리하려합니다.

1. DeviceActivity를 사용해서 특정시간에 코드를 실행시키는 방법과

2. 기기 사용시간을 모니터링 하는 방법을 알아볼거에요

3. 마지막으로는 사용시간 데이터로 시각화를 위해 차트화 하는 방법까지 해볼예정입니다.

DeviceActivity란

앱이 실행되지않아도 코드를 실행 할 수 있는 방법을 제공

사용자 기기를 모니터링하고 조건 충족시 자동으로 코드실행 가능

- 특정 시간대에 코드실행 가능

- 특정 앱을 일정 시간 이상 사용시 이벤트 발생하여 코드실행 가능

Device Activity Monitor Extension과 Device Activity Report Extension으로 구분됩니다.

먼저

Device Activity Monitor Extension

사용자 기기사용을 모니터링 합니다.

특정 조건시 이벤트를 트리거합니다.

File -> New -> Target에서

추가할 수 있습니다.

DeviceActivityMonitor를 준수해서

구현할 수 있는 함수는 아래와 같습니다.

/// 활동 시작전에 startMonitoring의 warningTime분 전에 알림 (시작 n분전, 종료 n분전)
override func intervalWillStartWarning(for activity: DeviceActivityName)
override func intervalWillEndWarning(for activity: DeviceActivityName)

/// 장치 활동 간격이 시작 (startMonitoring의 intervalStart 시간에 해당시 호출됨)
override func intervalDidStart(for activity: DeviceActivityName) 
/// 장치 활동 간격이 끝 (startMonitoring의 intervalEnd 시간에 해당시 호출됨)
override func intervalDidEnd(for activity: DeviceActivityName)

/// 활동이 지정한 임계값에 도달할 예정일때 호출됨
override func eventWillReachThresholdWarning(_ event: DeviceActivityEvent.Name, activity: DeviceActivityName)
/// 활동이 지정한 임계값에 도달하면 호출됨
override func eventDidReachThreshold(_ event: DeviceActivityEvent.Name, activity: DeviceActivityName)

위의 함수를 실행시키기위해선 DeviceActivityCenter 인스턴스를 사용합니다.

deviceActivityCenter.startMonitoring를 호출해서 모니터링을 등록합니다

let deviceActivityCenter = DeviceActivityCenter()
// 이벤트 이름에 맞는 이벤트 생성
private let events: [DeviceActivityEvent.Name: DeviceActivityEvent] = [
    .encouraged: .init(threshold: DateComponents(minute: 1))
]
var startDate: Date = .now
var startDateComponent: DateComponents { DateComponents(from: startDate) }
var endDate: Date = .now
var endDateComponent: DateComponents { DateComponents(from: endDate) }

func startMonitor() {
    do {
        try deviceActivityCenter.startMonitoring(
            .testName,
            during: .init(
                intervalStart: startDateComponent,
                intervalEnd: endDateComponent,
                repeats: true,
                warningTime: .init(minute: 1) // 1분전
            ),
            events: events
        )
        syncActivityList()
        print("설정완료")
    } catch {
        print(error)
    }
}

// MARK: - 이름정의

extension DeviceActivityName {
    static let testName = Self("testName")
}

extension DeviceActivityEvent.Name {
    static let encouraged = Self("encouraged")
}

제가 직접 테스트해본결과 start와 end시간 사이에 최소 15분 이상 필요합니다.

15분내 간격일때 너무 짧다고 에러를 발생시킵니다

여기서 주의할점이있는데

intervalStart값을 넣기위해 DateComponents타입생성시

Calendar.current.dateComponents([.year, .month, .day, .hour, .minute, .second], from: date) 이런식으로

년월일시간분초 값이 모두 존재해야 정상적으로 등록되서 이벤트발생합니다

에러도 없고 이벤트도 없어서 디버깅하기 어려웠습니다. ㅠ

테스트전엔 반드시 권한을 가져와야합니다.

let authCenter = AuthorizationCenter.shared

func checkAuth() {
    Task {
        do {
            try await authCenter.requestAuthorization(for: .individual)
        } catch {
            print("Fail: \(error)")
        }
    }
}

활성화중인 이벤트 리스트를 보는 방법은 아래와 같습니다.

var allActivieString: [String] = []

private func syncActivityList() {
    allActivieString = deviceActivityCenter.activities.map { activity in
        "\(activity.rawValue) " + startToEndTimeString(name: activity)
    }
}

앞 게시글에서 정리한 ManagedSetting을 이용한다면

특정시간에 앱을 차단하는 기능을 구현할 수 있습니다.

class DeviceActivityMonitorExtension: DeviceActivityMonitor {
    let store = ManagedSettingsStore()

    /// 장치 활동 간격이 시작되었음을 나타냅니다
    override func intervalDidStart(for activity: DeviceActivityName) {
        super.intervalDidStart(for: activity)
        
        if let selection = loadSelectedApps() {
            print("앱 목록 로드성공")
            blockSelectedApps(selection)
        }
    }

    private func loadSelectedApps() -> FamilyActivitySelection? {
        let userDefaults = UserDefaults(suiteName: "group.test.familyControl")
        guard let data = userDefaults?.data(forKey: "testKey") else {
            return nil
        }
        
        do {
            let model = try JSONDecoder().decode(AppModel.self, from: data)
            return model.selection
        } catch {
            print("앱 목록 로드 실패: \(error)")
            return nil
        }
    }
    
    private func blockSelectedApps(_ selection: FamilyActivitySelection) {
        // 앱 차단 설정
        store.shield.applications = selection.applicationTokens.isEmpty ?
            nil : selection.applicationTokens
        
        // 카테고리 차단 설정
        store.shield.applicationCategories = selection.categoryTokens.isEmpty
        ? nil
        : .specific(selection.categoryTokens)
        
        // 웹 도메인 차단 설정 (필요한 경우)
        store.shield.webDomains = selection.webDomainTokens.isEmpty
        ? nil
        : selection.webDomainTokens
    }
       
}

특정시간이 되면

loadSelectedApps()를 통해서 활동을 선택한 앱목록을 가져와서

blockSelectedApps()함수로 전달해서 선택된 앱들을 차단합니다.

모니터링 중단은

deviceActivityCenter.stopMonitoring()

를 사용합니다.

앱차단 해제는

    func unblockApps() {
        // 모든 차단 해제
        store.shield.applications = nil
        store.shield.applicationCategories = nil
        store.shield.webDomains = nil
    }

nil을 넣어주면 해제됩니다

이제 앱별 사용량을 체크할 수 있는 기능을 봐볼까요?

Device Activity Report Extension

사용자의 기기 사용 데이터 수집가능

어떤 앱을 얼마나 사용했는지, 특정시간대에 얼마나 사용했는지

1분주기로 업데이트가능

File -> New -> Target에서

이번엔 이 기능을 추가해줍니다.

DeviceActivityReport.Context

DeviceActivity 데이터를 기반으로 그릴 View 유형을 보고서에 알려주는 사용자 지정 가능한 유형입니다

public extension DeviceActivityReport.Context {
    // If your app initializes a DeviceActivityReport with this context, then the system will use
    // your extension's corresponding DeviceActivityReportScene to render the contents of the
    // report.
    static let totalActivity = Self("Total Activity")
}

생성하면 기본적으로 생성되있습니다.

이 타입은 어떤 DeviceActivityReportScene타입을 부를것인지 선택하는 이름입니다.

public protocol DeviceActivityReportScene : AppExtensionScene {

    /// The context of the scene.
    ///
    /// When your app creates a `DeviceActivityReport` with this context, the
    /// system uses this scene to render the report's content.
    var context: DeviceActivityReport.Context { get }
}

기본적으로 context를 작성해야하고

여기서 정의한 context가 앱타겟에서 불러올 ReportScene이 됩니다.

struct TotalActivityReport: DeviceActivityReportScene {
    // Define which context your scene will represent.
    // DeviceActivityReport호출시 해당 컨텍스트에 해당하는 Report 불러옴
    let context: DeviceActivityReport.Context = .totalActivity  
    
    // Define the custom configuration and the resulting view for this report.
    let content: ([AppUsage]) -> TotalActivityView

이런식으로 구현합니다.

여러 Report를 구현할 수도 있으므로 각 범위에 따라서 다르게 선택할 수 있습니다.

앱타겟에서 사용하는 뷰 예시는 아래와같습니다.

struct DeviceReportView: View {
    var body: some View {
        VStack {
            Text("사용량 통계")
            DeviceActivityReport(context, filter: filter)
        }
    }
}

DeviceActivityReport 뷰타입에 넣어줄 context가 여기에 해당합니다.

DeviceActivityResults

필터링된 장치 활동 결과의 비동기 시퀀스

for await in 으로 요소에 접근가능합니다.

DeviceActivityData

iOS16+

특정 디바이스에서 특정 사용자의 활동을 나타내는 핵심 데이터 타입

주요 속성 (Instance Properties)

1. activitySegments: 사용자의 활동을 세그먼트별로 구분한 데이터

2. device: 활동 보고서와 연관된 디바이스 정보

3. lastUpdatedDate: 시스템이 이 디바이스의 데이터를 마지막으로 업데이트한 날짜

4. segmentInterval: 각 활동 세그먼트의 간격

5. user: 활동 보고서와 연관된 사용자 정보

주요 하위 구조체들

1. DeviceActivityData.ActivitySegment

특정 날짜 간격 동안의 사용자 활동을 나타냅니다.

주요 속성:

- categories: 활동 세그먼트 동안의 카테고리별 디바이스 활동

- dateInterval: 활동 세그먼트의 날짜 간격

- firstPickup: 활동 세그먼트 동안 사용자가 처음 디바이스를 집어든 시간

- longestActivity: 활동 세그먼트 동안 가장 긴 활동 세션의 날짜 간격

- totalActivityDuration: 활동 세그먼트 동안의 총 활동 시간

- totalPickupsWithoutApplicationActivity: 앱을 사용하지 않고 디바이스를 집어든 횟수

2. DeviceActivityData.Device

활동 데이터를 보고할 디바이스를 나타냅니다.

주요 속성:

- model: 디바이스 모델 (iPhone, iPad, Mac 등)

- name: 사용자가 설정한 디바이스 이름

3. DeviceActivityData.User

활동과 연관된 사용자 정보를 나타냅니다.

주요 속성:

- appleID: 사용자의 Apple ID

- nameComponents: 사용자 이름

- role: 사용자 유형 (가족 역할 등)

4. DeviceActivityData.CategoryActivity

사용자의 앱 및 웹 도메인 활동을 카테고리별로 표현합니다.

주요 속성:

- applications: 이 카테고리에 기여한 앱 활동

- category: 활동의 카테고리

- totalActivityDuration: 이 카테고리의 총 활동 시간

- webDomains: 이 카테고리에 기여한 웹 도메인 활동

로그 코드를 참고해서 필요한 속성을 골라쓰시면 됩니다.

private func printLog(data: DeviceActivityResults<DeviceActivityData>) async -> [AppUsage] {
    let formatter = DateComponentsFormatter()
    formatter.allowedUnits = [.day, .hour, .minute, .second]
    formatter.unitsStyle = .abbreviated
    formatter.zeroFormattingBehavior = .dropAll
    let thisDevice = UIDevice.current.model
    
    var appUsages: [AppUsage] = []
    for await value in data {
        print(" device.name",value.device.name) // 연결된 모든 디바이스 (아이폰, 아이패드) NS, NS iPad
        print(" lastUpdatedDate",formatter.string(for: value.lastUpdatedDate))
        print(" segmentInterval", value.segmentInterval) // 측정 간격
        print(" name", value.user.nameComponents) // 사용자이름 ( given: 남수 family: 김)
        print(" user apple id", value.user.appleID) // apple id
        print(" user role", value.user.role) // individual
        
        
        for await activity in value.activitySegments {
            print(" activity dateInterval", activity.dateInterval) // 측정 간격
            print(" activity firstPickup", activity.firstPickup) // 처음 폰든시간 9/21 오후 11시2분2초
            print(" activity longestActivity", activity.longestActivity) // 제일긴 활동시간 Date to Date
            print(" activity totalActivityDuration", activity.totalActivityDuration) // 3072초
            print(" activity totalPickupsWithoutApplicationActivity", activity.totalPickupsWithoutApplicationActivity)
            
            for await category in activity.categories {
                print(" category.localizedDisplayName", category.category.localizedDisplayName) // social, Other, 큰카테고리
                print(" category.debugDescription", category.category.token.debugDescription) // 128 bytes, 토큰 해독불가
                print(" category.totalActivityDuration", category.totalActivityDuration) // 1668초, 690초

                for await application in category.applications {
                    print(" app localizedDisplayName", application.application.localizedDisplayName) // instagram, 카카오톡
                    print(" app bundleIdentifier", application.application.bundleIdentifier) // com.burbn.instagram. com.iwilab.KakaoTalk
                    print(" app numberOfNotifications", application.numberOfNotifications) // 0, 10
                    print(" app numberOfPickups", application.numberOfPickups) // 1, 5
                    print(" app totalActivityDuration", application.totalActivityDuration) // 1228초, 430초
                    let usage = AppUsage(
                        title: application.application.localizedDisplayName?.lowercased() ?? "",
                        time: Int(application.totalActivityDuration)
                    )
                    appUsages.append(usage)
                }
                
                for await webDomain in category.webDomains {
                    print("⚫️web domain", webDomain.webDomain.domain) // weather.naver.com, naver.com
                    print("⚫️web totalActivityDuration", webDomain.totalActivityDuration) // 5초
                    print("⚫️web debugDescription", webDomain.webDomain.token.debugDescription) // 128bytes
                }
            }
            
        }
    }
    print("------------------")
    return appUsages
}

  device.name Optional("NS")
  lastUpdatedDate nil
  segmentInterval daily(during: 2025-09-21 15:00:00 +0000 to 2025-09-22 15:00:00 +0000)
  name Optional(givenName: 남수 familyName: 김 )
  user apple id Optional("ㅁㅁㅁㅁ@naver.com")
  user role individual
  activity dateInterval 2025-09-21 15:00:00 +0000 to 2025-09-22 15:00:00 +0000
  activity firstPickup Optional(2025-09-21 23:02:02 +0000)
  activity longestActivity Optional(2025-09-22 01:14:31 +0000 to 2025-09-22 01:24:45 +0000)
  activity totalActivityDuration 3072.8046337366104
  activity totalPickupsWithoutApplicationActivity 2
  category.localizedDisplayName Optional("Social")
  category.debugDescription Optional(ActivityCategoryToken(data: 128 bytes: äéî/ÑI©éjMMô
 j7;ª$.èýô`gøcØ~v.¡À0Õ¥
 ¢2¯«û^
 SåRgÂÆ^8£±jóÄ«Âè,·Û9£:ÅÄäãCVª¶ÙBçâ6d Å"g/))
  category.totalActivityDuration 1668.274539232254
  app localizedDisplayName Optional("Instagram")
  app bundleIdentifier Optional("com.burbn.instagram")
  app bundleIdentifier Optional("com.burbn.instagram")
  app numberOfNotifications 0
  app numberOfPickups 1
  app totalActivityDuration 1228.57754611969
  app localizedDisplayName Optional("카카오톡")
  app bundleIdentifier Optional("com.iwilab.KakaoTalk")
  app bundleIdentifier Optional("com.iwilab.KakaoTalk")
  app numberOfNotifications 10
  app numberOfPickups 5
  app totalActivityDuration 430.60449719429016
  category.localizedDisplayName Optional("Productivity & Finance")
  category.debugDescription Optional(ActivityCategoryToken(data: 128 bytes: äéî/ÑI©éjMMô
 j7;ª$.èýô`gøcØ~v.¡À0Õ¥
 ¢2¯«û^
 SåRgÂÆ^8£±jóÄ«Âè,·Û9£:ÅÄäãCVª¶*LýìÓ)ûZD§9))
  category.totalActivityDuration 417.86487793922424
  app localizedDisplayName Optional("토스")
  app bundleIdentifier Optional("com.vivarepublica.cash")
  app bundleIdentifier Optional("com.vivarepublica.cash")
  app numberOfNotifications 6
  app numberOfPickups 4
  app totalActivityDuration 408.36211693286896
  app localizedDisplayName Optional("모바일출입카드")
  app bundleIdentifier Optional("kr.co.adcaps.mobilecard")
  app bundleIdentifier Optional("kr.co.adcaps.mobilecard")
  app numberOfNotifications 0
  app numberOfPickups 0
  app totalActivityDuration 9.502761006355286
  category.localizedDisplayName Optional("Entertainment")
  category.debugDescription Optional(ActivityCategoryToken(data: 128 bytes: äéî/ÑI©éjMMô
 j7;ª$.èýô`gøcØ~v.¡À0Õ¥¢2¯«û^
 SåRgÂÆ^8£±jóÄ«Âè,·Û9£:ÅÄäãCVª¶~²=ë¡ËÃA(CÏÝ))
  category.totalActivityDuration 31.47321093082428
  app localizedDisplayName Optional("네이버 웹툰")
  app bundleIdentifier Optional("com.nhncorp.NaverWebtoon")
  app bundleIdentifier Optional("com.nhncorp.NaverWebtoon")
  app numberOfNotifications 0
  app numberOfPickups 0
  app totalActivityDuration 22.481863021850586
  app localizedDisplayName Optional("YouTube")
  app bundleIdentifier Optional("com.google.ios.youtube")
  app bundleIdentifier Optional("com.google.ios.youtube")
  app numberOfNotifications 1
  app numberOfPickups 0
  app totalActivityDuration 2.891474962234497
 ⚫️web domain Optional("weather.naver.com")
 ⚫️web totalActivityDuration 5.285457968711853
 ⚫️web debugDescription Optional(WebDomainToken(data: 128 bytes: äéî/ÑI©éjMMô
 j7;ª$.üë0übwßcg&îØe½´ÛðJ®û¾è
 P
 qÂ¢±ïw´7ÌÆóÄ«Âè,·Û9£:ÅÄäãCVª¶÷ä]r    &vm¼Ò))
 ⚫️web domain Optional("naver.com")
 ⚫️web totalActivityDuration 0.8144149780273438
 ⚫️web debugDescription Optional(WebDomainToken(data: 128 bytes: äéî/ÑI©éjMMô
 j7;ª$.üë0übwßcg&îØ|¹£Á»[ï<ð÷¸JYë:ÂèòÆ^8£±jóÄ«Âè,·Û9£:ÅÄäãCVª¶0?Ã3ã(ýäR0))
  device.name Optional("NS iPad")
  lastUpdatedDate nil
  segmentInterval daily(during: 2025-09-21 15:00:00 +0000 to 2025-09-22 15:00:00 +0000)
  name Optional(givenName: 남수 familyName: 김 )
  user apple id Optional("ㅁㅁㅁㅁ@naver.com")
  user role individual

이런식으로

기기별로, 활동별로, 카테고리별로, 앱, 웹 이런식으로 하위까지 사용량을 확인할 수 있습니다.

이제 이 사용량을 토대로 차트화 시켜볼까요?

차트구현

Scene타입의 content에 사용할 타입을 먼저 정의할겁니다

앱 타이틀과 시간을 저장할 구조체도 같이 정의합니다.

let content: (String) -> TotalActivityView // 기본 생성시 

let content: ([AppUsage]) -> TotalActivityView // << 수정


struct AppUsage {
    let title: String
    let time: Int
}

이제 앱타겟에서 사용할 뷰를 정의합니다

struct DeviceReportView: View {
    @State private var context: DeviceActivityReport.Context = .totalActivity
    @State private var filter: DeviceActivityFilter = .init(
        segment: .daily(
            during: .init(
                start: .now.addingTimeInterval(-3600),
                end: .now.addingTimeInterval(3600)
            )
        ),
        devices: .all
    )
    var body: some View {
        VStack {
            Text("사용량 통계")
            DeviceActivityReport(context, filter: filter)
        }
    }
}

위에서 이미했지만 다시 코드를 불러오겠습니다.

로그부분은 다제거하고 필요한 코드만 작성했습니다.

struct TotalActivityReport: DeviceActivityReportScene {
    // Define which context your scene will represent.
    let context: DeviceActivityReport.Context = .totalActivity  // DeviceActivityReport호출시 해당 컨텍스트에 해당하는 Report 불러옴
    
    // Define the custom configuration and the resulting view for this report.
    let content: ([AppUsage]) -> TotalActivityView
    
    func makeConfiguration(representing data: DeviceActivityResults<DeviceActivityData>) async -> [AppUsage] {
        // Reformat the data into a configuration that can be used to create
        // the report's view.
        let formatter = DateComponentsFormatter()
        formatter.allowedUnits = [.day, .hour, .minute, .second]
        formatter.unitsStyle = .abbreviated
        formatter.zeroFormattingBehavior = .dropAll
        
        return await printLog(data: data)
    }
    
    func containsIPhone(_ name: String) -> Bool {
      return name.range(of: "iPhone", options: .caseInsensitive) != nil
    }
    
    private func printLog(data: DeviceActivityResults<DeviceActivityData>) async -> [AppUsage] {
        let formatter = DateComponentsFormatter()
        formatter.allowedUnits = [.day, .hour, .minute, .second]
        formatter.unitsStyle = .abbreviated
        formatter.zeroFormattingBehavior = .dropAll
        let thisDevice = UIDevice.current.model
        
        var appUsages: [AppUsage] = []
        for await value in data {
            for await activity in value.activitySegments {
                for await category in activity.categories {
                    for await application in category.applications {
                        let usage = AppUsage(
                            title: application.application.localizedDisplayName?.lowercased() ?? "",
                            time: Int(application.totalActivityDuration)
                        )
                        appUsages.append(usage)
                    }
                }
                
            }
        }

        return appUsages
    }
}

4중 for문이라니 ,,, (가능하다면 flatMap으로 배열 평탄화 가공하셔도 좋을거같네요)

리포트 데이터를 받아서 구현할 뷰를 작성해보겠습니다.


import SwiftUI
import Charts

struct AppUsage {
    let title: String
    let time: Int
}

struct TotalActivityView: View {
    let totalActivity: String
    let total: Int
    let data: [AppUsage]
    @State private var selectedAngle: Int?
    private let dataRange: [Range<Int>]
    // 선택한 차트 각도에 해당하는 선택된 아이템반환
    private var selectedItem: AppUsage? {
        guard let selectedAngle else { return nil }
        if let selectedIndex = dataRange.firstIndex(where: { range in
            range.contains(selectedAngle)
        }) {
            return data[selectedIndex]
        }
        return nil
    }
    
    init(data: [AppUsage]) {
        self.data = data
        var total: Int = 0
        self.dataRange = data.map {
            let newTotal = total + $0.time
            let result = total..<newTotal
            total = newTotal
            return result
       }
        self.totalActivity = "\(total)s"
        self.total = total
    }
    
    var body: some View {
        Text("전체 \(totalActivity)")
        
        Chart(data, id: \.title) { value in
            SectorMark(
                angle: .value("appName", value.time),
                innerRadius: .ratio(0.618), // 황금비율 (안쪽원)
                outerRadius: .ratio(1), // 전체원의 크기
                angularInset: 3 // 차트 데이터간 간격
            )
            .cornerRadius(10)
            .opacity(selectedItem?.title == value.title ? 1 : 0.5) // 선택된아이템 강조
            .foregroundStyle(by: .value("color", value.title))
        }
        .chartLegend(.visible) // 범주 노출
        .chartAngleSelection(value: $selectedAngle) // 선택된 각도 바인딩 (Double 혹은 Int 타입만 가능)
        .chartBackground { proxy in
            GeometryReader { geometry in
                if let plotFrame = proxy.plotFrame { // 차트가 그려진프레임
                    let frame = geometry[plotFrame] // Ahchor<CGRect> -> CGRect 형변환
                    VStack {
                        Text("사용량")
                        if let selectedItem {
                            Text(selectedItem.title)
                                .bold()
                            Text("time: \(selectedItem.time)s")
                            Text("\(Double(selectedItem.time) / Double(total) * 100)%")
                        }
                    }
                    .position(x: frame.midX, y: frame.midY) // 차트프레임 좌표 적용시켜야 중앙에뜸
                }
            }
        }
        .scaledToFit()
    }
}

차트를 터치하면 해당 앱의 이름, 사용시간, 비율을 확인 할 수 있습니다.

시뮬레이터에선 앱사용량 제공을 해주지않아서 실기기에서 테스트하는걸 권장드려요!!

NamS의 iOS일기

[Swift] WWDC 25 App Intent 알아보기 (feat. 단축어)

App Intents

AppEnum사용

AppEntity사용

TargetContentProvidingIntent예시

OpenIntent 예시

AppIntent로 데이터 수정 하는 예시

Entity 및 Query

[SwiftUI] iPad Layout 대응시 고려할점

@Environment(\.horizontalSizeClass)

ViewTahtFits

ViewThatFits vs HorizontalSizeClass

NavigationSplitView

inspector(isPresented: )

.popover

.presentationDetents

[Swift] BGContinuedProcessingTask 백그라운드 작업

기존에 쓰던 백그라운드 방식과 비교해볼까요?

플로우

키워드

예시코드

스크린샷

[Swift] Protocol Buffer (Protobuf)

Protocol buffer란?

특징

동작

스키마

구성

VARINT 타입 - Vairable Integer

LEN타입 - Length-delimited

사용예시

라이브러리 사용법

[iOS] AI 기본 개념부터 온디바이스까지 정리해보기

AI 핵심 개념

머신러닝 (Machine Learning)

딥러닝 (Deep Learning)

모델 (Model)

학습 vs 추론 (Training vs Inference)

학습

추론

관련 키워드 개념

Neural Network (신경망)

CNN / RNN / Transformer

CNN

RNN

Transformer

Input / Output / Feature

Loss / Optimization

Overfitting / Generalization

Overfitting

Generalization

Dataset / Label

Tensor

모델은 어떻게 사용하는가

Core ML 모델 포맷

모델 변환

ONNX

TensorFlow Lite

iOS에서는 어떻게 연결되는가

Core ML이란?

Foundation Models

CPU / GPU / ANE

전체 흐름

Python 방식과 Create ML 방식

Python 중심 방식

Create ML

성능 최적화

Quantization (양자화)

Pruning (가지치기)

Model Compression

Latency vs Accuracy trade-off

Batch vs Real-time inference

그래서 이 시점의 나는 지금 AI를 어떻게 사용하고 있는가

개발

개발 생산성

검색

Next...

[Swift] FoundationModels

FoundationModels?