Explora nuevos avances en App Intents

4:08 - Returning a Snippet Intent

import AppIntents
import SwiftUI

struct ClosestLandmarkIntent: AppIntent {
    static let title: LocalizedStringResource = "Find Closest Landmark"

    @Dependency var modelData: ModelData

    func perform() async throws -> some ReturnsValue<LandmarkEntity> & ShowsSnippetIntent & ProvidesDialog {
        let landmark = await self.findClosestLandmark()

        return .result(
            value: landmark,
            dialog: IntentDialog(
                full: "The closest landmark is \(landmark.name).",
                supporting: "\(landmark.name) is located in \(landmark.continent)."
            ),
            snippetIntent: LandmarkSnippetIntent(landmark: landmark)
        )
    }
}

4:31 - Building a SnippetIntent

struct LandmarkSnippetIntent: SnippetIntent {
    static let title: LocalizedStringResource = "Landmark Snippet"

    @Parameter var landmark: LandmarkEntity
    @Dependency var modelData: ModelData

    func perform() async throws -> some IntentResult & ShowsSnippetView {
        let isFavorite = await modelData.isFavorite(landmark)

        return .result(
            view: LandmarkView(landmark: landmark, isFavorite: isFavorite)
        )
    }
}

5:45 - Associate intents with buttons

struct LandmarkView: View {
    let landmark: LandmarkEntity
    let isFavorite: Bool

    var body: some View {
        // ...
        Button(intent: UpdateFavoritesIntent(landmark: landmark, isFavorite: !isFavorite)) { /* ... */ }

        Button(intent: FindTicketsIntent(landmark: landmark)) { /* ... */ }
        // ...
    }
}

6:53 - Request confirmation snippet

struct FindTicketsIntent: AppIntent {

    func perform() async throws -> some IntentResult & ShowsSnippetIntent {
        let searchRequest = await searchEngine.createRequest(landmarkEntity: landmark)

        // Present a snippet that allows people to change
        // the number of tickets.
        try await requestConfirmation(
            actionName: .search,
            snippetIntent: TicketRequestSnippetIntent(searchRequest: searchRequest)
        )

        // Resume searching...
    }
}

7:24 - Using Entities as parameters

struct TicketRequestSnippetIntent: SnippetIntent {
    static let title: LocalizedStringResource = "Ticket Request Snippet"

    @Parameter var searchRequest: SearchRequestEntity

    func perform() async throws -> some IntentResult & ShowsSnippetView {
        let view = TicketRequestView(searchRequest: searchRequest)

        return .result(view: view)
    }
}

8:01 - Updating a snippet

func performRequest(request: SearchRequestEntity) async throws {
    // Set to pending status...
   
    TicketResultSnippetIntent.reload()

    // Kick off search...

    TicketResultSnippetIntent.reload()
}

9:24 - Responding to Image Search

struct LandmarkIntentValueQuery: IntentValueQuery {

    @Dependency var modelData: ModelData

    func values(for input: SemanticContentDescriptor) async throws -> [LandmarkEntity] {
        guard let pixelBuffer: CVReadOnlyPixelBuffer = input.pixelBuffer else {
            return []
        }

        let landmarks = try await modelData.searchLandmarks(matching: pixelBuffer)

        return landmarks
    }
}

9:51 - Support opening an entity

struct OpenLandmarkIntent: OpenIntent {
    static var title: LocalizedStringResource = "Open Landmark"

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

    func perform() async throws -> some IntentResult {
        /// ...
    }
}

10:53 - Show search results in app

@AppIntent(schema: .visualIntelligence.semanticContentSearch)
struct ShowSearchResultsIntent {
    var semanticContent: SemanticContentDescriptor

    @Dependency var navigator: Navigator

    func perform() async throws -> some IntentResult {
        await navigator.showImageSearch(semanticContent.pixelBuffer)

        return .result()
    }

    // ...
}

11:40 - Returning multiple entity types

@UnionValue
enum VisualSearchResult {
    case landmark(LandmarkEntity)
    case collection(CollectionEntity)
}a

struct LandmarkIntentValueQuery: IntentValueQuery {
    func values(for input: SemanticContentDescriptor) async throws -> [VisualSearchResult] {
        // ...
    }
}

struct OpenLandmarkIntent: OpenIntent { /* ... */ }
struct OpenCollectionIntent: OpenIntent { /* ... */ }

13:00 - Associating a view with an AppEntity

struct LandmarkDetailView: View {

    let landmark: LandmarkEntity

