Crea app Android intelligenti: integra il sistema di intelligence di Android utilizzando AppFunctions

Bentornato alla serie di post del blog "Crea app per Android intelligenti", in cui prendiamo un'app per Android di base e la trasformiamo in un'esperienza personalizzata, intelligente e basata su agenti. Nel post precedente, abbiamo esplorato come sfruttare Firebase AI Logic per creare funzionalità di AI ibride e ospitate nel cloud.

Le UI mobile tradizionali sono ottime per le attività pratiche e mirate, mentre il sistema di intelligence di Android sta introducendo funzionalità complementari per semplificare ulteriormente le azioni complesse e in più passaggi. Integrando le interfacce utente tradizionali, AppFunctions fornisce un nuovo punto di accesso potente: un agente con privilegi sul dispositivo può accedere alle funzionalità dell'app in background. Questo può essere particolarmente utile quando gli utenti sono alla guida, camminano o svolgono altre attività in multitasking.

In questo articolo, ti mostreremo come abbiamo progettato e integrato queste funzionalità nella nostra app di pianificazione dei viaggi, JetPacker, utilizzando Android AppFunctions. Esploreremo la logica alla base delle nostre scelte di funzionalità, discuteremo gli strumenti specializzati che abbiamo utilizzato per accelerare lo sviluppo e approfondiremo il codice che fa funzionare tutto.

Progettare funzionalità pronte per l'AI: fare scelte importanti per gli utenti

Per selezionare le funzionalità da fornire al sistema di intelligence, abbiamo cercato le attività in cui un comando vocale o di testo è oggettivamente più veloce rispetto a toccare più schermate. In questa registrazione dello schermo affiancata puoi vedere perfettamente questo contrasto: a sinistra, un utente che tocca più schermate per registrare una spesa; a destra, la stessa attività completata immediatamente in background tramite un agente con privilegi.

La nostra prima scelta è stata il monitoraggio delle spese. La registrazione di una spesa per il caffè durante un viaggio di solito richiede alcuni tocchi: sbloccare il telefono, aprire l'app, trovare il viaggio attivo, passare alla scheda delle spese, toccare il pulsante Aggiungi, scattare una foto della ricevuta e controllare il risultato. Fornendo le funzionalità addExpense e getExpenses come AppFunctions, l'agente di sistema si occupa del lavoro pesante. Quando l'utente dice "Aggiungi una spesa per il caffè di 5 € al mio viaggio a Parigi", l'agente cerca automaticamente l'ID del viaggio corretto in background e inserisce la spesa, saltando completamente il flusso dell'UI manuale.

Abbiamo anche dato la priorità alla gestione dell'itinerario. Trovare l'attività successiva in un itinerario di viaggio intenso di solito richiede di scorrere una visualizzazione della sequenza temporale densa. Fornendo getItinerary e addItineraryEvent al sistema, l'utente può semplicemente chiedere "Cosa devo fare dopo a Parigi?" e ottenere una risposta immediata.

Infine, ci siamo concentrati sull'acquisizione di note in vivavoce. Digitare promemoria o note mentre si cammina per una strada trafficata è difficile e pericoloso. L'esposizione di una funzionalità di note vocali consente all'utente di dire "Il volo è stato fantastico, ho visto un tramonto bellissimo e sono riuscito a dormire bene" e l'agente con privilegi lo trascrive e lo salva automaticamente direttamente nel database dei viaggi utilizzando la AppFunction addVoiceNote.

Android MCP basato su AppFunctions

L'intera esperienza è basata su Android MCP. In base a questa progettazione, l'app funge da server MCP locale. Anziché API remote, fornisci le funzionalità dell'app direttamente al sistema di intelligence sul dispositivo.

Android AppFunctions è l'API che dà vita a questo concetto. Legge le funzioni Kotlin annotate e le compila in definizioni di strumenti con sandbox e type-safe che l'agente con privilegi può scoprire e richiamare localmente sul dispositivo.

Nel modello Android MCP, l'app funge da server MCP locale che espone strumenti strutturati, mentre la piattaforma Android funge da registro centrale degli strumenti. Sul lato client MCP, le app degli agenti vengono registrate nel sistema di intelligence dopo aver ricevuto le autorizzazioni con privilegi di sistema per accedere al registro.

Quando un utente interagisce con un agente registrato, il suo LLM determina se la richiesta può essere gestita da una AppFunction, esegue una query sui metadati della piattaforma ed esegue le funzioni registrate appropriate in background. Questa progettazione client-server MCP locale ti offre il controllo completo: scegli esattamente quali funzionalità sono accessibili all'agente, mantenendo privati gli altri dati dell'app.

Come abbiamo accelerato lo sviluppo con le competenze di Android

Per semplificare il processo di integrazione, abbiamo sfruttato la competenza di sviluppo di AppFunctions. La competenza di sviluppo di AppFunctions è un compagno di sviluppo completo. Ci ha guidato durante l'intero ciclo di vita: mappatura delle classi di dati Kotlin per serializzare i parametri, generazione dei punti di ingresso Service necessari, perfezionamento della documentazione KDoc per garantire che l'LLM comprenda i limiti dei parametri e configurazione dei test automatici utilizzando ADB.

