Panoramica di AppFunctions

AppFunctions è un'API della piattaforma Android con una libreria Jetpack di accompagnamento per semplificare l'integrazione di Android MCP. Consente alle tue app di comportarsi come server MCP sul dispositivo, contribuendo con funzioni che fungono da strumenti per l'utilizzo da parte di funzionalità proattive, nonché di agenti e assistenti, come Google Gemini. A partire da maggio 2026, l'integrazione di AppFunctions con Gemini è in anteprima privata con tester di fiducia. Puoi iniziare a preparare le tue app ora per utilizzare AppFunctions e gli strumenti di sviluppo.

Definendo queste AppFunctions, consenti alla tua app di fornire servizi, dati e azioni al registro integrato nel sistema operativo Android, consentendo agli utenti di completare le attività tramite agenti e interazioni a livello di sistema.

Le AppFunctions fungono da equivalenti mobili degli strumenti all'interno del Model Context Protocol (MCP). Mentre MCP standardizza tradizionalmente il modo in cui gli agenti si connettono agli strumenti lato server, AppFunctions fornisce lo stesso meccanismo per le app Android. In questo modo, puoi esporre le funzionalità della tua app come "strumenti" orchestrabili che le app autorizzate (chiamanti) possono scoprire ed eseguire per soddisfare le intenzioni dell'utente. I chiamanti devono disporre dell'autorizzazione EXECUTE_APP_FUNCTIONS per scoprire ed eseguire AppFunctions e possono includere agenti, app e assistenti AI come Gemini.

AppFunctions è disponibile sui dispositivi con Android 16 o versioni successive.

Esempi di casi d'uso

Le AppFunctions forniscono un meccanismo potente per automatizzare le attività e semplificare le interazioni degli utenti. Aprendo le funzionalità della tua app, consenti agli utenti di raggiungere obiettivi complessi utilizzando il linguaggio naturale, spesso sostituendo la necessità di una navigazione manuale passo passo con la tua UI.

I seguenti scenari illustrano come è possibile utilizzare AppFunctions per migliorare le esperienze in una varietà di categorie di app:

  • Gestione delle attività e produttività

    • Richiesta dell'utente: "Ricordami di ritirare il pacco al lavoro oggi alle 17 :00".
    • Azione AppFunction: il chiamante identifica l'app di gestione delle attività pertinente e richiama una funzione per creare un'attività, compilando automaticamente i campi titolo, ora e località in base al prompt dell'utente.

    /**
 * Create a new task or reminder with a title, due time, and location.
 *
 * @param title The descriptive title of the task (e.g., "Pick up my package").
 * @param dueDateTime The specific date and time when the task should be completed.
 * @param location The physical location associated with the task (e.g., "Work").
 * @return The created Task
 */
@AppFunction(isDescribedByKDoc = true)
suspend fun createTask(
    title: String,
    dueDateTime: LocalDateTime? = null,
    location: String? = null,
): Task = TODO()

  • Media e intrattenimento

    • Richiesta dell'utente: "Crea una nuova playlist con i migliori album jazz di quest'anno".
    • Azione AppFunction: il chiamante esegue una funzione di creazione di playlist all'interno di un'app musicale, passando il contesto come "i migliori album jazz del 2026" come query per generare immediatamente la playlist.

    /**
 * Create a new music playlist based on a natural language query.
 *
 * @param query The description used to generate the playlist (e.g., "top jazz albums from 2026").
 * @return The final created playlist based on songs.
 */
@AppFunction(isDescribedByKDoc = true)
suspend fun createPlaylistFromQuery(
    query: String,
): Playlist = TODO()

  • Flussi di lavoro tra app

    • Richiesta dell'utente: "Trova la ricetta dei noodle nell'email di Lisa e aggiungi gli ingredienti alla mia lista della spesa".
    • Azione AppFunction: questa richiesta utilizza le funzioni di più app. Innanzitutto, il chiamante utilizza la funzione di ricerca di un'app di posta elettronica per recuperare i contenuti. Poi, estrae gli ingredienti pertinenti e richiama la funzione di un'app per la lista della spesa per compilare l'elenco dell'utente.

    /**
 * Search for emails matching a query or sender name to retrieve content like recipes.
 *
 * @param query The search term or contact name (e.g., "Lisa noodle recipe").
 * @return A list of matching email summaries containing the requested information.
 */
@AppFunction(isDescribedByKDoc = true)
suspend fun searchEmails(
    query: String,
): List<EmailSummary> = TODO()

/**
 * Add a list of items or ingredients to the user's active shopping list.
 *
 * @param items The names of the ingredients or products to add to the list.
 * @return The final shopping list with new items added
 */
