🛡️ PermissionKit

⭐ Difficulty: ⭐⭐ ⏱️ Est. Time: 1h 📂 iOS 26

Build privacy-respecting apps with unified permission management

iOS 18+🆕 2024

✨ PermissionKit is?

PermissionKit is a unified permission management framework introduced in iOS 18. It manages various system permissions — camera, microphone, location, notifications, contacts — through a single consistent API. It tracks permission status in real-time, provides deep links to Settings when denied, and displays contextual explanations before requesting permissions to improve UX. A modern, privacy-first permission management solution.

💡 Key Features: Unified Permission API · Real-Time Status Tracking · Settings Deep Link · Contextual UI · Partial Permissions · Provisional Access · Permission Groups · SwiftUI Integration

🎯 1. Basic Setup

Set up PermissionKit and add permission descriptions to Info.plist.

Info.plist — Add Permission Descriptions

<!-- 카메라 -->
<key>NSCameraUsageDescription</key>
<string>사진을 촬영하고 프로필 이미지를 설정하는데 사용됩니다.</string>

<!-- 사진 라이브러리 -->
<key>NSPhotoLibraryUsageDescription</key>
<string>사진을 저장하고 불러오는데 사용됩니다.</string>

<!-- 위치 (사용 중) -->
<key>NSLocationWhenInUseUsageDescription</key>
<string>주변 장소를 검색하고 날씨 정보를 제공하는데 사용됩니다.</string>

<!-- 위치 (항상) -->
<key>NSLocationAlwaysAndWhenInUseUsageDescription</key>
<string>위치 기반 알림을 보내는데 사용됩니다.</string>

<!-- 마이크 -->
<key>NSMicrophoneUsageDescription</key>
<string>음성 메시지를 녹음하는데 사용됩니다.</string>

<!-- 연락처 -->
<key>NSContactsUsageDescription</key>
<string>친구를 찾고 초대하는데 사용됩니다.</string>

<!-- 알림 -->
<key>NSUserNotificationsUsageDescription</key>
<string>중요한 업데이트를 알려드리는데 사용됩니다.</string>

PermissionManager.swift — Permission Manager

import SwiftUI
import AVFoundation
import CoreLocation
import UserNotifications
import Contacts
import Photos

// 권한 타입
enum PermissionType: String, CaseIterable, Identifiable {
    case camera = "카메라"
    case photoLibrary = "사진"
    case location = "위치"
    case microphone = "마이크"
    case contacts = "연락처"
    case notifications = "알림"

    var id: String { rawValue }

    var icon: String {
        switch self {
        case .camera: return "camera.fill"
        case .photoLibrary: return "photo.fill"
        case .location: return "location.fill"
        case .microphone: return "mic.fill"
        case .contacts: return "person.2.fill"
        case .notifications: return "bell.fill"
        }
    }

    var description: String {
        switch self {
        case .camera: return "사진과 비디오를 촬영하는데 필요합니다"
        case .photoLibrary: return "사진을 저장하고 불러오는데 필요합니다"
        case .location: return "주변 장소를 찾는데 필요합니다"
        case .microphone: return "음성을 녹음하는데 필요합니다"
        case .contacts: return "친구를 찾는데 필요합니다"
        case .notifications: return "중요한 알림을 받는데 필요합니다"
        }
    }
}

// 권한 상태
enum PermissionStatus {
    case notDetermined
    case authorized
    case denied
    case restricted
    case limited // 부분 권한 (사진 등)

    var color: Color {
        switch self {
        case .notDetermined: return .gray
        case .authorized: return .green
        case .denied: return .red
        case .restricted: return .orange
        case .limited: return .yellow
        }
    }

    var text: String {
        switch self {
        case .notDetermined: return "미설정"
        case .authorized: return "허용됨"
        case .denied: return "거부됨"
        case .restricted: return "제한됨"
        case .limited: return "제한적 허용"
        }
    }
}

// 통합 권한 관리자
@Observable
class PermissionManager {
    var permissions: [PermissionType: PermissionStatus] = [:]