Fornire le funzionalità dell'app al sistema di intelligence

Basta con la teoria, passiamo all'implementazione.

Configurazione e impostazione delle dipendenze

Iniziamo aggiungendo le dipendenze di AppFunctions. Una per l'API e una per il compilatore di elaborazione dei simboli Kotlin.

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

Modellare i tipi di dati personalizzati

Qualsiasi oggetto personalizzato scambiato con l'agente deve essere annotato con @AppFunctionSerializable. Nel file TripSerializable.kt, definiamo il nostro modello di dati sul percorso:

@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>,
)

Fornire funzionalità utilizzando l'annotazione @AppFunction

Successivamente, la competenza ha scritto le funzioni Kotlin che eseguono le query del database e le ha annotate con @AppFunction. Possiamo visualizzarlo in 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
}

Poiché AppFunctions viene eseguito per impostazione predefinita sul thread dell'interfaccia utente, utilizziamo withContext(Dispatchers.IO) per passare a un dispatcher in background. Inoltre, perfezioniamo il nostro KDoc per utilizzare verbi imperativi chiari e specificare i vincoli dei parametri. Questa documentazione viene compilata direttamente nello schema dello strumento, che l'agente con privilegi utilizza per risolvere i parametri e gestire gli errori di runtime.

Il punto di ingresso del servizio e l'integrazione di Hilt

Per registrare queste funzionalità nel sistema di intelligence, creiamo una classe base astratta che estende AppFunctionService. La annotiamo 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 compilazione, KSP genera la sottoclasse di servizio concreta finale, JetPackerAppFunctionService, come dichiarato con il parametro serviceName. Registriamo anche app_metadata.xml nel manifest dell'app. Questo file fornisce regole operative globali per le AppFunctions dichiarate di JetPacker.

Testare e verificare le AppFunctions

Una volta implementate, devi verificare che le AppFunctions siano registrate e funzionino correttamente.

Se esegui dispositivi o emulatori con Android 17 o versioni successive, puoi utilizzare i comandi ADB dal terminale per elencare e richiamare le funzioni. L'esecuzione di adb shell cmd app_function list-app-functions visualizza tutte le funzioni registrate per il tuo pacchetto. Puoi quindi eseguire una funzione specifica e testare l'integrazione del database eseguendo adb shell cmd app_function execute-app-function mentre passi una stringa di parametri JSON non elaborati.

Anziché questi comandi ADB, puoi anche utilizzare l'agente di test di AppFunctions per esaminare la configurazione, elencare ed eseguire AppFunctions e persino vedere come si comportano le AppFunctions in un flusso conversazionale reale.

Conclusione

Quando si pensa alle funzionalità dell'app che possono essere contribuite al sistema di intelligence utilizzando AppFunctions, è necessario un leggero cambiamento nel modo in cui pensiamo al codice e alla documentazione. AppFunctions ti consente di utilizzare questo nuovo modello di interazione per le app, che consente di utilizzare un agente per accedere alle funzionalità dell'app.

Innanzitutto, la competenza di sviluppo di AppFunctions è uno strumento essenziale del ciclo di vita che ti aiuta a scoprire le funzionalità, implementare e perfezionare AppFunctions per le tue app. In secondo luogo, i commenti KDoc sono un asset API compilato; le descrizioni chiare dei parametri influiscono direttamente sull'accuratezza dell'esecuzione dell'agente di sistema. Infine, Android MCP fornisce un'esecuzione local-first che consente alle app di collaborare in modo sicuro con gli agenti AI.

La contribuzione delle funzionalità dell'app tramite AppFunctions rende la tua applicazione pronta per il sistema di intelligence. Facci sapere come stai adattando le tue app per l'era agentica.

Scopri di più

Consulta le altre parti di questa serie di post del blog:
Parte 1: introduzione dell'app e panoramica di alto livello.
Parte 2: intelligence sul dispositivo. Approfondisci le API GenAI di ML Kit e Gemini Nano per creare funzionalità incentrate sulla privacy, come il riepilogo dell'itinerario, l'analisi delle ricevute e l'elaborazione audio locale.
Parte 3: ragionamento ibrido e nel cloud. Scopri come utilizzare Firebase AI Logic per basare le risposte LLM su dati reali come Google Maps e il contesto web.
Parte 4 (questo post): Integrazione del sistema. Integrazione con il sistema di intelligence di Android utilizzando AppFunctions.
Parte 5 (in arrivo): flussi di lavoro basati su agenti in-app. Estendi l'app con un assistente di prenotazione end-to-end basato su A2UI e ADK.

Ti interessa saperne di più sullo sviluppo di Android? Segui Android for Developers su YouTube o LinkedIn.

Tutti gli snippet di codice in questo post del blog seguono la seguente nota sul copyright:

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