Übersicht über AppFunctions

Mit AppFunctions kann deine Android-App bestimmte Funktionen freigeben, die vom System und verschiedenen KI-Agenten und ‑Assistenten erkannt und aufgerufen werden können. Durch das Definieren dieser Funktionen kann deine App Dienste, Daten und Aktionen für das Android-Betriebssystem bereitstellen. So können Nutzer Aufgaben über KI-Agenten und Interaktionen auf Systemebene erledigen.

AppFunctions sind das mobile Äquivalent zu Tools im Model Context Protocol (MCP). Während MCP traditionell standardisiert, wie sich Agenten mit serverseitigen Tools verbinden, bieten AppFunctions denselben Mechanismus für Android-Apps. So kannst du die Funktionen deiner App als orchestrierbare „Tools“ verfügbar machen, die von autorisierten Apps (Aufrufern) erkannt und ausgeführt werden können, um Nutzeranfragen zu erfüllen. Aufrufer benötigen die EXECUTE_APP_FUNCTIONS Berechtigung, um AppFunctions zu erkennen und auszuführen. Dazu gehören Agenten, Apps, und KI-Assistenten wie Gemini.

AppFunctions funktionieren auf Geräten mit Android 16 oder höher.

Anwendungsbeispiele

AppFunctions bieten einen leistungsstarken Mechanismus zum Automatisieren von Aufgaben und Optimieren von Nutzerinteraktionen. Wenn du die Funktionen deiner App verfügbar machst, können Nutzer komplexe Aufgaben in natürlicher Sprache erledigen. Oft ist es dann nicht mehr erforderlich, Schritt für Schritt manuell in der Benutzeroberfläche zu navigieren.

Die folgenden Szenarien veranschaulichen, wie AppFunctions verwendet werden können, um die Nutzererfahrung in verschiedenen App-Kategorien zu verbessern:

• Aufgabenverwaltung und Produktivität
  • Nutzeranfrage: "Erinnere mich daran, heute um 17:00 Uhr mein Paket bei der Arbeit abzuholen.".
  • AppFunction-Aktion: Der Aufrufer identifiziert die entsprechende App zur Aufgaben verwaltung und ruft eine Funktion auf, um eine Aufgabe zu erstellen. Die Felder für Titel, Uhrzeit und Ort werden automatisch anhand der Nutzeranfrage ausgefüllt.
• Medien und Unterhaltung
  • Nutzeranfrage: "Erstelle eine neue Playlist mit den besten Jazzalben aus diesem Jahr".
  • AppFunction-Aktion: Der Aufrufer führt in einer Musik-App eine Funktion zum Erstellen von Playlists aus und übergibt Kontext wie „beste Jazzalben für 2026“ als Abfrage, um die Inhalte sofort zu generieren und abzuspielen.
• App-übergreifende Workflows
  • Nutzeranfrage: "Suche in Lisas E-Mail nach dem Nudelrezept und füge die Zutaten meiner Einkaufsliste hinzu."
  • AppFunction-Aktion: Für diese Anfrage werden Funktionen aus mehreren Apps verwendet. Zuerst ruft der Aufrufer die Suchfunktion einer E-Mail-App auf, um die Inhalte abzurufen. Anschließend werden die relevanten Zutaten extrahiert und die Funktion einer Einkaufslisten-App aufgerufen, um die Liste des Nutzers zu füllen.
• Kalender und Terminplanung
  • Nutzeranfrage: "Füge meinem Kalender für nächsten Montag um 18:00 Uhr die Geburtstagsparty von Mama hinzu.".
  • AppFunction-Aktion: Die genehmigte agentische App ruft die Funktion „Termin erstellen“ der Kalender App auf und analysiert den relevanten Kontext wie „nächsten Montag“ und „18:00 Uhr“, um den Eintrag zu erstellen, ohne dass der Nutzer den Kalender manuell öffnen muss.

Funktionsweise von AppFunctions

AppFunctions ist eine Android 16-Plattformfunktion und eine zugehörige Jetpack-Bibliothek, mit der Apps bestimmte Funktionen für Aufrufer wie Agent-Apps verfügbar machen können, damit diese auf dem Gerät darauf zugreifen und sie ausführen können.

Das folgende Diagramm veranschaulicht den typischen Ablauf, wie AppFunctions von Apps für einen Agenten freigegeben und anschließend ausgeführt werden. Agenten berücksichtigen bei der Bearbeitung von Nutzeranfragen wahrscheinlich sowohl serverseitige Remote-MCP-Tools als auch lokale AppFunctions. Der detaillierte Ablauf für die Verwendung lokaler AppFunctions ist wie folgt:

• AppFunction-Deklaration: Die Android-App ist so konzipiert, dass ihre AppFunctions wie „Notiz erstellen“ oder „Nachricht senden“ verfügbar gemacht werden.
• Schemaerstellung: Die AppFunctions Jetpack-Bibliothek generiert eine XML Schemadatei, in der alle deklarierten AppFunctions in der App aufgeführt sind. Diese Datei wird vom Android-Betriebssystem verwendet, um die verfügbaren AppFunctions zu indexieren.
• Abruf von Metadaten: Der Agent kann AppFunction-Metadaten abrufen, indem er sie abfragt.
• Auswahl und Ausführung von AppFunctions: Basierend auf Nutzeranfragen wählt der Agent die entsprechende AppFunction mit den entsprechenden Parametern aus und führt sie aus.

Die AppFunctions Jetpack-Bibliothek vereinfacht das Verfügbarmachen der Funktionen deiner App. Mit dem Annotation Processor können Entwickler die Funktionen annotieren, die sie verfügbar machen möchten. Aufrufer können diese indexierten Funktionen dann mit AppFunctionManager erkennen und aufrufen.