    init() {
        // 초기 상태 확인
        Task {
            await checkAllPermissions()
        }
    }

    // 모든 권한 상태 확인
    func checkAllPermissions() async {
        for type in PermissionType.allCases {
            let status = await checkPermission(type)
            await MainActor.run {
                permissions[type] = status
            }
        }
    }

    // 개별 권한 확인
    func checkPermission(_ type: PermissionType) async -> PermissionStatus {
        switch type {
        case .camera:
            return checkCameraPermission()

        case .photoLibrary:
            return checkPhotoLibraryPermission()

        case .location:
            return checkLocationPermission()

        case .microphone:
            return checkMicrophonePermission()

        case .contacts:
            return await checkContactsPermission()

        case .notifications:
            return await checkNotificationPermission()
        }
    }

    // 카메라 권한
    func checkCameraPermission() -> PermissionStatus {
        switch AVCaptureDevice.authorizationStatus(for: .video) {
        case .notDetermined: return .notDetermined
        case .authorized: return .authorized
        case .denied: return .denied
        case .restricted: return .restricted
        @unknown default: return .notDetermined
        }
    }

    // 사진 권한
    func checkPhotoLibraryPermission() -> PermissionStatus {
        switch PHPhotoLibrary.authorizationStatus(for: .readWrite) {
        case .notDetermined: return .notDetermined
        case .authorized: return .authorized
        case .denied: return .denied
        case .restricted: return .restricted
        case .limited: return .limited
        @unknown default: return .notDetermined
        }
    }

    // 위치 권한
    func checkLocationPermission() -> PermissionStatus {
        let status = CLLocationManager().authorizationStatus

        switch status {
        case .notDetermined: return .notDetermined
        case .authorizedAlways, .authorizedWhenInUse: return .authorized
        case .denied: return .denied
        case .restricted: return .restricted
        @unknown default: return .notDetermined
        }
    }

    // 마이크 권한
    func checkMicrophonePermission() -> PermissionStatus {
        switch AVAudioSession.sharedInstance().recordPermission {
        case .undetermined: return .notDetermined
        case .granted: return .authorized
        case .denied: return .denied
        @unknown default: return .notDetermined
        }
    }

    // 연락처 권한
    func checkContactsPermission() async -> PermissionStatus {
        switch CNContactStore.authorizationStatus(for: .contacts) {
        case .notDetermined: return .notDetermined
        case .authorized: return .authorized
        case .denied: return .denied
        case .restricted: return .restricted
        @unknown default: return .notDetermined
        }
    }

    // 알림 권한
    func checkNotificationPermission() async -> PermissionStatus {
        let settings = await UNUserNotificationCenter.current().notificationSettings()

        switch settings.authorizationStatus {
        case .notDetermined: return .notDetermined
        case .authorized, .provisional, .ephemeral: return .authorized
        case .denied: return .denied
        @unknown default: return .notDetermined
        }
    }
}

🔐 2. 권한 요청

사용자에게 권한을 요청하고 결과 handling.

PermissionRequest.swift — Permission Request

import SwiftUI

extension PermissionManager {
    // 권한 요청
    func requestPermission(_ type: PermissionType) async -> PermissionStatus {
        switch type {
        case .camera:
            return await requestCameraPermission()

        case .photoLibrary:
            return await requestPhotoLibraryPermission()

        case .location:
            // 위치는 CLLocationManager 델리게이트 필요
            return .notDetermined

        case .microphone:
            return await requestMicrophonePermission()

        case .contacts:
            return await requestContactsPermission()

        case .notifications:
            return await requestNotificationPermission()
        }
    }

    func requestCameraPermission() async -> PermissionStatus {
        let granted = await AVCaptureDevice.requestAccess(for: .video)
        return granted ? .authorized : .denied
    }

    func requestPhotoLibraryPermission() async -> PermissionStatus {
        let status = await PHPhotoLibrary.requestAuthorization(for: .readWrite)

        switch status {
        case .authorized: return .authorized
        case .limited: return .limited
        case .denied: return .denied
        case .restricted: return .restricted
        default: return .notDetermined
        }
    }

