NamS의 iOS일기

[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()
    }
}

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

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

[Swift] Screen Time API(FamilyControls, ManagedSettings)

냄수 — Fri, 26 Sep 2025 22:55:44 +0900

안녕하세요

오늘은 Screen Time API중 Family Controls과 ManagedSettings에 대해서 알아보려고합니다.

문서에 써잇는 간단한 소개글을 보면 아래와 같아요

Managed Setting 에서 보호자는 앱을 통해 계정 잠금, 웹 트래픽 필터링, 미디어 접근 제한 등의 작업을 수행할 수 있습니다.

자녀가 기기에서 앱을 실행할 이유가 전혀 없을 수 있으므로, 앱을 실행하지 않고도 기기에서 코드를 실행할 수 있도록 기기 Device Activity 프레임워크를 활용할 수 있습니다.

개인정보 보호를 위해 Family Control 프레임워크는 가족 공유를 통해 앱을 승인하기 위해 보호자의 동의를 요구합니다.

족 공유를 통한 보호자 승인을 요구함으로써, 단일 가족 공유 그룹 외부에서의 무단 정보 접근으로부터 사용자를 보호합니다.

Managed Setting - 계정잠금, 트래픽 필터링, 앱차단 등 기기사용을 보다 세밀하게 제어가능

Family Control - 승인 접근, 앱, 웹 활동제한을 위한 토큰 제공

Device Activity - 앱이 실행되지않아도 코드를 실행시킬 수 있는 방법 제공, 모니터링

간단하게 FamilyControl 프레임워크에서 앱 카테고리 토큰을 받아서

선택한 카테고리 앱들의 실행을 제한하는 간단한 샘플 앱을 만들어보겠습니다

구현시 주의사항으로

실제 디바이스 비번 설정이 안되있다면

authenticationMethodUnavailable 에러를 만나볼 수 있습니다.

(스크린타임 개발 디버깅 불가능)

해결방안으로는 아래와같이 진행하면 됩니다.

1. 설정 > Face ID 및 패스코드 - 패스코드 설정 또는 변경 - Face ID/Touch ID 재설정

2. 설정 > 스크린 타임 - 스크린 타임 켜기 - 스크린 타임 패스코드 설정 - 앱 및 웹사이트 활동 허용

Family Controls

FamilyControl사용을 위해서는

Capability에서 Family Control 을 먼저 추가한뒤

코드적으로도 사용자 승인을 받아야합니다

    let authCenter = AuthorizationCenter.shared

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

FamilyActivitySelection

.familyActivityPicker 모디파이어를 사용하여 기기내의 앱 리스트를 보여줍니다.

차단할 카테고리 세부앱들은 시뮬레이터에서는 확인이 불가능하여 카테고리 전체만 차단가능하고

실기기에선 각 앱별로 선택하여 차단할 수도 있습니다.

import FamilyControls
                
struct SomeView: View {
    @State var selection = FamilyActivitySelection()
    @State var isPresented = false
    
    var body: some View {
        SomeView2()
            .familyActivityPicker(isPresented: $isPresented, selection: $selection)
            .onChange(of: selection) { old, new in
                let applications = new.applications
                let categories = new.categories
                let webDomains = new.webDomains
                print(applications, categories, webDomains)
            }
    }
}

사용자의 개인 정보를 보호하기 위해 FamilyActivitySelection은 사용자가 선택한 범주, 애플리케이션 및 웹 도메인을 나타내는 불투명한 값을 보유합니다.

그런 다음 이러한 불투명한 값을 ManagedSettings 및 DeviceActivity 프레임워크의 인스턴스와 메서드에 전달하여 보호 기능을 설정하고 관리할 수 있습니다.

extension에서 사용할 것이라면 appGroup을 이용해서 이값을 저장하고 읽어오면 됩니다.

UserDefault에 타입을 바로 저장할수는 없으니 Data형식으로 인코딩해서 저장하고 디코딩해서 읽는 방식을 사용합니다.

인코딩 디코딩 하는 예시코드

struct AppModel: Codable {
    init(selection: FamilyActivitySelection) {
        self.selection = selection
    }
    
    let selection: FamilyActivitySelection
}

func setShieldRestrictions() {
    let applications = selectionToDiscourage
    
    do {
        let model = AppModel(selection: applications)
        let appData = try JSONEncoder().encode(model)
        userDefaults.set(appData, forKey: "testKey")
    } catch {
        print(error)
    }
}
    

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)
        print(model)
        return model.selection
    } catch {
        print("앱 목록 로드 실패: \(error)")
        return nil
    }
}

Managed Settings

ManagedSettingsStore

현재 사용자 또는 장치에 설정을 적용하는 데이터 저장소.

