AppIntent: vad är det, modell för Siri-intents och Swift

Vad är AppIntent och vad används det till?

AppIntent — Apple-ramverk för deklarativ beskrivning av kommandon som din app kan utföra på begäran av Siri, Shortcuts, Spotlight, Control Center och Action Button. I grunden ligger protokollet AppIntent, där utvecklaren beskriver intentets namn, dess parametrar och metoden perform() — den logik som utförs. Ramverket genererar automatiskt användargränssnittet för att konfigurera parametrar i Shortcuts-appen och röstfraser för Siri.

Innan AppIntent kom använde utvecklare Intents framework — ett system baserat på Intent Definition File, som genererade Objective-C-kod och krävde konfiguration av en separat Intents Extension. Denna process var krånglig: även ett enkelt intent krävde upp till 5 konfigurationsfiler. AppIntent eliminerar denna komplexitet — intentet beskrivs i en Swift-fil och systemet genererar automatiskt allt som behövs för integration med Siri och Shortcuts.

Enligt WWDC 2024 Session “Dive deeper into App Intents”, ser Apple AppIntent som den centrala mekanismen för att utöka appars funktionalitet bortom traditionellt UI. Vid tiden för iOS 18-släppet använder över 70% av apparna i top 100 på App Store redan AppIntent för integration med Shortcuts och Siri, och den genomsnittliga iOS 18-användaren startar 4–6 intents per dag via röstkommandon eller widgetar.

Var används AppIntent

• Siri — röstkommandon: “Hey Siri, lägg till uppgift i MyApp”
• Shortcuts — automatisering i appen Genvägar med parameterkonfiguration
• Spotlight — sökning och exekvering av kommandon direkt från sökfältet
• Control Center — knappar för snabbåtgärder på iOS 18+
• Action Button — konfiguration av åtgärd för knappen på iPhone 15 Pro och nyare

AppIntent vs Intents framework: viktiga skillnader

Intents framework (iOS 10–15) krävde skapande av .intentdefinition-fil, generering av ObjC/Swift-klasser via Xcode, konfiguration av Intents Extension och App Intent Configuration. AppIntent (iOS 16+) ersätter helt denna pipeline med ren Swift-kod utan generering, tillägg och extra konfigurationer. Detta gör processen att skapa intents tillgänglig för den genomsnittliga iOS-utvecklaren utan att behöva lära sig SiriKit.

Den största fördelen med AppIntent är dess deklarativa natur. Utvecklaren beskriver vad intentet gör, inte hur det integreras med systemet. Ramverket hanterar själv Siri-dialogscenarier, visning av parametrar i Shortcuts och överföring av kontext mellan intents. I det gamla Intents framework måste varje aspekt av integration kodas manuellt, inklusive INUIHostedView för att visa intentets UI.

Jämförelse av tillvägagångssätt

Huvudprotokoll: AppIntent, AppEntity, AppEnum

AppIntent — det centrala protokollet som definierar intentet. Det innehåller title (namn för Siri), description (beskrivning i Shortcuts), parametrar (via @Parameter) och metoden perform() som returnerar IntentResult. Resultatet kan vara IntentDialog (dialog med Siri), ett värde att returnera till Shortcuts eller ett fel. Varje intent kan också tillhandahålla suggestedInvocationPhrase — en fras för röstandrop.

AppEntity beskriver entiteter som intents arbetar med. Till exempel, om appen hanterar projekt, innehåller AppEntity Project id, displayRepresentation (hur entiteten visas i UI) och defaultQuery (hur entiteter söks). AppEnum — uppräkning för valparametrar som automatiskt genererar UI med ett picker-element i Shortcuts. Istället för att manuellt skapa en parameterlista räcker det att deklarera en enum som följer AppEnum.

Exempel på AppEnum och parameter

enum TaskPriority: String, AppEnum {
    case low, medium, high
    
    static var typeDisplayRepresentation: TypeDisplayRepresentation =
        "Priority"
    