Bevor sie eine Funktion aufrufen, sollten Aufrufer prüfen, ob das Gerät die AppFunctions-Funktion unterstützt. Dazu versuchen sie, eine Instanz von AppFunctionManager abzurufen. Wenn die Funktion unterstützt wird, können Aufrufer mit isAppFunctionEnabled(packageName, functionId)prüfen, ob eine bestimmte Funktion in einer Ziel-App aktiviert ist. Für das Abfragen des Status von Funktionen in anderen Paketen ist die android.permission.EXECUTE_APP_FUNCTIONS permissionerforderlich.

Deine App muss nicht prüfen, ob die AppFunction-Funktion unterstützt wird. Das wird automatisch in der Jetpack-Bibliothek erledigt. Mit AppFunctionManager kann beispielsweise geprüft werden, ob die Funktion unterstützt wird.

Hier ist ein Beispiel für AppFunctions für eine Notizen-App mit Funktionen zum Erstellen, Bearbeiten und Auflisten von Notizen:

/**
 * A note app's [AppFunction]s.
 */
class NoteFunctions(
    private val noteRepository: NoteRepository
) {
    /**
     * Lists all available notes.
     *
     * @param appFunctionContext The context in which the AppFunction is executed.
     */
    @AppFunction(isDescribedByKDoc = true)
    suspend fun listNotes(appFunctionContext: AppFunctionContext): List<Note>? {
        return noteRepository.appNotes.ifEmpty { null }?.toList()
    }

    /**
     * Adds a new note to the app.
     *
     * @param appFunctionContext The context in which the AppFunction is executed.
     * @param title The title of the note.
     * @param content The note's content.
     */
    @AppFunction(isDescribedByKDoc = true)
    suspend fun createNote(
        appFunctionContext: AppFunctionContext,
        title: String,
        content: String
    ): Note {
        return noteRepository.createNote(title, content)
    }

    /**
     * Edits a single note.
     *
     * @param appFunctionContext The context in which the AppFunction is executed.
     * @param noteId The target note's ID.
     * @param title The note's title if it should be updated.
     * @param content The new content if it should be updated.
     */
    @AppFunction(isDescribedByKDoc = true)
    suspend fun editNote(
        appFunctionContext: AppFunctionContext,
        noteId: Int,
        title: String?,
        content: String?,
    ): Note? {
        return noteRepository.updateNote(noteId, title, content)
    }
}

/**
 * A note.
 */
@AppFunctionSerializable(isDescribedByKDoc = true)
data class Note(
    /** The note's identifier */
    val id: Int,
    /** The note's title */
    val title: String,
    /** The note's content */
    val content: String
)
AppFunctionsApiSnippets.kt

Häufig gestellte Fragen

In diesem Abschnitt findest du Antworten auf häufig gestellte Fragen zu AppFunctions.

F: Ich bin App-Entwickler. Kann ich AppFunctions schon heute implementieren?

A: Ja, du kannst AppFunctions in deiner App implementieren und testen. Folge dazu der Anleitung in den vorherigen Abschnitten.

F: Ich habe AppFunctions in meiner App implementiert. Warum kann mein Systemagent nicht darauf zugreifen?

A: AppFunctions sind eine experimentelle Funktion. Um die Qualität der Gesamterfahrung während dieser experimentellen Phase sorgfältig zu bewerten, können nur eine begrenzte Anzahl von Apps und Systemagenten auf die gesamte Pipeline zugreifen.

F: Ich entwickle einen Agenten. Kann ich auf AppFunctions zugreifen, die von Apps bereitgestellt werden?

A: Dein Testagent kann in einer Entwicklungsumgebung auf AppFunctions zugreifen. Während dieser experimentellen Phase können nur eine begrenzte Anzahl von Systemagenten in der Produktion auf AppFunctions zugreifen und sie ausführen.

F: Welche Systemagenten haben Zugriff auf AppFunctions?

A: Nur eine begrenzte Anzahl von Systemagenten kann auf die gesamte Pipeline zugreifen solange AppFunctions experimentell sind.

F: Wie kann ich meine App auf die allgemeine Verfügbarkeit von AppFunctions vorbereiten?

A: Überlege dir, welche Funktionen deiner App du für die agentische Automatisierung verfügbar machen möchtest. Du kannst AppFunctions in deiner App implementieren. Folge dazu der Anleitung in den vorherigen Abschnitten auf dieser Seite und prüfe, ob sie auf dem Gerät registriert sind. Rufe dazu adb shell cmd app_function list-app-functions auf.

F: Kann ich vorab auf die End-to-End-Entwicklererfahrung für Agenten zugreifen?

A: Wir führen ein Early-Access-Programm durch, um ausgewählte Apps für das Testen der End-to-End-Entwicklererfahrung zu registrieren, die erforderlich ist, um AppFunctions in der Produktion auf Android zu starten. Über dieses Registrierungsformular für das Early-Access-Programm kannst du dein Interesse an der Integration deiner AppFunctions bekunden. Wenn du dein Interesse bekundest, erhältst du NICHT automatisch Zugriff auf die vollständige Integration. Wir benachrichtigen dich per E-Mail, wenn deine App für das Early-Access-Programm ausgewählt wurde oder wenn AppFunctions öffentlich verfügbar werden.

F: Wie kann ich Feedback zu AppFunctions geben?

A: Du kannst Feedback zur API geben, indem du ein Problem meldest und dein Interesse am Early-Access-Programm bekundest.