관리 설정 데이터 저장소는 기능을 기준으로 설정을 그룹화합니다.

각 그룹은 관련 설정(예: 기본값, 가능한 최소값 및 최대값)에 대한 관련 데이터를 포함합니다.

FamilyActivitySelection타입으로 선택한값을 ManagedSettingsStore에 전달합니다

import ManagedSettings

@Observable
final class ManagedModel {
    private let store = ManagedSettingsStore()
    var selectionToDiscourage: FamilyActivitySelection = .init()
    
    func setShieldRestrictions() {
        let applications = selectionToDiscourage
        
        store.shield.applications = applications.applicationTokens.isEmpty ? nil : applications.applicationTokens
        store.shield.applicationCategories = applications.categoryTokens.isEmpty
        ? nil
        : .specific(applications.categoryTokens)
    }
}

store.shield(ShieldSettings타입) 을통해서 앱이나 웹사이트를 제한 할 수 있습니다.

Shield

앱이 차단되는 화면을 커스텀하고싶으면 addTarget에서 아래중 원하는것을 선택하면됩니다.

Shield Configuration - ShieldConfigurationDataSource

차단시 UI설정

    override func configuration(shielding application: Application) -> ShieldConfiguration {
        // Customize the shield as needed for applications.
        ShieldConfiguration(
            backgroundBlurStyle: .dark,
            backgroundColor: .black,
            icon: nil,
            title: .init(text: "앱 차단⚠️!!", color: .systemPink),
            subtitle: .init(text: "서브타이틀임", color: .systemPink),
            primaryButtonLabel: .init(text: "primary버튼", color: .systemPink),
            primaryButtonBackgroundColor: .black,
            secondaryButtonLabel: .init(text: "secondary버튼", color: .systemPink)
        )
    }
    
    override func configuration(shielding application: Application, in category: ActivityCategory) -> ShieldConfiguration {
        // Customize the shield as needed for applications shielded because of their category.
        ShieldConfiguration(
            backgroundBlurStyle: .dark,
            backgroundColor: .black,
            icon: nil,
            title: .init(text: "카테고리 차단⚠️!!", color: .systemPink),
            subtitle: .init(text: "서브타이틀임\(category.localizedDisplayName)", color: .systemPink),
            primaryButtonLabel: .init(text: "primary버튼", color: .systemPink),
            primaryButtonBackgroundColor: .black,
            secondaryButtonLabel: .init(text: "secondary버튼", color: .systemPink)
        )
    }

CGV앱을 제한걸고(시뮬에서 테스트불가능해서 실제폰에서 테스트) CGV앱을 실행시키면 앱 차단이 노출됩니다.

이와 다르게 생산성 및 금융이라는 카테고리를 제한시키고 앱을 실행시키면 카테고리 차단이 노출됩니다.

카테고리가 더 상위개념으로 카테고리를 차단하면 앱차단보다 우선순위로 노출됩니다.

Shield Action Extension - ShieldActionDelegate

차단시 각 버튼에 따른 이벤트 처리

    override func handle(action: ShieldAction, for application: ApplicationToken, completionHandler: @escaping (ShieldActionResponse) -> Void) {
        // Handle the action as needed.
        switch action {
        case .primaryButtonPressed:
            completionHandler(.close)
        case .secondaryButtonPressed:
            completionHandler(.defer)
        @unknown default:
            fatalError()
        }
    }

defer은 버튼을 눌러도 아무동작이 없습니다. 참고하세요

[Swift] WWDC25 Explore concurrency in SwiftUI

냄수 — Thu, 28 Aug 2025 20:05:17 +0900

Swift6.2에서 달라진내용과 앱의 응답성을 효율적으로 만드는 내용입니다

Concurrency를 이용해서 UI업데이트의 시점과 큰 리소스가 들어가는 작업을 효율적으로 관리하기위한 방법을 제시합니다

Swift 6.2에는 새 언어 모드가 도입됐습니다

모듈의 모든 타입에 암묵적이 @MainActor주석을 표시

투어에서 배우는 모든 내용은 새 모드와 상관없이 적용됩니다

투어에는 3가지 명소가 등장합니다(WWDC에서 각 목차를 투어에 비유함)

메인 액터의 아름다운 메도우에서 시작하여 SwiftUI가 메인 액터를 애플리케이션 컴파일 시점과 런타임 기본값으로 처리하는 방법을 살펴봅니다

그런 다음 동시성 절벽을 방문해 SwiftUI가 메인 스레드에서 작업을 분리하여 앱 UI 지연을 방지하는 방법과 데이터 레이스 버그 방지 방법을 살펴봅니다