    func requestMicrophonePermission() async -> PermissionStatus {
        let granted = await AVAudioSession.sharedInstance().requestRecordPermission()
        return granted ? .authorized : .denied
    }

    func requestContactsPermission() async -> PermissionStatus {
        do {
            let granted = try await CNContactStore().requestAccess(for: .contacts)
            return granted ? .authorized : .denied
        } catch {
            return .denied
        }
    }

    func requestNotificationPermission() async -> PermissionStatus {
        do {
            let granted = try await UNUserNotificationCenter.current()
                .requestAuthorization(options: [.alert, .badge, .sound])
            return granted ? .authorized : .denied
        } catch {
            return .denied
        }
    }

    // 설정 앱으로 이동
    func openSettings() {
        guard let settingsURL = URL(string: UIApplication.openSettingsURLString)
        else { return }

        UIApplication.shared.open(settingsURL)
    }
}

📱 3. 권한 UI

사용자 친화적인 권한 요청 화면을 만듭.

PermissionView.swift — 권한 화면

import SwiftUI

struct PermissionListView: View {
    @State private var manager = PermissionManager()

    var body: some View {
        NavigationStack {
            List(PermissionType.allCases) { type in
                PermissionRow(
                    type: type,
                    status: manager.permissions[type] ?? .notDetermined,
                    onRequest: {
                        Task {
                            let newStatus = await manager.requestPermission(type)
                            manager.permissions[type] = newStatus
                        }
                    },
                    onOpenSettings: {
                        manager.openSettings()
                    }
                )
            }
            .navigationTitle("권한 관리")
            .task {
                await manager.checkAllPermissions()
            }
        }
    }
}

struct PermissionRow: View {
    let type: PermissionType
    let status: PermissionStatus
    let onRequest: () -> Void
    let onOpenSettings: () -> Void

    var body: some View {
        VStack(alignment: .leading, spacing: 12) {
            HStack {
                Image(systemName: type.icon)
                    .font(.title2)
                    .foregroundStyle(.blue)
                    .frame(width: 40)

                VStack(alignment: .leading, spacing: 4) {
                    Text(type.rawValue)
                        .font(.headline)

                    Text(type.description)
                        .font(.caption)
                        .foregroundStyle(.secondary)
                }

                Spacer()

                // 상태 배지
                Text(status.text)
                    .font(.caption)
                    .fontWeight(.semibold)
                    .foregroundStyle(.white)
                    .padding(.horizontal, 8)
                    .padding(.vertical, 4)
                    .background(status.color)
                    .cornerRadius(8)
            }

            // 액션 버튼
            switch status {
            case .notDetermined:
                Button {
                    onRequest()
                } label: {
                    Text("권한 허용")
                        .frame(maxWidth: .infinity)
                        .padding(8)
                        .background(Color.blue)
                        .foregroundStyle(.white)
                        .cornerRadius(8)
                }
                .buttonStyle(.plain)

            case .denied:
                VStack(spacing: 8) {
                    Text("권한이 거부되었습니다")
                        .font(.caption)
                        .foregroundStyle(.red)

                    Button {
                        onOpenSettings()
                    } label: {
                        Label("설정에서 허용하기", systemImage: "gear")
                            .frame(maxWidth: .infinity)
                            .padding(8)
                            .background(Color.gray.opacity(0.2))
                            .foregroundStyle(.primary)
                            .cornerRadius(8)
                    }
                    .buttonStyle(.plain)
                }

            case .limited:
                Button {
                    onRequest()
                } label: {
                    Text("전체 액세스 허용")
                        .frame(maxWidth: .infinity)
                        .padding(8)
                        .background(Color.orange)
                        .foregroundStyle(.white)
                        .cornerRadius(8)
                }
                .buttonStyle(.plain)

            case .authorized:
                HStack {
                    Image(systemName: "checkmark.circle.fill")
                        .foregroundStyle(.green)
                    Text("권한이 허용되었습니다")
                        .font(.caption)
                        .foregroundStyle(.secondary)
                }

            case .restricted:
                Text("기기 설정에 의해 제한되었습니다")
                    .font(.caption)
                    .foregroundStyle(.orange)
            }
        }
        .padding(.vertical, 8)
    }
}