    var displayRepresentation: DisplayRepresentation {
        switch self {
        case .low: "Low"
        case .medium: "Medium"
        case .high: "High"
        }
    }
}

struct CreateTaskIntent: AppIntent {
    static var title: LocalizedStringResource = "Create Task"
    
    @Parameter(title: "Task Name")
    var taskName: String
    
    @Parameter(title: "Priority")
    var priority: TaskPriority
    
    func perform() async throws -> some IntentResult {
        try await TaskManager.shared
            .createTask(name: taskName, priority: priority)
        return .result(dialog: "Task created")
    }
}

Intentparametrar och deras validering

Parametrar för AppIntent deklareras via property wrapper @Parameter, som automatiskt integreras med Shortcuts UI och Siri-röstförfrågningar. Varje parameter har en title (visas i Shortcuts) och kan innehålla beskrivning, standardvärden, begränsningar. AppIntent stöder standardtyper: String, Int, Double, Bool, samt anpassade typer via AppEntity och AppEnum.

Validering av parametrar utförs i metoden perform() innan logiken exekveras. Om parametrar är felaktiga returnerar intentet ett fel via IntentError. För komplex validering kan metoden validate() implementeras, som anropas före perform() och kan ge feedback till användaren via IntentDialog även innan kommandot utförs. Detta är särskilt användbart i Siri-röstscenarier, där det är lättare att fråga användaren igen än att utföra ett felaktigt kommando.

Parametrar med validering

struct SendMessageIntent: AppIntent {
    static var title: LocalizedStringResource = "Send Message"
    
    @Parameter(title: "Recipient")
    var recipient: String
    
    @Parameter(title: "Message")
    var message: String
    
    func validate() throws {
        guard message.count >= 1 else {
            throw IntentError.invalidMessage
        }
    }
    
    func perform() async throws -> some IntentResult {
        try await Messenger.shared
            .send(recipient: recipient, text: message)
        return .result(dialog: "Sent!")
    }
}

Skapa ett intent i Swift: exempel

Ett komplett exempel på ett intent för att söka anteckningar i en app demonstrerar arbete med AppEntity och EntityQuery. Intentet SearchNotesIntent tar emot en söksträng och returnerar en lista med hittade anteckningar. AppEntity Note beskriver anteckningens struktur och EntityQuery implementerar sökningen i lagret. Resultatet returneras via IntentResult med en array av entiteter, som Shortcuts visar för användaren.

struct Note: AppEntity {
    let id: UUID
    let title: String
    let content: String
    
    static var typeDisplayRepresentation: TypeDisplayRepresentation =
        "Note"
    
    var displayRepresentation: DisplayRepresentation {
        DisplayRepresentation(title: "(title)")
    }
}

struct SearchNotesIntent: AppIntent {
    static var title: LocalizedStringResource = "Search Notes"
    
    @Parameter(title: "Query")
    var query: String
    
    func perform() async throws -> some IntentResult {
        let results = await NoteStore.shared
            .search(query)
            .map { $0.toEntity() }
        return .result(value: results)
    }
}

Integration med Shortcuts och Siri

Efter deklaration av AppIntent sker integration med Shortcuts och Siri automatiskt. Shortcuts-appen skannar alla AppIntent från installerade appar och visar dem i listan över tillgängliga åtgärder. Användaren kan lägga till intentet i sitt kommando, konfigurera dess parametrar och kombinera med andra åtgärder. För Siri visas intents som röstkommandon utan ytterligare konfiguration från utvecklaren.

Utvecklaren kan förbättra integrationen genom att lägga till suggestedInvocationPhrase — en rekommenderad fras för röstandrop. Till exempel, för ett intent att lägga till en uppgift: suggestedInvocationPhrase = "Add new task". Siri analyserar denna fras och föreslår den för användaren vid inlärning av röstkommandon. Man kan också ange categories — intentets kategori (create, view, search, edit), som hjälper Shortcuts att gruppera åtgärder efter betydelse.

Kategorier av intents för Shortcuts