마지막에는 캠프에 도착해 동시 코드와 SwiftUI API 간의 관계에 대해 생각해 봅니다

Main-actor Meadows

View는 @MainActor에 격리되며 구조체를 View에 맞게 조정함

따라서 ColorExtractorView는 @MainActor로 격리됨

이 점선은 추론된 격리를 나타냄
즉 이 주석은 컴파일 시점에 암시적으로 적용됨

@MainActor에 격리된 전체 타입은 모든 멤버도 암시적으로 격리됩니다

View의 요구 사항을 구현하는 본문 프로퍼티뿐만 아니라

@State 변수 같은 선언한 다른 멤버도 포함됩니다

모델의 스키마나 colorCount에 바인딩된 속성 같은 다른 멤버 속성을 참조시 공유된 @MainActor 격리가 액세스 안전을 보장하기 때문에 컴파일러에서 허용

@MainActor는 SwiftUI의 컴파일 타임 기본값입니다
따라서 대부분의 시간을 앱 기능 개발에 집중하고 동시성 문제를 고민할 필요가 없습니다

색상 추출 함수는 비동기식이므로 비동기 컨텍스트로 전환하기 위해 Task로 함수를 호출합니다

뷰 body가 @MainActor로 격리되기 때문에 이 Task에 전달한 클로저도 메인 스레드에서 실행됩니다

[훨씬 더 실용적인 이유]

- AppKit 및 UIKit의 API는 @MainActor에만 격리됨

- SwiftUI는 이러한 프레임워크와 원활하게 상호작용함

@MainActor로 주석을 달지 않아도 됩니다

SwiftUI는 API에 @MainActor 주석을 답니다 SwiftUI가 구현하는 기본 런타임 동작을 반영하기 때문

SwiftUI의 동시성 주석은 런타임 의미론을 표현합니다

Concurrency Cliffs

메인 스레드가 처리해야 할 작업이 너무 많으면 앱 프레임 드롭이나 지연이 발생할 수 있습니다 작업과 구조화된 동시성을 이용해 메인 스레드에서 컴퓨팅 작업을 분리할 수 있습니다

isLoading 속성에 반응하는 scaleEffect를 사용하고 있습니다
애니메이션 값에는 복잡한 수학이 동반됩니다
프레임 단위로 계산하면 비용이 많이 들 수 있습니다
SwiftUI는 이 계산을 백그라운드 스레드에서 수행하여 메인 스레드가 다른 작업에 더 집중하게 합니다

SwiftUI는 선언형입니다

UIView와 달리 View 프로토콜을 준수하는 구조체는 메모리에서 고정된 위치를 차지하는 객체가 아닙니다

런타임에 SwiftUI는 View에 대한 별도의 표현을 만듭니다

이 표현은 다양한 최적화 기회를 제공합니다

중요한 점은 뷰 표현의 일부를 백그라운드 스레드에서 평가하는 것

SwiftUI는 사용자를 대신해 많은 계산을 수행할 때 이 기법을 사용함

예를들어 대부분의 경우에 고빈도 기하 계산이 동반됩니다

Shape 프로토콜이 대표적인 예입니다

웨지 모양이 움직이면 작성한 path 메서드는 백그라운드 스레드에서 호출을 받습니다

뷰 수정자 visualEffect는 대상 뷰(즉 텍스트)에 적용될 효과를 정의하는 클로저를 허용합니다

시각 효과는 화려하지만 렌더링 비용은 비쌉니다 SwiftUI는 백그라운드 스레드에서 이 클로저를 호출함

Layout 프로토콜은 메인 스레드 에서 요구 사항 메서드를 호출

visualEffect처럼 onGeometryChange의 최초 인수는 백그라운드 스레드에서도 호출될 수 있는 클로저입니다

SwiftUI는 Sendable 주석을 사용하여 이 런타임 동작 또는 의미론을 컴파일러와 사용자에게 전달합니다

여기서도 SwiftUI의 동시성 주석은 런타임 의미론을 표현합니다

코드를 별도의 스레드에서 실행하면 메인 스레드가 해제되어 앱의 응답 속도가 개선됨

Sendable 키워드는 @MainActor에서 데이터를 공유할 때 발생하는 데이터 레이스 조건을 알려 줍니다

Sendable은 절벽길 경고 표지판과 같습니다

Swift는 코드 내의 레이스 조건을 안정적으로 탐지하고 컴파일러 오류로 이를 알립니다

데이터 레이스 조건을 방지하는 최고의 전략은 동시 실행되는 작업 간에 데이터를 공유하지 않는 것입니다

샌더블함수 밖에서 변수에 접근해야할때를 알아보자

SchemeContentView에서 상태 pulse 가 이 visualEffect에 필요함