🎭 4. 온보딩 통합

Build an onboarding screen that explains and requests permissions on first launch.

PermissionOnboardingView.swift — Onboarding

import SwiftUI

struct PermissionOnboardingView: View {
    @State private var manager = PermissionManager()
    @State private var currentStep = 0
    @Environment(\.dismiss) var dismiss

    let steps: [PermissionType] = [.camera, .photoLibrary, .location, .notifications]

    var body: some View {
        VStack(spacing: 32) {
            // 진행 표시
            HStack(spacing: 8) {
                ForEach(0..<4, id: \.self) { index in
                    Capsule()
                        .fill(index <= currentStep ? Color.blue : Color.gray.opacity(0.3))
                        .frame(height: 4)
                }
            }
            .padding(.horizontal)

            Spacer()

            // 현재 단계 콘텐츠
            if currentStep < steps.count {
                PermissionStepView(type: steps[currentStep])
            } else {
                CompletionView()
            }

            Spacer()

            // 액션 버튼
            VStack(spacing: 12) {
                if currentStep < steps.count {
                    Button {
                        Task {
                            let type = steps[currentStep]
                            let status = await manager.requestPermission(type)
                            manager.permissions[type] = status
                            currentStep += 1
                        }
                    } label: {
                        Text("허용")
                            .font(.headline)
                            .frame(maxWidth: .infinity)
                            .padding()
                            .background(Color.blue)
                            .foregroundStyle(.white)
                            .cornerRadius(12)
                    }

                    Button {
                        currentStep += 1
                    } label: {
                        Text("나중에")
                            .font(.subheadline)
                            .foregroundStyle(.secondary)
                    }
                } else {
                    Button {
                        dismiss()
                    } label: {
                        Text("시작하기")
                            .font(.headline)
                            .frame(maxWidth: .infinity)
                            .padding()
                            .background(Color.blue)
                            .foregroundStyle(.white)
                            .cornerRadius(12)
                    }
                }
            }
            .padding()
        }
    }
}

struct PermissionStepView: View {
    let type: PermissionType

    var body: some View {
        VStack(spacing: 24) {
            // 아이콘
            Image(systemName: type.icon)
                .font(.system(size: 80))
                .foregroundStyle(.blue)
                .symbolEffect(.bounce)

            // 제목과 설명
            VStack(spacing: 8) {
                Text(type.rawValue)
                    .font(.title)
                    .fontWeight(.bold)

                Text(type.description)
                    .font(.body)
                    .foregroundStyle(.secondary)
                    .multilineTextAlignment(.center)
            }
            .padding(.horizontal)

            // 사용 예시
            VStack(alignment: .leading, spacing: 12) {
                Text("이런 용도로 사용됩니다:")
                    .font(.headline)

                VStack(alignment: .leading, spacing: 8) {
                    usageExample("프로필 사진 촬영")
                    usageExample("문서 스캔")
                    usageExample("AR 기능 사용")
                }
            }
            .padding()
            .frame(maxWidth: .infinity, alignment: .leading)
            .background(Color.gray.opacity(0.1))
            .cornerRadius(12)
            .padding(.horizontal)
        }
    }

    func usageExample(_ text: String) -> some View {
        HStack {
            Image(systemName: "checkmark.circle.fill")
                .foregroundStyle(.green)
            Text(text)
                .font(.subheadline)
        }
    }
}

struct CompletionView: View {
    var body: some View {
        VStack(spacing: 24) {
            Image(systemName: "checkmark.circle.fill")
                .font(.system(size: 80))
                .foregroundStyle(.green)

            VStack(spacing: 8) {
                Text("모두 완료!")
                    .font(.title)
                    .fontWeight(.bold)

                Text("이제 앱의 모든 기능을 사용할 수 있습니다")
                    .font(.body)
                    .foregroundStyle(.secondary)
            }
        }
    }
}

