App Intents en iOS 27: Siri, App Schemas y el índice semántico

En iOS 27, Siri puede encontrar contenido dentro de las apps, actuar sobre él y entender lo que hay en pantalla. Nada de eso ocurre si tu app no se describe de una forma que Siri pueda leer. Esa descripción es App Intents: el mismo framework que hay detrás de las acciones de Atajos y Spotlight, ampliado en iOS 27 con App Schemas, el índice semántico y nuevas formas de compartir datos entre apps. Esta guía recorre cada pieza en el orden en que Apple recomienda adoptarlas.

El artículo se basa en las sesiones y la documentación de Apple de la WWDC26, un análisis de Jordan Morgan y publicaciones del desarrollador iOS @sarunw. El equipo de AppleDuo no ha publicado este código. Varias API son nuevas en iOS 27 y Xcode 27, otras se remontan a iOS 18 o iOS 26, y los detalles pueden cambiar entre versiones.

¿Qué son los App Intents en iOS 27?

Como resume @sarunw, un App Intent es una acción que tu app puede hacer. Una vez que lo defines, está disponible en todo el sistema: Atajos, Spotlight y widgets. En la sesión de la WWDC26 Build intelligent Siri experiences with App Schemas, Apple describe App Intents como la base para integrarse con Siri y Apple Intelligence.

Un intent básico tiene un título y un método perform(). Esta estructura existe desde iOS 16:

struct OpenInboxIntent: AppIntent {
    static var title: LocalizedStringResource = "Open Inbox"
    static var openAppWhenRun = true

    func perform() async throws -> some IntentResult {
        // Navegar a la bandeja de entrada
        return .result()
    }
}

Lo nuevo en iOS 27 es hasta dónde puede llevar Siri estas acciones. El planteamiento de Apple es que Siri se encarga de entender el lenguaje mientras tu app se centra en la acción. Para que ese reparto funcione, Siri necesita saber qué significa cada acción y cada contenido.

¿Cómo hacen los App Schemas y los dominios que Siri entienda tu app?

@sarunw lo resume en tres piezas. Los App Intents describen la acción. Los App Schemas le dan un significado que Siri entiende. Los dominios agrupan los schemas relacionados.

Apple describe los schemas como una especialización de App Intents: siguen siendo App Intents, pero con una forma que permite a Siri saber cómo procesarlos. Aplicas uno con una macro delante de la declaración: AppIntent(schema:), AppEntity(schema:) o AppEnum(schema:). La página de Apple App schema domains enumera tres grupos:

Los dominios de schemas aparecieron por primera vez con iOS 18. En la sesión de la WWDC26, la app de mensajería de ejemplo de Apple adopta el schema sendMessage del dominio Messages. Xcode 27 también comprueba los schemas relacionados al compilar: si adoptas sendMessage sin draftMessage, obtienes un error de compilación con un Fix-It que genera el esqueleto.

Si tu contenido no encaja en ningún schema, puedes seguir publicando App Intents sin schema. El análisis de iOS 27 de Jordan Morgan señala que todavía no está claro cuánto del nuevo comportamiento de Siri llega a las apps fuera de un schema.

¿Cómo hago que Siri encuentre el contenido de mi app?

Las acciones son la mitad de la historia; Siri también tiene que encontrar aquello de lo que habla una persona. @sarunw enumera cuatro pasos, que coinciden con el orden de la sesión de Apple:

Los pasos 2 y 3 se juntan en una sola declaración. Esta es la entidad de mensaje de la sesión de Apple de la WWDC26:

@AppEntity(schema: .messages.message)
struct MessageEntity: IndexedEntity {

    // El contenido de texto del mensaje
    @Property(indexingKey: \.textContent)
    var body: AttributedString?
}

@sarunw lo divide en tres decisiones: el tipo de contenido, que pertenece al índice y qué campo indexar. Apple dice que adoptar IndexedEntity es la forma principal de impulsar la resolución de entidades, porque las entidades indexadas entran en el índice semántico, lo que permite a Siri buscar por significado y no por palabras exactas.