Swift는 데이터 레이스 조건이 있다고 에러뜸

pulse 변수는 self.pulse의 약자입니다 @MainActor 격리 변수를 전송 가능 클로저에서 공유할 때 자주 발생하는 상황임

Self는 뷰입니다 메인 액터에 격리되어 있습니다

최종 목표는 전송 가능 클로저에서 pulse 변수에 접근하는 것입니다 이렇게 하려면 두 가지 일이 일어나야 합니다

첫째, 격리된 속성읽기를 방지해야함

값 자체가 메인 액터에서 배경 스레드 코드 영역으로 넘어가야 합니다

Swift에서는 이를 변수 자체의 백그라운드 스레드 전송이라 부릅니다

이렇게 하려면 self의 유형이 Sendable이어야 합니다

self가 적절한 위치에 있으니 이 비격리 영역에서 관련 속성 pulse를 읽겠습니다

컴파일러는 속성 pulse가 어떤 액터에도 격리되지 않은 경우에만 이를 허용합니다

코드를 다시 살펴보면 self는 View이므로 @MainActor로 보호됩니다

그래서 컴파일러는 이를 Sendable로 간주합니다

그래서 Swift는 이 self 참조가 @MainActor 격리 영역에서 Sendable 클로저로 넘어가도록 허용함

컴파일러는 self 전달은 가능하지만 @MainActor에 격리된 속성 pulse 접근은 안전하지 않다고 말합니다

컴파일 오류를 수정하려면 View를 참조하여 속성 읽기를 방지해야 합니다

작성 중인 visualEffect에는 뷰의 전체 값이 필요 없습니다

pulse가 true인지 false인지 알기만 하면 됩니다

클로저의 캡처 목록에 있는 pulse 변수의 복사본을 만들어 대신 참조할 수 있습니다

이렇게 하면 self가 클로저에 전송되지 않습니다

Bool은 단순 값 유형이므로 전송 가능 pulse의 복사본을 전송함

이 복사본은 이 함수 범위 내에서만 존재하므로 접근해도 데이터 레이스 문제가 발생하지 않습니다

이 작업을 위한 두번째 다른 전략은 우리가 읽는 모든 내용이 격리되지 않게 하는 것입니다

Code Camp

왜 Button은 비동기 클로저를 받지 않을까요?

동기식 업데이트는 좋은 사용자 경험의 필수 요소입니다

앱에 장기 실행 작업이 있으며 사용자가 결과물을 기다려야 할 때는 더 중요하죠

SwiftUI의 액션 콜백은 제 로딩 상태 같은 UI 업데이트 설정에 필요한 동기식 클로저를 허용함

반면 비동기 함수는 특히 애니메이션을 다룰 때 추가 고려사항이 있습니다

UI 프레임워크로서 프레임마다 부드러운 상호작용을 구현하려면 SwiftUI는 기기가 요구하는 특정 화면 재생 빈도를 고려해야 합니다

스크롤 같은 연속 제스처에 반응하는 코드를 작성할 때는 이 맥락을 반드시 고려해야 합니다 코드를 타임라인에 넣어 보겠습니다

녹색 삼각형을 이용해 SwiftUI가 onScrollVisibilityChange를 호출하는 시점을 표시하겠습니다

파란색 원은 상태 변환을 통해 애니메이션을 트리거하는 순간을 표시합니다

이 설정에서는 변환이 제스처 콜백과 동일한 프레임에서 발생하느냐에 따라 시각적으로 완전히 달라질 수 있습니다

이제 애니메이션 변환 전에 비동기 작업을 추가하려 합니다 비동기 작업이 시작되는 시점을 주황 선으로 표시하고 대기합니다

Task는 async 함수를 인수로 허용합니다

await를 목격하면 컴파일러는 비동기 함수를 두 개로 나눕니다

첫 번째 부분을 실행하면 Swift 런타임은 함수를 일시 중지하고 CPU에서 다른 작업을 수행할 수 있습니다

이 과정은 임의의 시간 동안 지속될 수 있습니다

이후 런타임은 원래 비동기 함수로 돌아가 두 번째 부분을 실행합니다

함수에서 await가 발생할 때마다 반복됨

타임라인으로 돌아가면 이 중단은 작업 완료가 기기에서 지정된 새로 고침 마감 시간 이후에도 재개되지 않을 수 있음을 의미합니다

그래서 애니메이션이 버벅거리는 것처럼 보입니다

따라서 비동기 함수 변형은 목표 달성에 도움이 되지 않죠

애니메이션 같은 시간에 민감한 로직은 SwiftUI의 입력과 출력이 동기화되어야 합니다