@AppFunction(isDescribedByKDoc = true)
suspend fun addItemsToShoppingList(
    items: List<String>,
): ShoppingList = TODO()

  • Calendario e pianificazione

    • Richiesta dell'utente: "Aggiungi la festa di compleanno di mamma al mio calendario per lunedì prossimo alle 18:00".
    • Azione AppFunction: l'app agentica approvata richiama la funzione "crea evento" dell'app Calendario, analizzando il contesto pertinente come "lunedì prossimo" e "18:00" per creare la voce senza che l'utente debba aprire manualmente il calendario.

    /**
 * Schedule a new event on the user's primary calendar.
 *
 * @param title The name of the calendar event (e.g., "Mom's birthday party").
 * @param startDateTime The specific date and time the event is scheduled to begin.
 * @return The created Event object.
 */
@AppFunction(isDescribedByKDoc = true)
suspend fun createCalendarEvent(
    title: String,
    startDateTime: LocalDateTime,
): Event = TODO()

Come funzionano le AppFunctions

Il seguente diagramma illustra il flusso tipico di come le AppFunctions vengono condivise dalle app con un agente e successivamente eseguite. È probabile che gli agenti prendano in considerazione sia gli strumenti MCP remoti lato server sia le AppFunctions locali quando gestiscono le richieste degli utenti. Il flusso dettagliato per l'utilizzo delle AppFunctions locali è il seguente:

  • Dichiarazione di AppFunction: l'app per Android è progettata per utilizzare AppFunctions per rendere disponibili le sue funzionalità, ad esempio "Crea nota" o "Invia messaggio".
  • Generazione dello schema: la libreria Jetpack AppFunctions genera un file di schema XML che elenca tutte le AppFunctions dichiarate nell'app. Il sistema operativo Android utilizza questo file per indicizzare le AppFunctions disponibili.
  • Recupero dei metadati: l'agente può recuperare i metadati di AppFunction eseguendo una query. Oltre ai KDoc specifici per le funzioni, gli sviluppatori possono definire pattern e vincoli operativi a livello di app nei metadati dell'app per guidare l'orchestrazione degli agenti su più strumenti.
  • Selezione ed esecuzione di AppFunction: in base ai prompt dell'utente, l'agente seleziona ed esegue l'AppFunction appropriata con i parametri appropriati.
Flusso tipico di AppFunctions dall'esposizione dell'app all'esecuzione dell'agente.
Figura 1: il flusso tipico di come le AppFunctions vengono esposte e successivamente eseguite da un agente.

La libreria Jetpack AppFunctions semplifica l'esposizione delle funzionalità della tua app. Con il processore di annotazioni, puoi annotare le funzioni che vuoi rendere disponibili agli agenti. I chiamanti possono quindi scoprire e richiamare queste funzioni indicizzate utilizzando AppFunctionManager.

Prima di richiamare una funzione, i chiamanti devono verificare che il dispositivo supporti la funzionalità AppFunctions tentando di recuperare un'istanza di AppFunctionManager. Una volta supportati, i chiamanti possono verificare se una specifica funzione è abilitata all'interno di un'app di destinazione utilizzando isAppFunctionEnabled(packageName,functionId). L'esecuzione di query sullo stato delle funzioni in altri pacchetti richiede l' android.permission.EXECUTE_APP_FUNCTIONSpermission.

Non è necessario che la tua app verifichi se la funzionalità AppFunction è supportata; questa operazione viene gestita automaticamente all'interno della libreria Jetpack. Ad esempio, AppFunctionManager può verificare se la funzionalità è supportata.

Ecco un esempio di AppFunctions per un'app per prendere appunti con funzionalità per creare, modificare ed elencare le note:

@RequiresApi(36)
@AndroidEntryPoint
@AppFunctionServiceEntryPoint(
    serviceName = "TaskAppFunctionService",
    appFunctionXmlFileName = "task_app_function_service",
)
abstract class BaseTaskAppFunctionService : AppFunctionService() {
    @Inject internal lateinit var taskRepository: TaskRepository

    /**
     * Creates a task based on [createTaskParams].
     *
     * @param createTaskParams The parameter to describe how to create the task.
     */
    @AppFunction(isDescribedByKDoc = true)
    suspend fun createTask(
        createTaskParams: CreateTaskParams,
    ): Task = withContext(Dispatchers.IO) {
        // Developers can use predefined exceptions to let the agent know
        // why it failed.
        if (createTaskParams.title == null && createTaskParams.content == null) {
            throw AppFunctionInvalidArgumentException("Title or content should be non-null")
        }

        val id = taskRepository.createTask(
            createTaskParams.title,
            createTaskParams.content
        )

        return@withContext taskRepository
            .getTask(id)
            ?.toTask()
            ?: throw AppFunctionElementNotFoundException("Task not found for ID = $id")
    }