La parte de indexingKey es una traducción. Como explica @sarunw, tu propiedad se llama body, pero Spotlight guarda su valor como textContent. Sin esa correspondencia, el sistema no tiene forma de saber cuál de tus campos contiene el texto del mensaje.

¿Qué partes son nuevas?

IndexedEntity llegó en iOS 18, y @Property(indexingKey:) en iOS 26, según la página de Apple App Intents updates. Lo que añade iOS 27 es que Siri use ese índice para la búsqueda semántica, además de nuevos tipos como IndexedEntityQuery. En la sesión code-along, Apple también mantiene el índice actualizado llamando a indexAppEntities en un CSSearchableIndex después de crear o actualizar contenido, y a deleteAppEntities después de eliminarlo.

¿Qué pasa si mi contenido no se puede indexar?

Hay contenido que no se puede indexar por adelantado: está en un servidor, cambia constantemente o es demasiado grande. Para esos casos, Apple recomienda EntityStringQuery. Siri pasa a tu app las palabras de la persona y tu app devuelve las entidades que coinciden. Este es el ejemplo de Apple:

struct ContactQuery: EntityStringQuery {
    func entities(matching string: String) async throws -> [ContactEntity] {
        let predicate = #Predicate<Person> { person in
            person.name.localizedStandardContains(string)
        }
        let descriptor = FetchDescriptor<Person>(predicate: predicate)
        let matches = try modelContext.fetch(descriptor)
        return matches.map(\.entity)
    }
}

Una consulta de texto busca coincidencias de texto, no de significado, y ejecuta tu código en cada solicitud. Prefiere IndexedEntity siempre que puedas y reserva las consultas de texto para el resto.

¿Cómo sabe Siri qué hay en la pantalla de mi app?

@sarunw señala que en iOS 27 Siri puede leer lo que hay en tu pantalla, pero tienes que indicarle qué App Entity representa una vista. El artículo de Apple Providing contextual cues to Apple Intelligence and Siri describe dos vías, y la sesión de la WWDC26 da la regla: usa una user activity cuando haya un elemento principal en pantalla, y anotaciones de vista cuando haya varios elementos relevantes visibles.

En una lista, aplica appEntityIdentifier(_:) a cada fila:

List {
    ForEach(messages) { message in
        MessageRow(message: message)
            .appEntityIdentifier(
                EntityIdentifier(
                    for: MessageEntity.self,
                    identifier: message.id
                )
            )
    }
}

Cuando un solo elemento ocupa la pantalla, anótalo con un NSUserActivity y define la propiedad appEntityIdentifier de la actividad. En SwiftUI, el modificador userActivity te da la actividad para configurarla. El code-along de Apple aplica .userActivity con un EntityIdentifier a su vista de detalle de evento, pero no muestra el código, así que esto es un boceto nuestro:

EventDetailView(event: event)
    .userActivity("com.example.viewEvent") { activity in
        activity.title = event.title
        activity.appEntityIdentifier = EntityIdentifier(
            for: EventEntity.self,
            identifier: event.id
        )
    }

Ambas API existían antes de iOS 27: la documentación de Apple sitúa el modificador de SwiftUI desde iOS 18.4 y la propiedad de NSUserActivity desde iOS 18.2. Apple también advierte de no adjuntar entidades no relacionadas: una anotación debe reflejar los datos que muestra la vista. Para contenido dibujado a medida sin una vista por entidad, usa appEntityUIElements(_:).

¿Cómo comparto datos con otras apps a través de Siri?

Transferable es el protocolo que hay detrás de ShareLink y de arrastrar y soltar. En iOS 27, Siri también lo usa. Devuelves una IntentValueRepresentation, y una sola conformidad cubre ambas direcciones.

El motivo es que los archivos y los datos sin más tienen límites. El ejemplo de Apple: Mapas no puede usar una foto de un monumento para obtener indicaciones hasta él. Para personas, lugares y nombres, IntentValueRepresentation (nuevo en iOS 27) entrega un tipo del sistema que otras apps pueden usar directamente, como IntentPerson, PlaceDescriptor o PersonNameComponents. La exportación, según la sesión de Apple:

extension ContactEntity: Transferable {

    static var transferRepresentation: some TransferRepresentation {
        IntentValueRepresentation(
            exporting: \.person
        )
    }
}

Los valores entrantes siguen uno de dos caminos. La regla de Apple es resolver el contenido que ya existe e importar el que no. Tal como @sarunw describe IntentValueQuery, el sistema te pasa el valor entrante, y tú buscas en tus propios datos y devuelves lo que coincide:

struct ContactEntityQuery: IntentValueQuery {

    func values(for input: [IntentPerson]) async throws -> [ContactEntity] {
        let names = input.map(\.displayName)
        let descriptor = FetchDescriptor<Contact>()
        let contacts = try model.mainContext.fetch(descriptor)
        let matches = contacts.filter { contact in
            names.contains(where: { name in
                contact.name.localizedStandardContains(name)
            })
        }
        return matches.map(\.entity)
    }
}

Cuando nada coincide, crea el contenido con IntentValueRepresentation(exporting:importing:), que recibe un closure que construye una entidad nueva a partir del IntentPerson entrante. IntentValueQuery en sí data de iOS 26, donde se introdujo para visual intelligence.

Una advertencia: un desarrollador informó en los foros de que, en una beta de iOS 27, los closures de exportación nunca se ejecutaban y Siri pedía una aclaración en su lugar. El hilo no tiene una respuesta confirmada, así que prueba con la versión final.

¿Qué cambia para Siri en iPhone Duo?

Nada en las API. No encontramos ninguna API de Siri ni de App Intents específica para iPhone Duo; el código anterior es el mismo en cualquier iPhone con iOS 27.

Lo que cambia es el lienzo. Cuando iPhone Duo está abierto, la pantalla interior informa size classes regular en ambas direcciones, así que muchas apps muestran a la vez una barra lateral, una lista y una vista de detalle. Nuestra guía sobre las size classes de iPhone Duo cubre ese cambio de diseño. Más contenido en pantalla significa más cosas que Siri tiene que resolver con «este» o «el tercer mensaje», y más lugares donde una anotación que falta deja a Siri adivinando.

Algunas comprobaciones prácticas:

• Anota cada columna. Si una disposición dividida muestra una lista junto a una vista de detalle, da a las filas de la lista appEntityIdentifier y a la vista de detalle una user activity.
• Mantén las anotaciones ligadas a los datos visibles. A medida que el dispositivo se pliega y tu diseño cambia, las anotaciones deben seguir a las vistas que realmente están en pantalla.
• Valida por etapas. Apple sugiere el framework AppIntentsTesting para la lógica, luego Atajos para la forma del intent, Spotlight para la indexación y Siri para el flujo completo.

Para el resto del trabajo de adaptar una app, usa nuestra checklist para preparar tu app para iPhone Duo.

Puntos clave

• Los App Intents describen acciones; los App Schemas, aplicados con @AppIntent(schema:) y @AppEntity(schema:), les dan un significado que Siri entiende; los dominios agrupan los schemas.
• Haz que el contenido se pueda encontrar en cuatro pasos: App Entity, App Schema, IndexedEntity para el índice semántico y EntityStringQuery como alternativa.
• @Property(indexingKey:) asigna tu campo al de Spotlight, por ejemplo body a textContent.
• Para que Siri sepa qué hay en pantalla, usa appEntityIdentifier en las filas de las listas y NSUserActivity cuando un solo elemento ocupa la pantalla.
• Adopta Transferable con IntentValueRepresentation (iOS 27) para compartir datos, e IntentValueQuery para buscar coincidencias con los valores entrantes.
• iPhone Duo usa las mismas API; su lienzo más grande simplemente pone más contenido en pantalla que anotar.

A continuación, planifica tus capturas del App Store para iPhone Duo o explora apps y juegos ya creados para el pliegue.