Descripción general de AppFunctions

Las AppFunctions permiten que tu app para Android comparta funcionalidades específicas que el sistema y varios asistentes y agentes de IA pueden descubrir e invocar. Si defines estas funciones, permites que tu app proporcione servicios, datos y acciones al SO Android, lo que permite que los usuarios completen tareas a través de agentes de IA y de interacciones a nivel del sistema.

Las AppFunctions son el equivalente móvil de las herramientas dentro del Protocolo de contexto del modelo (MCP). Si bien MCP estandariza tradicionalmente la forma en que los agentes se conectan a las herramientas del servidor, AppFunctions proporciona el mismo mecanismo para las apps para Android. Esto te permite exponer las capacidades de tu app como "herramientas" orquestables que las apps autorizadas (llamantes) pueden descubrir y ejecutar para satisfacer las intenciones del usuario. Las entidades que llaman deben tener el permiso EXECUTE_APP_FUNCTIONS para descubrir y ejecutar AppFunctions, y pueden incluir agentes, apps y asistentes de IA, como Gemini.

Las AppFunctions funcionan con dispositivos que ejecutan Android 16 o versiones posteriores.

Ejemplos de casos de uso

Las AppFunctions proporcionan un mecanismo potente para automatizar tareas y optimizar las interacciones del usuario. Cuando expones las capacidades de tu app, permites que los usuarios alcancen objetivos complejos con lenguaje natural, lo que, a menudo, evita la necesidad de una navegación manual paso a paso con tu IU.

En las siguientes situaciones, se ilustra cómo se pueden usar las AppFunctions para impulsar experiencias en una variedad de categorías de apps:

• Administración de tareas y productividad
  • Solicitud del usuario: "Recuérdame que recoja mi paquete en el trabajo hoy a las 5 p.m.".
  • Acción AppFunction: El llamador identifica la app de administración de tareas pertinente y llama a una función para crear una tarea, y completa automáticamente los campos de título, hora y ubicación según la instrucción del usuario.
• Medios de comunicación y entretenimiento
  • Solicitud del usuario: "Crea una playlist nueva con los mejores álbumes de jazz de este año".
  • Acción AppFunction: El llamador ejecuta una función de creación de playlists dentro de una app de música y pasa contexto, como "los mejores álbumes de jazz de 2026", como la búsqueda para generar y lanzar el contenido de inmediato.
• Flujos de trabajo en varias apps
  • Solicitud del usuario: "Busca la receta de fideos en el correo electrónico de Lisa y agrega los ingredientes a mi lista de compras".
  • Acción AppFunction: Esta solicitud usa funciones de varias apps. Primero, el llamador usa la función de búsqueda de una app de correo electrónico para recuperar el contenido. Luego, extrae los ingredientes pertinentes y llama a la función de una app de lista de compras para completar la lista del usuario.
• Calendario y programación
  • Solicitud del usuario: "Agrega la fiesta de cumpleaños de mamá a mi calendario para el próximo lunes a las 6 p.m.".
  • Acción de AppFunction: La app agentiva aprobada invoca la función "crear evento" de la app de calendario y analiza el contexto pertinente, como "el próximo lunes" y "las 18:00", para crear la entrada sin que el usuario tenga que abrir el calendario de forma manual.

Cómo funcionan las AppFunctions

AppFunctions es una función de la plataforma de Android 16 y una biblioteca de Jetpack complementaria que permite que las apps expongan funciones específicas para que los llamadores, como las apps de agentes, accedan a ellas y las ejecuten en el dispositivo.

En el siguiente diagrama, se ilustra el flujo típico de cómo las apps comparten AppFunctions con un agente y, luego, se ejecutan. Es probable que los agentes consideren tanto las herramientas de MCP remotas del servidor como las AppFunctions locales cuando manejen las solicitudes de los usuarios. El flujo detallado para usar AppFunctions locales es el siguiente:

• Declaración de AppFunction: La app para Android se compila para exponer sus AppFunctions, como "Crear nota" o "Enviar mensaje".
• Generación de esquemas: La biblioteca de AppFunctions de Jetpack genera un archivo de esquema XML que enumera todas las AppFunctions declaradas en la app. El SO de Android usa este archivo para indexar las AppFunctions disponibles.
• Recuperación de metadatos: El agente puede recuperar metadatos de AppFunction consultándolos.
• Selección y ejecución de AppFunction: Según las instrucciones del usuario, el agente seleccionará y ejecutará la AppFunction adecuada con los parámetros correspondientes.

La biblioteca de AppFunctions de Jetpack simplifica la exposición de la funcionalidad de tu app. Con el procesador de anotaciones, los desarrolladores anotan las funciones que desean exponer. Luego, los llamadores pueden descubrir e invocar estas funciones indexadas con AppFunctionManager.

Tu app no necesita verificar si se admite la función AppFunction, ya que esto se controla automáticamente dentro de la biblioteca de Jetpack. Por ejemplo, AppFunctionManager puede verificar si se admite la función.

Este es un ejemplo de AppFunctions para una app para tomar notas con capacidades para crear, editar y enumerar notas.

class NoteFunctions(
  private val noteRepository: NoteRepository
) {
    /**
     * A note.
     *
     * @param id The note's ID.
     * @param title The note's title.
     * @param content The note's content.
     */
    @AppFunctionSerializable(isDescribedByKDoc = true)
    data class Note(val id: Int, val title: String, val content: String)

    /**
     * Lists all available notes.
     *
     * @param appFunctionContext The context in which the AppFunction is executed.
     */
    @AppFunction(isDescribedByKDoc = true)
    suspend fun listNotes(appFunctionContext: AppFunctionContext): List<Note>? {
        return if (noteRepository.appNotes.isEmpty()) null else viewModel.appNotes
    }

    /**
     * Adds a new note to the app.
     *
     * @param appFunctionContext The context in which the AppFunction is executed.
     * @param title The title of the note.
     * @param content The note's content.
     */
    @AppFunction(isDescribedByKDoc = true)
    suspend fun createNote(
      appFunctionContext: AppFunctionContext,
      title: String,
      content: String
    ): Note {
        return noteRepository.createNote(title, content)
    }

    /**
     * Edits a single note.
     *
     * @param appFunctionContext The context in which the AppFunction is executed.
     * @param noteId The target note's ID.
     * @param title The new title if it should be updated.
     * @param content The new content if it should be updated.
     */
    @AppFunction(isDescribedByKDoc = true)
    suspend fun editNote(
      appFunctionContext: AppFunctionContext,
      noteId: String,
      title: String?,
      content: String,
    ): Note? {
        return noteRepository.updateNote(noteId, title, content)
    }
}