🔄 5. 실시간 권한 모니터링

Detect and respond to permission changes while the app is running.

PermissionMonitor.swift — Real-Time Monitoring

import SwiftUI
import Combine

@Observable
class PermissionMonitor {
    var cameraAvailable = false
    var locationAvailable = false
    var showPermissionAlert = false
    var alertMessage = ""

    private var cancellables = Set<AnyCancellable>()

    init() {
        startMonitoring()
    }

    func startMonitoring() {
        // 앱 포그라운드 진입 시 권한 재확인
        NotificationCenter.default.publisher(for: UIApplication.willEnterForegroundNotification)
            .sink { _ in
                Task {
                    await self.checkPermissions()
                }
            }
            .store(in: &cancellables)
    }

    func checkPermissions() async {
        // 카메라 권한 확인
        let cameraStatus = AVCaptureDevice.authorizationStatus(for: .video)
        let cameraWasAvailable = cameraAvailable
        cameraAvailable = cameraStatus == .authorized

        // 권한이 취소된 경우
        if cameraWasAvailable && !cameraAvailable {
            await showAlert("카메라 권한이 취소되었습니다. 설정에서 다시 허용해주세요.")
        }

        // 위치 권한 확인
        let locationStatus = CLLocationManager().authorizationStatus
        let locationWasAvailable = locationAvailable
        locationAvailable = locationStatus == .authorizedWhenInUse || locationStatus == .authorizedAlways

        if locationWasAvailable && !locationAvailable {
            await showAlert("위치 권한이 취소되었습니다. 설정에서 다시 허용해주세요.")
        }
    }

    func showAlert(_ message: String) async {
        await MainActor.run {
            alertMessage = message
            showPermissionAlert = true
        }
    }
}

// 사용 예제
struct CameraView: View {
    @State private var monitor = PermissionMonitor()

    var body: some View {
        VStack {
            if monitor.cameraAvailable {
                Text("카메라 사용 가능")
                // 카메라 UI
            } else {
                ContentUnavailableView {
                    Label("카메라 권한 필요", systemImage: "camera.fill")
                } description: {
                    Text("설정에서 카메라 권한을 허용해주세요")
                } actions: {
                    Button("설정 열기") {
                        PermissionManager().openSettings()
                    }
                }
            }
        }
        .alert("권한 변경", isPresented: $monitor.showPermissionAlert) {
            Button("설정 열기") {
                PermissionManager().openSettings()
            }
            Button("확인", role: .cancel) { }
        } message: {
            Text(monitor.alertMessage)
        }
        .task {
            await monitor.checkPermissions()
        }
    }
}

💡 HIG Guidelines

명확한 이유: 권한이 왜 필요한지 사용자가 이해할 수 있도록 설명
Appropriate Timing: 기능을 사용하려는 시점에 권한 요청
우아한 저하: 권한이 없어도 앱의 다른 기능은 사용 가능하도록
재요청 금지: 거부된 권한을 반복적으로 요청하지 않음
설정 안내: 거부 시 설정 앱으로 이동하는 명확한 경로 제공

🎯 Practical Usage

소셜 앱: 연락처, 카메라, 알림 권한 통합 관리
헬스 앱: HealthKit, 위치, 알림 권한 온보딩
포토 앱: 사진 라이브러리 부분 권한 활용
Messaging Apps: 마이크, 카메라 실시간 권한 확인
내비게이션 앱: 위치 권한 상태 모니터링

📚 Learn More

⚡️ 팁: PermissionKit puts user privacy first. Always explain context before requesting permissions, and design your app to work properly even when denied. Leverage partial permissions (e.g., selected photos only) to increase user trust. Re-check permission status whenever the app returns to foreground for a consistent experience.

📎 Apple Official Resources

📘 Documentation 🎬 WWDC Sessions