Observable 속성의 동기화된 변환과 동기화된 콜백은 프레임워크와의 상호작용에서 가장 자연스러운 타입입니다

앱이 많은 동시 작업을 수행한다면 UI 코드와 비 UI 코드 사이의 경계를 찾아보세요

비동기 작업의 로직을 뷰 로직에서 분리하세요

상태 일부를 브리지로 사용할 수 있습니다 상태는 UI 코드와 비동기 코드를 분리합니다

비동기 작업이 완료되면 상태에 동기식 변경을 수행하여 UI가 이 변경에 반응해 업데이트되게 합니다

이런 방식으로 UI 로직은 대부분 동기식이 됩니다

또한, 비동기 코드에 대한 테스트 작성이 더 쉬워집니다 UI 로직과 독립적으로 작동하기 때문이죠

뷰는 여전히 Task를 이용해 비동기 컨텍스트로 전환 가능하죠

하지만 코드를 최대한 간단하게 유지해야 합니다 UI 이벤트를 모델에 알리는 역할을 합니다

UI 코드 중 시간에 민감한 변경이 많이 필요한 부분과 장기 실행되는 비동기 로직 간의 경계를 찾으면 앱 구조를 개선할 수 있습니다

뷰의 동기성과 반응성 유지에도 도움이 됩니다 UI가 아닌 코드를 잘 정리하는 것도 중요합니다

Swift 6.2는 우수한 기본 액터 격리 설정을 제공합니다 기존 앱이 있다면 시도해 보세요

대부분의 @MainActor 주석을 삭제할 수 있습니다

Mutex는 클래스를 전송 가능으로 만드는 중요 도구입니다

[Swift] WWDC25 Wake up to the AlarmKit API

냄수 — Tue, 22 Jul 2025 18:14:28 +0900

최근에 알람관련기능을 개발하면서 알람은 왜지원을 안해주는건가

많이 불편했었는데

이제야 지원을 해주네요??

시대를 빨리태어난 요구사항이 돼버렷습니다..

아무튼!

오늘은 WWDC25주제중 AlarmKit에 관련된 내용을 정리해보려합니다

알람이란?

고정되거나 예정된 시간에 발생하는 일에 대한 두드러진 알림

일정이나 카운트기반으로 작동

무음모드와 현재 포커스상태를 무시하고 실행됨

이게 중요한거같아요

잘때 알람맞추고자면 어떤상태든 아침에 울리듯이

어떠한 상태여도 알림을 줄 수 있죠

기본구성으로는

- 알람제목

- 앱이름 표시

- 앱 인텐트로 정의된 동작을 가진 커스텀 버튼 혹은 미루기 버튼

을 갖는 UI가 노출됩니다

Authorization관련해서는

사용자가 앱내에서 권한을 동의해야 사용가능하고

수동으로 요청하거나 첫알람 생성시 자동으로 요청되도록 가능하다고하네요

언제든지 설정앱에서 권한상태를 변경할 수 있습니다.

다른 권한들처럼 앱의 info.plist에 NSAlarmKitUsageDescription를 추가하여 알람사용 사례를 설명하면 됩니다.

수동으로 권한요청시 requestAuthorization를 사용하고

권한 상태 확인시 AlarmManager 클래스의 authorizationState를 사용해서 확인하고

권한 거부시 알람이 예약되지않음을 명확하게 표시해야합니다.

알람생성시 필요한 주요요소

- Countdown duration: 카운트다운 시간

- Schedule: 특정날짜나 반복패턴 일정

- Appearance: 알람표시 맞춤화

- Action: 알람동작 맞춤화

- Sound: 알람 관련소리

이렇게 5가지가 주요요소입니다.

하나씩 살펴보면

Countdown duration

알림이 처음 예약되면 알람전 카운트다운 시간에 표시될 카운트다운 UI가 표시됨

알람 시간이 경과하면 알람이 발동되고 구성에 따라서 커스텀된 알람UI가 표시됨

이때 알람에대해 다시 알림이 선택되면 다음알람 간격동안 카운트다운 UI가 다시 표시됨

이 간격이 경과하면 알람이 다시 발동되고 사용자가 알림을 선택하거나 무시 할 수 있음

위의코드는 10분후 알람 타이머를 설정하는 코드(여기서는 알람 전 10분이라고 설명합니다 그래서 preAlert 라고하나보네요)

타이머가 발동되고 반복되면 5분후 다시 발동됨

Schedule

[고정시간]

고정일정은 알람이 울릴 특정 미래날짜를 지정

일정은 절대적이고 기기 시간대가 바뀌어도 변경되지 않음

위의코드는 Date만들어서 Alarm셋팅하는 코드

Alarm.Schedule.fixed

[상대시간]