    var body: some View {
        Group{ /* ... */ }
        .userActivity("com.landmarks.ViewingLandmark") { activity in
            activity.title = "Viewing \(landmark.name)"
            activity.appEntityIdentifier = EntityIdentifier(for: landmark)
        }
    }
}

13:21 - Converting AppEntity to PDF

import CoreTransferable
import PDFKit

extension LandmarkEntity: Transferable {
    static var transferRepresentation: some TransferRepresentation {
        DataRepresentation(exportedContentType: .pdf) {landmark in
            // Create PDF data...
            return data
        }
    }
}

14:05 - Associating properties with Spotlight keys

struct LandmarkEntity: IndexedEntity {

    // ...

    @Property(indexingKey: \.displayName)
    var name: String

    @Property(customIndexingKey: /* ... */)
    var continent: String

    // ...
}

15:49 - Making intents undoable

struct DeleteCollectionIntent: UndoableIntent {
    // ...

    func perform() async throws -> some IntentResult {

        // Confirm deletion...

        await undoManager?.registerUndo(withTarget: modelData) {modelData in
            // Restore collection...
        }
        await undoManager?.setActionName("Delete \(collection.name)")

       // Delete collection...
    }
}

16:52 - Multiple choice

struct DeleteCollectionIntent: UndoableIntent {
    func perform() async throws -> some IntentResult & ReturnsValue<CollectionEntity?> {
        let archive = Option(title: "Archive", style: .default)
        let delete = Option(title: "Delete", style: .destructive)

        let resultChoice = try await requestChoice(
            between: [.cancel, archive, delete],
            dialog: "Do you want to archive or delete \(collection.name)?",
            view: collectionSnippetView(collection)
        )

        switch resultChoice {
        case archive: // Archive collection...
        case delete: // Delete collection...
        default: // Do nothing...
        }
    }
    // ...
}

18:47 - Supported modes

struct GetCrowdStatusIntent: AppIntent {

    static let supportedModes: IntentModes = [.background, .foreground]

    func perform() async throws -> some ReturnsValue<Int> & ProvidesDialog {
        if systemContext.currentMode == .foreground {
            await navigator.navigateToCrowdStatus(landmark)
        }

        // Retrieve status and return dialog...
    }
}

19:30 - Supported modes

struct GetCrowdStatusIntent: AppIntent {
    static let supportedModes: IntentModes = [.background, .foreground(.dynamic)]

    func perform() async throws -> some ReturnsValue<Int> & ProvidesDialog {
        guard await modelData.isOpen(landmark) else { /* Exit early... */ }

        if systemContext.currentMode.canContinueInForeground {
            do {
                try await continueInForeground(alwaysConfirm: false)
                await navigator.navigateToCrowdStatus(landmark)
            } catch {
                // Open app denied.
            }
        }

        // Retrieve status and return dialog...
    }
}

21:30 - View Control

extension OpenLandmarkIntent: TargetContentProvidingIntent {}

struct LandmarksNavigationStack: View {

    @State var path: [Landmark] = []

    var body: some View {
        NavigationStack(path: $path) { /* ... */ }
        .onAppIntentExecution(OpenLandmarkIntent.self) { intent in
            self.path.append(intent.landmark)
        }
    }
}

23:13 - Scene activation condition

@main
struct AppIntentsTravelTrackerApp: App {
    var body: some Scene {
        WindowGroup { /* ... */ }

        WindowGroup { /* ... */ }
        .handlesExternalEvents(matching: [
            OpenLandmarkIntent.persistentIdentifier
        ])
    }
}

23:33 - View activation condition

struct LandmarksNavigationStack: View {
    var body: some View {
        NavigationStack(path: $path) { /* ... */ }
        .handlesExternalEvents(
            preferring: [],
            allowing: !isEditing ? [OpenLandmarkIntent.persistentIdentifier] : []
        )
    }
}

24:23 - Computed property

struct SettingsEntity: UniqueAppEntity {

    @ComputedProperty
    var defaultPlace: PlaceDescriptor {
        UserDefaults.standard.defaultPlace
    }

    init() {
    }
}

24:48 - Deferred property

struct LandmarkEntity: IndexedEntity {
    // ...

    @DeferredProperty
    var crowdStatus: Int {
        get async throws {
            await modelData.getCrowdStatus(self)
        }
    }

    // ...
}

25:50 - AppIntentsPackage

// Framework or dynamic library
public struct LandmarksKitPackage: AppIntentsPackage { }

// App target
struct LandmarksPackage: AppIntentsPackage {
    static var includedPackages: [any AppIntentsPackage.Type] {
        [LandmarksKitPackage.self]
    }
}