    // Maps internal TaskEntity
    private fun TaskEntity.toTask() = Task(id = id, title = title, content = description)
}

/** The parameter to create the task. */
@AppFunctionSerializable(isDescribedByKDoc = true)
data class CreateTaskParams(
    /** The title of the task. */
    val title: String?,
    /** The content of the task. */
    val content: String?,
)

/** The user-created task. */
@AppFunctionSerializable(isDescribedByKDoc = true)
data class Task(
    /** The ID of the task. */
    val id: String,
    /** The title of the task. */
    val title: String,
    /** The content of the task. */
    val content: String,
)

Esempi, competenze e strumenti di test

Abbiamo reso disponibili i seguenti elementi per aiutarti a migliorare le tue competenze in AppFunctions:

  • Esplora l'esempio di AppFunctions per verificare ed esplorare il funzionamento di tutto sui tuoi dispositivi.
  • Utilizza la competina dell'agente AppFunctions per accelerare lo sviluppo durante il ciclo di vita in quattro passaggi:
    • Rilevamento: analizza la base di codice per identificare e consigliare funzionalità di alto valore per l'orchestrazione dell'AI.
    • Implementazione e configurazione: genera implementazioni Kotlin e configura i metadati di sistema e le dipendenze di build.
    • Perfezionamento di KDoc: ottimizza la documentazione di funzioni e proprietà per gli agenti AI e Android MCP.
    • Test e debug: fornisci comandi ADB per la valutazione e il debug locali sul dispositivo.
  • Per i test e la verifica da riga di comando, utilizza i comandi ADB come adb shell cmd app_function ... come un modo diretto e leggero per testare la registrazione delle funzioni , ispezionare le descrizioni dei metadati ed eseguire le funzioni sul dispositivo.
  • Per provare Android MCP in azione e testare i flussi di lavoro end-to-end senza bisogno di prompt, installa e utilizza l'app per Android dell'agente di test AppFunctions sul tuo dispositivo.

Domande frequenti

La sezione seguente risponde alle domande frequenti su AppFunctions.

Sono uno sviluppatore di app. Posso implementare AppFunctions oggi?

Sì, è possibile implementare e testare AppFunctions all'interno dell'app seguendo le indicazioni dettagliate nelle sezioni precedenti.

Qual è la differenza tra AppFunctions e MCP?

Entrambi consentono agli agenti AI di orchestrare gli strumenti, ma presentano differenze significative in termini di architettura, latenza e impegno richiesto agli sviluppatori. Le AppFunctions sono hook integrati a livello di sistema operativo esclusivi di Android che vengono eseguiti localmente. Al contrario, un server MCP standard è una soluzione indipendente dalla piattaforma che si basa sull'esecuzione nel cloud e sui round trip di rete.

In breve, lo sviluppo con AppFunctions ti consente di utilizzare lo stato dell'app esistente direttamente sul dispositivo e non richiede di gestire servizi al di fuori dell'app per Android.

Ho implementato AppFunctions nella mia app. Perché il mio agente di sistema non può accedervi?

Le AppFunctions sono una funzionalità sperimentale. Per valutare attentamente la qualità dell'esperienza complessiva durante questa fase sperimentale, solo un numero limitato di app e agenti di sistema può accedere all'intera pipeline.

Come posso preparare la mia app per la disponibilità generale di AppFunctions?

Valuta quali funzionalità della tua app vuoi esporre all'automazione agentica. Puoi implementare AppFunctions nella tua app. Per farlo, segui i passaggi descritti nelle sezioni precedenti di questa pagina e verifica che siano registrati sul dispositivo chiamando adb shell cmd app_function list-app-functions.

Posso ottenere l'accesso in anteprima all'esperienza di sviluppo agentica end-to-end?

Stiamo conducendo un programma di accesso in anteprima (EAP) per integrare app selezionate nel test dell'esperienza di sviluppo end-to-end necessaria per lanciare AppFunctions in produzione su Android. Puoi manifestare il tuo interesse a integrare le tue AppFunctions tramite questo modulo di registrazione all'EAP. La registrazione del tuo interesse NON ti garantisce automaticamente l'accesso all'integrazione completa. Ti invieremo un'email se la tua app viene selezionata per l'EAP o per informarti quando AppFunctions sarà disponibile pubblicamente.

Come posso fornire un feedback su AppFunctions?

Puoi fornire un feedback sull'API segnalando un problema e registrando il tuo interesse nel modulo del programma di accesso in anteprima.