상대적인 일정을 지정할 수 있음

여기에는 시간이 포함되고, 주간 반복 패턴을 추가할 수도 있음

상대적인 일정은 시간대의 변화를 고려함

위의코드는 알람이 매주 월,수,금 오전 7시에 울리도록 설정하는코드

Alarm.Schedule.Relative

Appearance

AlarmButton타입을 이용해서 알람버튼을 구현가능

텍스트, 텍스트색, 시스템 이미지 지정가능

AlarmPresentation.Alert: 알람 제목, stop버튼 설정가능

AlarmAttributes: 알람 표시를 렌더링 하기위해 필요한 정보

기본적인 알림은 여기까지 설정만하면 됨

카운트다운을 시작하는 반복버튼을 추가하고

카운트다운UI를 표시하려면 아래와같이 설정해야함

먼저 반복버튼을 추가하는 과정을 아래와같음

AlarmPresentation.Alert에 보조 버튼으로 Repeat버튼을 만들어서 넣어줌

secondaryButtonBehavior으로 타이머반복, 다시알림과 같은 카운트다운 상태로 전활할지, 커스텀 작업을 실행할지 지정

이제 카운트다운 UI를 구현하기위해서는 Live Activity(실시간현황)를 구현해줘야함

카운트다운은 잠금화면, Dynamic Island, 스탠바이에서 표시됨

Live Activity를 앱의 위젯 확장프로그램에 추가하고

ActivityConfiguration을 설정하고

AlarmAttributes를 메타데이터 유형으로 지정하면 됨

라이브 액티비티 설정

다이나믹 아일랜드 설정

다이나믹 아일랜드 디자인의 확장 영역 설정

추가정보는 알람 메타데이터에서 제공할 수 있음

AlarmAttributes을 생성할 때 이 커스텀된 메타데이터를 포함하면됨

컨텍스트 속성을 통해서 커스텀 메타데이터에 접근가능

알람이 카운트 다운기능을 지원하는경우 시스템은 카운트다운 인터페이스가 표시되도록 함

그런데 기기가 재시동되고 처음으로 잠금해제가 되기전처럼 실시간 현황이 표시 불가능한 상황도 있음

이러한 경우 시스템의 카운트다운 표시방식을 커스텀할 수 있음

잠금화면에서는 보조버튼의 아이콘, 알림제목, 카운트다운에 tintColor가 사용됨

다이나믹 아일랜드에서도 유사한방식으로 사용됨

Action

AlarmKit은 사용자가 알람버튼을 탭할때 자체코드를 실행하는 기능도 제공함

앱 인텐트로 구현

중지 버튼이나 보조 버튼에대한 커스텀 앱인텐트 제공

맞춤형 동작을 실행하도록 보조버튼 동작을 custom으로 설정합니다

알람을 예약할때 알람생성후 추적할 수 있는 고유 식별자를 생성하고

OpenInApp타입인 인텐트(LiveActivityIntent프로토콜)의 인스턴스를 생성하고

알람의 고유 식별자를 전달합니다

보조버튼이 탭될 때 이 인텐트를 실행하라고 시스템에 알립니다

Sound

알람은 기본 시스템 소리를 사용합니다

알람에 커스텀 소리를 제공할 수도 있습니다.

AlertSound구조체를 사용해서 커스텀 소리를 정의할 수 있습니다.

이 파일은 앱의 메인 번들이나 앱 데이터 컨테이너의 Library/Sounds 폴더에 있어야합니다

Life Cycle

알람을 구성한후 시스템을 통해 알람을 예약 할 수 있습니다.

예약하려면 알람의 고유식별자와 이전에 생성한 configuration을 사용합니다

알람 라이프사이클을 완전히 제어할 수 있고

카운트다운 상태로 전환하거나, 취소, 중지, 일시정지, 다시시작이 가능합니다.

[Swift] Vision OCR 인식

냄수 — Wed, 25 Jun 2025 21:34:20 +0900

Vision Framework를 사용해서 이미지속의 텍스트를 인식할 수 있는 OCR 기능을 구현해보려합니다

OCR 이란?

광학 문자 인식 Optical Character Recognition의 약자로 이미지나 스캔 문서에 있는 텍스트를 기계가 읽을 수 있는 텍스트로 변환하는 기술입니다.

애플에서 제공되는 텍스트 인식기능은

2가지 방법으로 이용합니다

fast path방식과 accurate path방식이 있습니다.

Fast

프레임워크의 문자 감지 기능을 사용해서 개별문자를 찾은다음, 작은 머신 러닝 모델을 사용하여 개별 문자와 단어를 인식

이 접근방식은 기존 OCR과 유사함

Accurate (default)

