🎯 RelevanceKit

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

컨텍스트 인식 기반 앱 제안 및 우선순위 관리

iOS 18+🆕 2024

✨ RelevanceKit is?

RelevanceKit is a framework introduced in iOS 18 that lets your app communicate relevance to the system based on the user's current context (location, time, activity, etc.). This ensures your app surfaces at the right time in Spotlight search, Live Activity priority, Siri Suggestions and more.

💡 Key Features: Context Relevance Signals · Live Activity Priority · Spotlight Integration · User Intent Prediction · Background Updates · Privacy Protection

🎯 1. Basic Setup

Define your app's relevance context using RelevanceKit.

RelevanceManager.swift — Basic Setup

import RelevanceKit
import Foundation

@Observable
class RelevanceManager {
    var currentRelevance: Double = 0.5
    private let relevanceContext = RKRelevanceContext()

    // 관련성 업데이트
    func updateRelevance(score: Double, reason: String) async {
        currentRelevance = score

        // 시스템에 관련성 신호 전달
        await relevanceContext.updateRelevance(
            score: score,
            metadata: [
                "reason": reason,
                "timestamp": Date().timeIntervalSince1970
            ]
        )
    }

    // 컨텍스트 기반 관련성 계산
    func calculateContextualRelevance(
        location: String?,
        timeOfDay: String,
        userActivity: String
    ) -> Double {
        var score = 0.0

        // 위치 기반 점수
        if location == "gym" {
            score += 0.3
        }

        // 시간 기반 점수
        if timeOfDay == "morning" {
            score += 0.2
        }

        // 활동 기반 점수
        if userActivity == "workout" {
            score += 0.5
        }

        return min(score, 1.0)
    }
}

🔔 2. Live Activity 우선순위

Dynamically adjust Live Activity priority.

LiveActivityRelevance.swift — Live Activity Priority

import ActivityKit
import RelevanceKit

struct DeliveryAttributes: ActivityAttributes {
    public struct ContentState: Codable, Hashable {
        var status: String
        var estimatedTime: Date
        var relevanceScore: Double // 🆕 관련성 점수
    }

    var orderId: String
}

@Observable
class LiveActivityRelevanceManager {
    private var activity: Activity<DeliveryAttributes>?

    // Live Activity 시작 (관련성 포함)
    func startActivity(orderId: String) async throws {
        let attributes = DeliveryAttributes(orderId: orderId)
        let initialState = DeliveryAttributes.ContentState(
            status: "준비 중",
            estimatedTime: Date().addingTimeInterval(1800),
            relevanceScore: 0.5
        )

        activity = try Activity.request(
            attributes: attributes,
            content: .init(state: initialState, staleDate: nil),
            pushType: nil
        )
    }

    // 배달 임박 시 우선순위 증가
    func updateForIncomingDelivery() async {
        guard let activity else { return }

        let updatedState = DeliveryAttributes.ContentState(
            status: "배달 중 - 5분 남음",
            estimatedTime: Date().addingTimeInterval(300),
            relevanceScore: 0.95 // 🆕 높은 우선순위
        )

        await activity.update(using: updatedState)
    }

    // 배달 완료 시 우선순위 감소
    func updateForCompletion() async {
        guard let activity else { return }

        let finalState = DeliveryAttributes.ContentState(
            status: "배달 완료",
            estimatedTime: Date(),
            relevanceScore: 0.1 // 🆕 낮은 우선순위
        )

        await activity.update(using: finalState)

        // 5초 후 종료
        try? await Task.sleep(for: .seconds(5))
        await activity.end(nil, dismissalPolicy: .immediate)
    }
}

🔍 3. Spotlight 통합

Adjust context-based ranking in Spotlight search results.

SpotlightRelevance.swift — Spotlight Integration

import CoreSpotlight
import RelevanceKit

