Compila apps inteligentes para Android: Integra el sistema de inteligencia de Android con AppFunctions

Te damos la bienvenida nuevamente a la serie de entradas de blog "Compila apps inteligentes para Android", en la que tomamos una app básica para Android y la transformamos en una experiencia personalizada, inteligente y de agente. En nuestra entrada anterior, exploramos cómo aprovechar Firebase AI Logic para compilar funciones de IA híbridas y alojadas en la nube.

Las IUs móviles tradicionales se destacan en tareas prácticas y enfocadas, y el sistema de inteligencia de Android presenta funciones complementarias para facilitar aún más las acciones complejas de varios pasos. Al complementar las interfaces de usuario tradicionales, AppFunctions proporciona un nuevo punto de entrada potente: un agente con privilegios en el dispositivo puede acceder a las funciones de la app en segundo plano. Esto puede ser particularmente útil cuando los usuarios conducen, caminan o realizan 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 Android AppFunctions. Exploraremos la lógica detrás de nuestras opciones de funciones, analizaremos las herramientas especializadas que usamos para acelerar el desarrollo y profundizaremos en el código que hace que todo funcione.

Diseña 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 de voz o texto sea objetivamente más rápido que presionar las pantallas. En esta grabación de pantalla en paralelo, puedes ver este contraste perfectamente: a la izquierda, un usuario presiona varias pantallas para registrar un gasto; a la derecha, la misma tarea se completa al instante en segundo plano a través de un agente con privilegios.

Nuestra primera opción fue el seguimiento de gastos. Por lo general, registrar un gasto de café durante un viaje requiere presionar varias veces: desbloquear el teléfono, abrir la app, encontrar 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 del trabajo pesado. Cuando el usuario dice "Agrega un gasto de café de cinco dólares a mi viaje a París", el agente busca automáticamente el ID de viaje correcto en segundo plano y agrega el gasto, omitiendo por completo el flujo manual de la IU.

También priorizamos la administración de itinerarios. Por lo general, encontrar qué actividad sigue en un itinerario de viaje ocupado requiere desplazarse por una vista de cronograma densa. Al proporcionar 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 poco seguro. Exponer una capacidad de notas de voz permite al usuario decir "El vuelo fue increíble, vi una hermosa puesta de sol y logré dormir bien", y el agente con privilegios la transcribe y guarda automáticamente directamente en la base de datos de viajes con la AppFunction addVoiceNote.

MCP de Android con tecnología de AppFunctions

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

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

En el modelo 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 lado del 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 de MCP te brinda control total: eliges exactamente qué funciones son accesibles para 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 habilidad de desarrollo de AppFunctions es un compañero de desarrollo completo. Nos guio durante 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, refinamiento 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.

Proporciona funciones de la app al sistema de inteligencia

Basta de teoría, profundicemos en la implementación.

Configuración y configuración de dependencias

Comenzamos agregando las dependencias de AppFunctions. Una para la API y otra 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 intercambiado 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>,
)

Proporciona funciones con la anotación @AppFunction

A continuación, la habilidad escribió las funciones de Kotlin que realizan las consultas de la base de datos y las anotan 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 AppFunctions se ejecuta en el subproceso de IU de forma predeterminada, usamos withContext(Dispatchers.IO) para cambiar a un despachador en segundo plano. Además, refinamos 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 con privilegios 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 declara 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.

Prueba y verifica tus AppFunctions

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

Si ejecutas dispositivos o emuladores con 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 muestran todas las funciones registradas para tu paquete. Luego, puedes ejecutar una función específica y probar su integración de 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 estos comandos de ADB, también puedes usar el agente de prueba de AppFunctions para inspeccionar tu configuración, enumerar y ejecutar AppFunctions, e incluso ver cómo se comportan tus AppFunctions en un flujo conversacional real.

Finalización

Cuando se piensa en las funciones de la app que se pueden aportar 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. AppFunctions te permite usar este nuevo modelo de interacción para apps, lo 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 refinar 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 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 adaptas 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 de la app y descripción general.
Parte 2: Inteligencia integrada en el dispositivo. Profundiza en las APIs de IA generativa de ML Kit y Gemini Nano para compilar 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 basar las respuestas de LLM en datos del mundo real, como Google Maps y el contexto web.
Parte 4 (esta entrada): Integración de sistemas. Integración con el sistema de inteligencia de Android con 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 con tecnología de A2UI y 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 siguen el siguiente aviso sobre derechos de autor:

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