App Intents for Apple ecosystem

What is App Intents?

App Intents is not just a framework - it's an ecosystem that enables your app's functionality to expand OUT across the Apple system. It extends your app's discoverability, visibility, and capabilities across:

• Spotlight (new: Mac-wide action invocation)
• Siri voice commands
• Control Center quick controls
• Widget configurability and interactivity
• Action Button context-aware experiences
• Apple Pencil Pro custom actions

Key Point: Provides rich experiences even when users aren't in your app.

Core Architecture: The Grammar System

The Grammar Analogy

• Intents = Verbs (actions: open note, start workout, add grocery item)
• App Enums/Entities = Nouns (data: navigation sections, user content)
• App Shortcuts = Sentences (complete phrases: intent + parameters)

Build-Time Processing Architecture

• Source of truth: Your Swift source code
• Build-time generation: Framework reads code to create App Intents representation
• System understanding: Stored representation lets system understand capabilities without running app
• Critical constraint: Titles and representations must be constant values (no functions/computed properties)

Core Components Deep Dive

1. Basic Intent Structure

Minimum requirements:

• title: Unique LocalizedStringResource (becomes unique identifier)
• perform() method: Contains logic, returns IntentResult
• Use @MainActor for navigation/UI operations
• supportedModes: .foreground to open app before execution

IntentResult capabilities:

• Dialog for Siri to speak
• View snippet to display
• Returned values for multi-step shortcuts

2. Parameters & App Enums

App Enum requirements:

• String raw value (must be instantiable from string)
• TypeDisplayRepresentation (describes type as whole)
• CaseDisplayRepresentation (describes each case)
• Compile-time constant values only

Parameter features:

• @Parameter attribute makes variables into intent inputs
• Can be required or optional
• Runtime ensures required parameters have values before perform()
• Custom titles and dialogs improve UX

Parameter Summary:

• Fluent, sentence-like representation
• Human-readable action description
• New 2024: Complete Parameter Summary enables Mac Spotlight execution
• Interpolate parameters into natural language strings

3. App Entities (Dynamic Data)

Entity requirements:

• Persistent identifier (critical - must be lookup-friendly)
• Properties with @Property or new @ComputedProperty
• DisplayRepresentation for instances
• Associated EntityQuery for system reasoning

New @ComputedProperty (2024):

• Defer to data model instead of copying values
• Getters eliminate value synchronization

Query system answers key questions:

• "What entities are there?" (collection of matching entities)
• "What entity has this ID?" (required - enables unique references)
• "Do you have entities matching this string?" (EntityStringQuery)
• "What entities match these predicates?" (EntityPropertyQuery)

4. App Shortcuts (Auto-Discovery)

Automatic system exposure:

• Featured prominently in Spotlight
• Siri trigger phrases (must include applicationName placeholder)
• Action Button/Apple Pencil configuration
• Shortcuts app without user setup
• Limitation: Only one parameter per phrase

App Shortcuts Provider:

• Single provider per app containing all shortcuts
• Takes intent instance + phrases + title + image
• Parameterized phrases create shortcuts for each value

Advanced Integration Features

Transferable Protocol Integration

• Declarative data representations for cross-app sharing
• Image/data representations usable in other apps' actions
• Enables rich content display in Shortcuts
• Transfer representations for different data types

Spotlight Deep Integration

IndexedEntity protocol:

• Core Spotlight attribute set inclusion
• New 2024: Direct property annotation with indexing keys
• Framework handles searchable item creation
• Entities appear in Spotlight search results

OpenIntent for navigation:

• Automatic app opening before execution
• Required target parameter
• New: TargetContentProvidingIntent for SwiftUI navigation
• onAppIntentExecution modifier eliminates perform() method need

Query System Deep Dive

EntityQuery (base):

• entities(for:) method for ID-based lookup
• @Dependency injection for database/service access
• Register dependencies with AppDependencyManager early in lifecycle

Specialized query types:

• EnumerableEntityQuery: Return all entities (memory permitting)
• EntityStringQuery: Text-based entity searching
• EntityPropertyQuery: Filtered/sorted results with predicates
• suggestedEntities: Improve picker UX with favorites/recent items

Multi-Target Architecture

Code Sharing Strategy

AppIntentsPackage registration:

• Required when sharing types across targets
• Register each target individually
• Include package dependencies explicitly
• Ensures proper type indexing and validation

New 2024: Swift Package Support

• Add App Intents to Swift packages and static libraries
• Enhanced code sharing flexibility
• Use when referencing non-static library code

Dependency Management

• @Dependency attribute for intents and queries
• Early registration in app lifecycle
• Access to databases, services, shared resources

Key 2024 Updates

1. Mac Spotlight Integration: Direct action invocation system-wide
2. @ComputedProperty: Eliminate value copying between models
3. Swift Package Support: Enhanced multi-target architecture
4. Direct Property Indexing: Spotlight keys on individual properties
5. TargetContentProvidingIntent: Navigation without perform() methods
6. Enhanced Parameter Summaries: Enable Mac Spotlight execution

Interview-Critical Points

Performance & Architecture

• Default behavior: Intents don't foreground app
• Context provision: Always include dialog and view snippets
• Build-time constraints: Constant values for system processing
• Entity ID persistence: Critical for system references

Best Practices

1. Start small: One App Shortcut for key feature
2. Natural language: Parameter Summaries for readability
3. User experience: Implement suggestedEntities
4. Cross-app integration: Use Transferable for data sharing
5. System integration: IndexedEntity for Spotlight discovery

Common Pitfalls

• Non-constant build-time values (titles, representations)
• Missing AppIntentsPackage registration in multi-target apps
• Inadequate EntityQuery implementation
• Forgetting @MainActor for UI operations
• Poor entity ID persistence strategy

Architecture Benefits

• No configuration files: Pure Swift implementation
• Compile-time validation: Build-time error detection
• System-level integration: Works without app execution
• Cross-platform availability: All Apple platforms
• Future extensibility: Ready for new system features

Integration Points Summary

• Spotlight: Search, direct actions, Mac system-wide access
• Siri: Natural language voice commands
• Control Center: Quick access controls
• Widgets: Interactive experiences
• Hardware: Action Button, Apple Pencil Pro integration
• Shortcuts: Automation and multi-step workflows

Getting Started Strategy

1. Identify your app's most important action
2. Create basic intent with title and perform method
3. Add App Shortcut for immediate discoverability
4. Implement Parameter Summary for natural language
5. Expand with entities and advanced queries
6. Integrate Spotlight indexing for discovery
7. Add Transferable support for cross-app functionality