@Observable
class SpotlightRelevanceManager {
    // 컨텍스트 기반 검색 항목 색인
    func indexWithRelevance(
        title: String,
        description: String,
        contextScore: Double
    ) async {
        let attributeSet = CSSearchableItemAttributeSet(
            contentType: .init(rawValue: "public.content")
        )

        attributeSet.title = title
        attributeSet.contentDescription = description

        // 🆕 관련성 점수 설정
        attributeSet.rankingHint = contextScore

        // 컨텍스트 메타데이터
        attributeSet.keywords = [
            "relevant",
            "priority-\(Int(contextScore * 10))"
        ]

        let item = CSSearchableItem(
            uniqueIdentifier: UUID().uuidString,
            domainIdentifier: "com.app.relevance",
            attributeSet: attributeSet
        )

        try? await CSSearchableIndex.default().indexSearchableItems([item])
    }

    // 운동 시간에 피트니스 콘텐츠 우선순위 증가
    func indexWorkoutContent() async {
        let currentHour = Calendar.current.component(.hour, from: Date())
        let isWorkoutTime = (6...9).contains(currentHour) || (17...20).contains(currentHour)

        await indexWithRelevance(
            title: "오늘의 운동 루틴",
            description: "맞춤형 운동 계획",
            contextScore: isWorkoutTime ? 0.9 : 0.3
        )
    }

    // 위치 기반 관련성
    func indexLocationBasedContent(nearGym: Bool) async {
        await indexWithRelevance(
            title: "체육관 회원권",
            description: "회원권 정보 확인",
            contextScore: nearGym ? 0.95 : 0.2
        )
    }
}

🧠 4. 사용자 의도 예측

Learn user patterns to optimize when to suggest the app.

IntentPrediction.swift — Intent Prediction

import RelevanceKit
import CoreLocation

@Observable
class IntentPredictionManager {
    private var userPatterns: [String: [Date]] = [:]
    private let relevanceContext = RKRelevanceContext()

    // 사용자 행동 패턴 기록
    func recordActivity(_ activity: String) {
        if userPatterns[activity] == nil {
            userPatterns[activity] = []
        }
        userPatterns[activity]?.append(Date())
    }

    // 패턴 기반 관련성 예측
    func predictRelevance(for activity: String) -> Double {
        guard let history = userPatterns[activity] else {
            return 0.1
        }

        let now = Date()
        let calendar = Calendar.current
        let currentHour = calendar.component(.hour, from: now)

        // 같은 시간대 활동 빈도 계산
        let sameHourActivities = history.filter {
            calendar.component(.hour, from: $0) == currentHour
        }

        let frequency = Double(sameHourActivities.count) / Double(history.count)
        return min(frequency * 2.0, 1.0)
    }

    // 시스템에 예측 전달
    func updatePredictedRelevance(for activity: String) async {
        let score = predictRelevance(for: activity)

        await relevanceContext.updateRelevance(
            score: score,
            metadata: [
                "activity": activity,
                "prediction_confidence": score,
                "timestamp": Date().timeIntervalSince1970
            ]
        )
    }
}

// 실사용 예제
struct WorkoutPredictionView: View {
    @State private var predictor = IntentPredictionManager()
    @State private var relevanceScore = 0.0

    var body: some View {
        VStack {
            Text("운동 관련성: \(Int(relevanceScore * 100))%")
                .font(.title)

            Button("운동 시작") {
                predictor.recordActivity("workout")
                Task {
                    await predictor.updatePredictedRelevance(for: "workout")
                }
            }
        }
        .task {
            relevanceScore = predictor.predictRelevance(for: "workout")
        }
    }
}

📍 5. 위치 기반 관련성

위치 컨텍스트를 활용한 관련성 관리.

LocationRelevance.swift — Location-Based Relevance

import RelevanceKit
import CoreLocation

@Observable
class LocationRelevanceManager: NSObject, CLLocationManagerDelegate {
    private let locationManager = CLLocationManager()
    private let relevanceContext = RKRelevanceContext()
    var currentRelevance = 0.0