신경망을 이용해서 문자열과 줄로 이루어진 텍스트를 찾은다음 추가 분석을 수행하여 개별 단어와 문장을 찾음

이 접근방식은 사람이 텍스트를 읽는 방식과 훨씬 더 일치함

VNRequestTextRecognitionLevel타입으로 제공되고

VNRecognizeTextRequest의 recognitionLevel옵션을 변경하면 적용됩니다

let textRequest = VNRecognizeTextRequest()
textRequest.recognitionLevel = .accurate

구현

단순 OCR인식 코드구현은 간단합니다

사용하기 편리하게 제공된거같네요

guard let image = uiImage.cgImage else {
    print("cgImage nil!!")
    return
}

let textRequest = VNRecognizeTextRequest()
textRequest.revision = VNRecognizeTextRequestRevision3
textRequest.recognitionLanguages = ["ko-KR", "en-US"]
textRequest.usesLanguageCorrection = false
textRequest.minimumTextHeight = 0.1
textRequest.recognitionLevel = .accurate

let handler = VNImageRequestHandler(cgImage: image)
do {
    // 요청실행
    try handler.perform([textRequest])
    
    // 요청값 반환
    let text = textRequest.results?.compactMap { $0.topCandidates(1).first?.string }.joined(separator: "\n") ?? ""
    print(text)
}

Request 옵션을 하나씩알아볼게요

revision - 엔진 버전 선택(최신이 좋아요 iOS지원 버전에맞게 선택하세요!)

recognitionLanguages - 인식할 언어

textRequest.supportedRecognitionLanguages()

위의코드를 실행해서 인식가능한 언어목록을 확인할 수 있어요

인식할 언어 ko-KR를 안넣어주면 한국어가 있어도 한국어로 인식하지않아요

usesLanguageCorrection - 인식 프로세스 중에 언어보정을 할건지 옵션이에요

비활성화하면 원시 인식 결과값이 반환되서 성능은 좋지만 정확도가 떨어져요

minimumTextHeight - 이미지 높이에 상대적인 크기의 텍스트를 인식하는 옵션이에요

예를들어 이미지높이의 절반인 텍스트로 인식을 제한하려면 0.5를 넣어요

크게크게 보기때문에 메모리 사용량이 줄고, 인식속도가 빨라지지만 작은크기 텍스트는 무시합니다.

기본값은 0.03125 라고하네요

(테스트할때 0.1~0.9 다 비슷하게나와서 체감을 못하겠어요 )

recognitionLevel - 위에서 말한 인식요청 우선순위를 정하는 옵션입니다.

VNImageRequestHandler의 perform()

요청을 수행하는 함수입니다.

이때 인식이 시작됩니다

try handler.perform([textRequest])

VNRecognizeTextRequest.results

perform을 했을때 VNRecognizedTextObservation타입의 결과값 배열이 반환되요

    let text = textRequest.results?.compactMap { $0.topCandidates(1).first?.string }.joined(separator: "\n") ?? ""

$0.topCandidates(1) - 인식결과값이 여러개인데 그중 우선순위 최상위 1개만 받겠다 라는 옵션이에요

인식한 문자 하나하나의 결과값을 joined시켜서 하나의 문장으로 만들어주는 코드에요

실험

인식시킬 테스트 이미지를 만들어봤어요

각 글씨크기별로 인식차이와 영어 한글 숫자 차이를 알아보려합니다!

결과를 극단적으로 비교하기위해서

우선 처음테스트는 정확도우선의 옵션을 설정했어요

let textRequest = VNRecognizeTextRequest()
textRequest.revision = VNRecognizeTextRequestRevision3
textRequest.recognitionLanguages = ["ko-KR", "en-US"]
textRequest.usesLanguageCorrection = true
textRequest.recognitionLevel = .accurate

출력값은 아래와같아요

12 point 포인트
14 point 포인트
16 point 포인트
20 point 포인트
24 point 포인트
32 point 포인트
36 point 포인트
40 point 포인트
48 point 포인트
0123456789 0123456789
01234567890123456789
0123456789 0123456789
0123456790123456789
01234567890123456789
01234567890123456789
01234567890123456789
01234567890123456789
01234567890123456789
64 point 포인트
01234567890123456789
1 장, 0.800754084 seconds

정확하게 잘 인식하네요

하지만 이때 고려해야할게 하나 있죠 바로 시간입니다

1장을 인식하는데 0.8초라 여러장의 사진을 인식하려한다면 고려해야할 부분이 많아지겠죠?

다음으론

빠름우선의 옵션을 설정해볼게요

