Istruzioni

Crea app per Android intelligenti: integrati nel sistema di intelligence di Android utilizzando AppFunctions

Tempo di lettura: 6 min
Visualizza il profilo di Ben Weiss
Ben Weiss Developer Relations Engineer

Ti diamo il bentornato alla serie di blog post "Crea app per Android intelligenti", in cui prendiamo un'app per Android di base e la trasformiamo in un'esperienza personalizzata, intelligente e agentica. Nel nostro post precedente, abbiamo esplorato come sfruttare Firebase AI Logic per creare funzionalità di AI ibride e ospitate nel cloud.

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

In questo articolo, ti mostreremo come abbiamo progettato e integrato queste funzionalità nella nostra app di pianificazione dei viaggi, JetPacker, utilizzando AppFunctions per Android. Esploreremo le motivazioni alla base delle nostre scelte relative alle funzionalità, discuteremo degli 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 attività in cui un comando vocale o di testo è oggettivamente più veloce rispetto al tocco delle 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 istantaneamente in background tramite un agente con privilegi.

La nostra prima scelta è stata il monitoraggio delle spese. La registrazione di una spesa per un caffè durante un viaggio richiede in genere diversi tocchi: sblocco dello smartphone, apertura dell'app, ricerca del viaggio attivo, navigazione alla scheda delle spese, tocco del pulsante di aggiunta, scatto di una foto della ricevuta e controllo del risultato. Fornendo le funzionalità addExpense e getExpenses come AppFunctions, l'agente di sistema si occupa del lavoro più impegnativo. Quando l'utente dice "Aggiungi una spesa di cinque dollari per il caffè al mio viaggio a Parigi", l'agente cerca automaticamente l'ID viaggio corretto in background e inserisce la spesa, saltando completamente il flusso UI manuale.

Abbiamo anche dato la priorità alla gestione degli itinerari. Per trovare l'attività successiva in un itinerario di viaggio fitto di impegni, di solito è necessario scorrere una visualizzazione cronologica densa. Fornendo getItinerary e addItineraryEvent al sistema, l'utente può semplicemente chiedere "Cosa farò dopo a Parigi?" e ricevere una risposta immediata.

Infine, ci siamo concentrati sull'acquisizione di note con comandi vocali. Digitare promemoria o note mentre cammini per una strada affollata è difficile e non sicuro. L'esposizione di una funzionalità di nota vocale consente all'utente di dire: "Il volo è stato fantastico, ho visto un bellissimo tramonto e sono riuscito a dormire bene" e l'agente con privilegi la trascrive e la salva automaticamente direttamente nel database di viaggio  utilizzando l'AppFunction addVoiceNote.

Android MCP basato su AppFunctions

L'intera esperienza si basa su Android MCP. In questo progetto, l'app funge da server MCP locale. Anziché utilizzare API remote, fornisci le funzionalità della tua app direttamente al sistema di intelligence on-device.

Android AppFunctions è l'API che dà vita a questo concetto. Legge le funzioni Kotlin annotate e le compila in definizioni di strumenti sicure per i tipi e in sandbox che l'agente con privilegi può rilevare e richiamare localmente sul dispositivo.

Android MCP diagram.png
Diagramma che evidenzia il modo in cui le nostre app, la piattaforma Android e gli agenti di sistema coordinano AppFunctions.

Nel modello MCP di Android, la tua app agisce come un 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 registry.

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

Come abbiamo accelerato lo sviluppo con le competenze Android

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

Fornire funzionalità dell'app al sistema di intelligence

Basta con la teoria, passiamo all'implementazione.

Configurazione e impostazione delle dipendenze

Iniziamo aggiungendo le dipendenze AppFunctions. Uno per l'API e uno per il compilatore Kotlin Symbol Processing.

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

Modellazione di tipi di dati personalizzati

Qualsiasi oggetto personalizzato scambiato con l'agente deve essere annotato con @AppFunctionSerializable. Nel nostro file TripSerializable.kt, definiamo il nostro modello di dati del 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 skill ha scritto le funzioni Kotlin che eseguono le query sul database e le annotano 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é le AppFunction vengono eseguite sul thread dell'interfaccia utente per impostazione predefinita, utilizziamo withContext(Dispatchers.IO) per passare a un dispatcher in background. Inoltre, perfezioniamo il nostro KDoc per utilizzare verbi chiari e imperativi 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.

L'entry point del servizio e l'integrazione di Hilt

Per registrare queste funzionalità nel sistema di intelligence, creiamo una classe base astratta che estende AppFunctionService. Lo 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 del servizio concreta finale, JetPackerAppFunctionService, come dichiarato con il parametro serviceName. Inoltre, registriamo app_metadata.xml nel manifest dell'app. Questo file fornisce regole operative globali per le AppFunction dichiarate di JetPacker.

Test e verifica di AppFunctions

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

Se utilizzi 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 mostra tutte le funzioni registrate per il tuo pacchetto. Puoi quindi eseguire una funzione specifica e testare la sua integrazione con il database eseguendo adb shell cmd app_function execute-app-function e passando una stringa di parametri JSON non elaborata.

Invece di questi comandi ADB, puoi anche utilizzare l'AppFunctions Testing Agent per ispezionare la configurazione, elencare ed eseguire le AppFunction e persino vedere come si comportano le AppFunction in un flusso di conversazione reale.

Wrap up

Quando si pensa alle funzionalità dell'app che possono essere fornite 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 permette di utilizzare un agente per accedere alle funzionalità delle app.

Innanzitutto, la competenza di sviluppo di AppFunctions è uno strumento essenziale per il ciclo di vita, che ti aiuta a scoprire funzionalità, implementare e perfezionare AppFunctions per le tue app. In secondo luogo, i commenti KDoc sono un asset API compilato; 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 sicurezza con gli agenti AI.

Se contribuisci alle funzionalità dell'app tramite AppFunctions, la tua applicazione è pronta per il sistema di intelligence. Facci sapere come stai adattando le tue app per l'era agentica.

Scopri di più

Dai un'occhiata alle altre parti di questa serie di blog post:
Parte 1: introduzione dell'app e panoramica generale.
Parte 2: on-device intelligence. Approfondisci le API GenAI di ML Kit e Gemini Nano per creare funzionalità incentrate sulla privacy, come il riepilogo degli itinerari, l'analisi delle ricevute e l'elaborazione dell'audio locale.
Parte 3: ragionamento ibrido e cloud. Scopri come utilizzare Firebase AI Logic per basare le risposte degli LLM su dati reali come Google Maps e il contesto web.
Parte 4 (questo post!): Integrazione dei sistemi. Integrazione con il sistema di intelligence di Android utilizzando AppFunctions.
Parte 5 (disponibile a breve): Agentic Workflows in-app. Estendi l'app con un assistente per le prenotazioni end-to-end basato su A2UI e ADK.

Vuoi saperne di più sullo sviluppo Android? Segui Android Developers su YouTube o LinkedIn.

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

Copyright 2026 Google LLC.
SPDX-License-Identifier: Apache-2.0
Scritto da:
Continua a leggere