    // 관심 위치 정의
    private let gymLocation = CLLocationCoordinate2D(
        latitude: 37.5665,
        longitude: 126.9780
    )

    override init() {
        super.init()
        locationManager.delegate = self
        locationManager.desiredAccuracy = kCLLocationAccuracyHundredMeters
    }

    // 위치 모니터링 시작
    func startMonitoring() {
        locationManager.requestWhenInUseAuthorization()
        locationManager.startUpdatingLocation()
    }

    // 위치 업데이트 처리
    func locationManager(
        _ manager: CLLocationManager,
        didUpdateLocations locations: [CLLocation]
    ) {
        guard let location = locations.last else { return }

        // 체육관과의 거리 계산
        let gymCLLocation = CLLocation(
            latitude: gymLocation.latitude,
            longitude: gymLocation.longitude
        )
        let distance = location.distance(from: gymCLLocation)

        // 거리 기반 관련성 계산
        let relevance: Double
        if distance < 100 {
            relevance = 1.0 // 매우 가까움
        } else if distance < 500 {
            relevance = 0.7 // 가까움
        } else if distance < 1000 {
            relevance = 0.4 // 중간
        } else {
            relevance = 0.1 // 멀음
        }

        currentRelevance = relevance

        // 시스템에 전달
        Task {
            await relevanceContext.updateRelevance(
                score: relevance,
                metadata: [
                    "distance": distance,
                    "location": "gym"
                ]
            )
        }
    }
}

📱 SwiftUI Integration

RelevanceApp.swift — Complete Example

import SwiftUI
import RelevanceKit

struct RelevanceApp: View {
    @State private var relevanceManager = RelevanceManager()
    @State private var liveActivityManager = LiveActivityRelevanceManager()
    @State private var locationManager = LocationRelevanceManager()

    var body: some View {
        NavigationStack {
            List {
                Section("현재 관련성") {
                    HStack {
                        Text("시스템 관련성")
                        Spacer()
                        Text("\(Int(relevanceManager.currentRelevance * 100))%")
                            .foregroundStyle(.secondary)
                    }

                    HStack {
                        Text("위치 기반")
                        Spacer()
                        Text("\(Int(locationManager.currentRelevance * 100))%")
                            .foregroundStyle(.secondary)
                    }
                }

                Section("액션") {
                    Button("운동 시작") {
                        Task {
                            await relevanceManager.updateRelevance(
                                score: 0.9,
                                reason: "workout_started"
                            )
                        }
                    }

                    Button("배달 시작") {
                        Task {
                            try? await liveActivityManager.startActivity(
                                orderId: "ORDER123"
                            )
                        }
                    }

                    Button("위치 추적 시작") {
                        locationManager.startMonitoring()
                    }
                }
            }
            .navigationTitle("RelevanceKit")
        }
    }
}

💡 HIG Guidelines

Privacy: 위치 등 민감한 데이터 사용 시 명확한 이유 설명
배터리: 백그라운드 업데이트 최소화, 효율적인 관련성 계산
정확성: 관련성 점수는 실제 사용자 컨텍스트와 일치해야 함
투명성: 왜 앱이 제안되는지 사용자가 이해할 수 있어야 함
권한: In Info.plist, 위치 권한 설명 추가

🎯 Practical Applications

Fitness Apps: 체육관 근처에서 운동 루틴 제안
배달 앱: 배달 임박 시 Live Activity 우선 표시
교통 앱: 출퇴근 시간에 경로 제안 우선순위 증가
Music Apps: 운동 시간에 워크아웃 플레이리스트 제안
쇼핑 앱: 매장 근처에서 쿠폰 및 할인 정보 강조

📚 Learn More

⚡️ Performance Tips: Don't update relevance scores too frequently. Only update on meaningful context changes to optimize battery and performance.

📎 Apple Official Resources

📘 Documentation 🎬 WWDC Sessions