Crea apps inteligentes para Android: Integra AppFunctions en el sistema de inteligencia de Android

Te damos la bienvenida a la serie de entradas de blog "Crea apps inteligentes para Android", en la que tomamos una app básica para Android y la transformamos en una experiencia personalizada, inteligente y basada en agentes. En nuestra publicación anterior, exploramos cómo aprovechar Firebase AI Logic para crear funciones híbridas y alojadas en la nube potenciadas por IA.

Las IU móviles tradicionales se destacan en tareas enfocadas y prácticas, y el sistema de inteligencia de Android está introduciendo funciones complementarias para facilitar aún más las acciones complejas de varios pasos. Al complementar las interfaces de usuario tradicionales, las AppFunctions proporcionan un nuevo y potente punto de entrada: un agente privilegiado en el dispositivo puede acceder a las funciones de la app en segundo plano. Esto puede ser especialmente útil cuando los usuarios están conduciendo, caminando o realizando varias tareas a la vez.

En este artículo, te mostraremos cómo diseñamos e integramos estas capacidades en nuestra app de planificación de viajes, JetPacker, con AppFunctions de Android. Exploraremos la lógica detrás de nuestras elecciones de funciones, analizaremos las herramientas especializadas que usamos para acelerar el desarrollo y profundizaremos en el código que hace que todo funcione.

Diseño de funciones listas para la IA: toma decisiones importantes para tus usuarios

Para seleccionar qué funciones proporcionar al sistema de inteligencia, buscamos tareas en las que un comando por voz o texto es objetivamente más rápido que tocar la pantalla. En esta grabación de pantalla comparativa, se puede ver este contraste a la perfección: a la izquierda, un usuario que presiona varias pantallas para registrar un gasto; a la derecha, la misma tarea completada al instante en segundo plano a través de un agente privilegiado.

Nuestra primera opción fue el seguimiento de gastos. Registrar un gasto de café durante un viaje suele requerir varios toques: desbloquear el teléfono, abrir la app, buscar el viaje activo, navegar a la pestaña de gastos, presionar el botón de agregar, tomar una foto del recibo y verificar el resultado. Al proporcionar las funciones addExpense y getExpenses como AppFunctions, el agente del sistema se encarga de la mayor parte del trabajo. Cuando el usuario dice: "Agrega un gasto de cinco dólares en café a mi viaje a París", el agente busca automáticamente el ID de viaje correcto en segundo plano y agrega el gasto, lo que omite por completo el flujo manual de la IU.

También priorizamos la administración del itinerario. Por lo general, para saber qué actividad sigue en un itinerario de viaje ocupado, es necesario desplazarse por una vista de cronograma densa. Si proporciona getItinerary y addItineraryEvent al sistema, el usuario puede simplemente preguntar: "¿Qué haré después en París?" y obtener una respuesta inmediata.

Por último, nos enfocamos en la captura de notas con manos libres. Escribir recordatorios o notas mientras caminas por una calle concurrida es difícil y peligroso. Exponer una capacidad de notas de voz permite que el usuario diga: "El vuelo fue increíble, vi un hermoso atardecer y pude dormir bien", y el agente privilegiado lo transcribe y guarda automáticamente directamente en la base de datos de viajes  con la AppFunction addVoiceNote.

MCP de Android potenciado por AppFunctions

Toda esta experiencia se basa en el MCP de Android. Según este diseño, la app actúa como un servidor MCP local. En lugar de APIs remotas, proporcionas las funciones de tu app directamente al sistema de inteligencia en el dispositivo.

Android AppFunctions es la API que da vida a este concepto. Lee funciones de Kotlin anotadas y las compila en definiciones de herramientas con seguridad de tipos y en zona de pruebas que el agente privilegiado puede descubrir e invocar de forma local en el dispositivo.

En el modelo de MCP de Android, tu app actúa como un servidor de MCP local que expone herramientas estructuradas, mientras que la plataforma de Android funciona como el registro central de herramientas. En el cliente de MCP, las apps de agentes se registran en el sistema de inteligencia después de que se les otorgan permisos con privilegios del sistema para acceder al registro.

Cuando un usuario interactúa con un agente registrado, su LLM determina si una AppFunction puede controlar la solicitud, consulta los metadatos de la plataforma y ejecuta las funciones registradas correspondientes en segundo plano. Este diseño local de cliente-servidor del MCP te brinda control total: tú eliges exactamente a qué funciones puede acceder el agente, lo que mantiene la privacidad del resto de los datos de tu app.

Cómo aceleramos el desarrollo con habilidades de Android

Para optimizar el proceso de integración, aprovechamos la habilidad de desarrollo de AppFunctions. La skill de desarrollo de AppFunctions es un asistente de desarrollo completo. Nos guio a través de todo el ciclo de vida: asignación de clases de datos de Kotlin para serializar parámetros, generación de los puntos de entrada Service necesarios, perfeccionamiento de nuestra documentación de KDoc para garantizar que el LLM comprenda los límites de los parámetros y configuración de pruebas automatizadas con ADB.

Proporcionar funciones de la app al sistema de inteligencia

Basta de teoría, pasemos a la implementación.

Configuración y dependencias

Comenzaremos por agregar las dependencias de AppFunctions. Uno para la API y otro para el compilador de Kotlin Symbol Processing.

implementation("androidx.appfunctions:appfunctions:1.0.0-alpha10")
ksp("androidx.appfunctions:appfunctions-compiler:1.0.0-alpha10")

Modelado de tipos de datos personalizados

Cualquier objeto personalizado que se intercambie con el agente debe anotarse con @AppFunctionSerializable. En nuestro archivo TripSerializable.kt, definimos nuestro modelo de datos de viaje:

@AppFunctionSerializable(isDescribedByKDoc = true)
data class TripSerializable(
    /** The trip's unique identifier. */
    val id: String,
    /** The trip's title. */
    val title: String,
    /** The trip's destination location. */
    val location: String,
    /** The trip's start date in milliseconds. */
    val startDate: Long,
    /** The trip's end date in milliseconds. */
    val endDate: Long,
    /** A list of participants. */
    val participants: List<String>,
)

Cómo proporcionar funciones con la anotación @AppFunction

A continuación, la skill escribió las funciones de Kotlin que realizan las consultas de la base de datos y las anotó con @AppFunction. Podemos ver esto en searchTrip:

/**
 * Looks for trips based on optional filters like id, title (name), location, and dates.
 *
 * @param id The unique identifier of the trip.
 * @param title The title or name of the trip.
 * @param location The destination location.
 * @param startDate The minimum start date in milliseconds.
 * @param endDate The maximum end date in milliseconds.
 * @return A list of trips matching the filters.
 */
@AppFunction(isDescribedByKDoc = true)
suspend fun searchTrip(
    id: String? = null,
    title: String? = null,
    location: String? = null,
    startDate: Long? = null,
    endDate: Long? = null
): List<TripSerializable> {
    return withContext(Dispatchers.IO) {
    // implementation
}

Como las AppFunctions se ejecutan en el subproceso de IU de forma predeterminada, usamos withContext(Dispatchers.IO) para cambiar a un despachador en segundo plano. Además, mejoramos nuestro KDoc para usar verbos imperativos claros y especificar restricciones de parámetros. Esta documentación se compila directamente en el esquema de la herramienta, que el agente privilegiado usa para resolver parámetros y controlar errores de tiempo de ejecución.

El punto de entrada del servicio y la integración de Hilt

Para registrar estas funciones en el sistema de inteligencia, creamos una clase base abstracta que extiende AppFunctionService. La anotamos con @AppFunctionServiceEntryPoint:

@RequiresApi(36)
@AndroidEntryPoint
@AppFunctionServiceEntryPoint(
    serviceName = "JetPackerAppFunctionService",
    appFunctionXmlFileName = "jetpacker_app_function_service"
)
abstract class BaseJetPackerAppFunctionService : AppFunctionService() {
    @Inject internal lateinit var tripDao: TripDao
    // DAOs and database references are injected here...
}

Durante la compilación, KSP genera la subclase de servicio concreta final, JetPackerAppFunctionService, como se declaró con el parámetro serviceName. También registramos app_metadata.xml en el manifiesto de la app. Este archivo proporciona reglas operativas globales para las AppFunctions declaradas de JetPacker.

Cómo probar y verificar tus AppFunctions

Una vez que las implementes, debes verificar que tus AppFunctions estén registradas y funcionen correctamente.

En dispositivos o emuladores que ejecutan Android 17 o versiones posteriores, puedes usar comandos de ADB desde tu terminal para enumerar e invocar tus funciones. Si ejecutas adb shell cmd app_function list-app-functions, se mostrarán todas las funciones registradas para tu paquete. Luego, puedes ejecutar una función específica y probar su integración en la base de datos ejecutando adb shell cmd app_function execute-app-function mientras pasas una cadena de parámetros JSON sin procesar.

En lugar de usar estos comandos de ADB, también puedes usar el agente de pruebas de AppFunctions para inspeccionar tu configuración, enumerar y ejecutar AppFunctions, y hasta ver cómo se comportan tus AppFunctions en un flujo de conversación real.

Conclusión

Cuando pensamos en las funciones de la app que pueden contribuir al sistema de inteligencia con AppFunctions, se requiere un pequeño cambio en la forma en que pensamos sobre el código y la documentación. Las AppFunctions te permiten usar este nuevo modelo de interacción para apps, que permite usar un agente para acceder a las funciones de la app.

En primer lugar, la habilidad de desarrollo de AppFunctions es una herramienta esencial del ciclo de vida que te ayuda a descubrir funciones, implementar y definir AppFunctions para tus apps. En segundo lugar, los comentarios de KDoc son un recurso de API compilado; las descripciones claras de los parámetros afectan directamente la precisión de ejecución del agente del sistema. Por último, el MCP de Android proporciona una ejecución local primero, lo que permite que las apps colaboren de forma segura con los agentes de IA.

Aportar funciones de la app a través de AppFunctions prepara tu aplicación para el sistema de inteligencia. Cuéntanos cómo estás adaptando tus apps para la era de los agentes.

Más información

Consulta las otras partes de esta serie de entradas de blog:
Parte 1: Introducción a la app y descripción general.
Parte 2: Inteligencia en el dispositivo. Analiza en detalle las APIs de IA generativa de ML Kit y Gemini Nano para crear funciones que prioricen la privacidad ante todo, como el resumen de itinerarios, el análisis de recibos y el procesamiento de audio local.
Parte 3: Razonamiento híbrido y en la nube. Explora cómo usar Firebase AI Logic para fundamentar las respuestas de LLM en datos del mundo real, como Google Maps y el contexto web.
Parte 4 (esta publicación): Integración de sistemas Integración con el sistema de inteligencia de Android a través de AppFunctions.
Parte 5 (próximamente): Flujos de trabajo de agentes integrados en la app. Extiende la app con un asistente de reservas de extremo a extremo potenciado por A2UI y el ADK.

¿Te interesa obtener más información sobre el desarrollo para Android? Sigue a Android Developers en YouTube o LinkedIn.

Todos los fragmentos de código de esta entrada de blog incluyen el siguiente aviso sobre derechos de autor:

Copyright 2026 Google LLC.
SPDX-License-Identifier: Apache-2.0