let textRequest = VNRecognizeTextRequest()
textRequest.revision = VNRecognizeTextRequestRevision3
textRequest.recognitionLanguages = ["ko-KR", "en-US"]
textRequest.usesLanguageCorrection = false
//        textRequest.minimumTextHeight = 0.1  << fast일때 설정하면 아무결과를 받지못합니다
textRequest.recognitionLevel = .fast

출력값은 아래와같아요

12 point &oI_
01234587890123456789
14 point EOI
01234567890123456789
16 point EOIE
01234567890123456789
20 point £oI E
01234567890123456789
24 point £oI E
01234567890123456789
32 point &OI E
01234567890123456789
36 point &oIE
01234567890123456789
40 point £OIE
01234567890123456789
48 point lOI E
01234567890123456789
64 point lOI E
01234567890123456789
1 장, 0.077625583 seconds

12point 테스트케이스인 1번째줄은 6과 8을 정확하게 인식하지못햇네요

나머지 숫자와 영어는 잘인식되늰데 한글을 인식하지못하네요

그리고 위코드에서 보이듯이 minimumTextHeight를 fast옵션과 함께주면 텍스트인식을 못해서 아무결과값을 받지못해요

시간도보면 0.07초로 10배차이가 나는걸 볼 수있어요

시간과 성능의 트레이드오프인 옵션들이라 테스트하면서 잘 선택하면 좋을 것 같아요!

마지막으로 이젠 여러장을 인식할때 async로 동시에 돌리고싶을때를 가정하고

코드를 한번 바꿔볼게요

텍스트인식 구현부는 아래와같구요

private func excuteRequest(uiImage: UIImage) async -> [VNRecognizedTextObservation] {
    guard let image = uiImage.cgImage else {
        print("cgImage nil!!")
        return []
    }
    let textRequest = VNRecognizeTextRequest()
    textRequest.revision = VNRecognizeTextRequestRevision3
    textRequest.recognitionLanguages = ["ko-KR", "en-US"]
    textRequest.usesLanguageCorrection = false
//        textRequest.minimumTextHeight = 0.1
    textRequest.recognitionLevel = .fast
    
    let handler = VNImageRequestHandler(cgImage: image)
    
    return await withUnsafeContinuation { continuation in
        do {
            try handler.perform([textRequest])
            let observations = textRequest.results ?? []
            continuation.resume(returning: observations)
        } catch {
            print(error)
            continuation.resume(returning: [])
        }
    }
}

상위에서 이미지를 넣어주는 코드는 아래와같습니다.

func recognizeText() async {
    let images: [UIImage] = [
        .폰트테스트png,
        .폰트테스트png,
    ]
    
    let time = await clock.measure {
        // 이미지 총갯수를 4개의 이미지그룹으로 분리
        let imageGroups = images.splitFourStride()
        
        let recognizationString = await withTaskGroup(of: String.self) { group in
            imageGroups.forEach { imageGroup in
                group.addTask {
                    await self.excute(imageGroup: imageGroup)
                }
            }
            var result: String = ""
            for await value in group {
                result += value
            }
            return result
        }
        
        // 종합된 결과 텍스트
        print(recognizationString)
    }
    
    // 인식한 장수, 인식까지 걸린시간
    print(images.count, "장", time)
}

// 각 그룹별 인식결과 반환
private func excute(imageGroup: [UIImage]) async -> String {
    var totalString = ""
    for (i, image) in imageGroup.enumerated() {
        let results = await self.excuteRequest(uiImage: image)
        let text = results.compactMap { $0.topCandidates(1).first?.string }.joined(separator: "\n")
        totalString += text
    }
    return totalString
}

10개의 이미지를 4개의 그룹으로 실행시킨 결과 아래와같이 동시에 잘 진행되는걸 확인할 수 있어요

비교를위해 그룹을 나누지않는다면 아래와같은 그림처럼 동시에 진행하진 않는걸 볼 수 있어요

NamS의 iOS일기

[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?

LanguageModelSession

GenerationOptions

Generable

GenerationGuide

Tool

[Swift] Core Image Filter

Core Image란?

CIFilter이란..?

2025 회고

# 월별 기록

# 커리어 회고

# 인생 회고

# 2026 목표

[Swift] Vision FaceDetect

VNDetectFaceRectanglesRequest란?

VNFaceObservation란?

[Swift] Screen Time API(DeviceActivity)

DeviceActivity란

Device Activity Monitor Extension

Device Activity Report Extension

DeviceActivityReport.Context

DeviceActivityResults

DeviceActivityData

차트구현

[Swift] Screen Time API(FamilyControls, ManagedSettings)

Family Controls

FamilyActivitySelection

Managed Settings

ManagedSettingsStore

Shield

[Swift] WWDC25 Explore concurrency in SwiftUI

Main-actor Meadows