Übersicht über AppFunctions

Mit AppFunctions können Sie bestimmte Funktionen Ihrer Android-App freigeben, die vom System und verschiedenen KI-Agenten und ‑Assistenten erkannt und aufgerufen werden können. Durch das Definieren dieser Funktionen kann Ihre App dem Android-Betriebssystem Dienste, Daten und Aktionen zur Verfügung stellen, sodass Nutzer Aufgaben über KI-Agents und Interaktionen auf Systemebene erledigen können.

AppFunctions sind das mobile Äquivalent von Tools im Model Context Protocol (MCP). Während MCP traditionell standardisiert, wie KI-Agents eine Verbindung zu serverseitigen Tools herstellen, bieten AppFunctions denselben Mechanismus für Android-Apps. So können Sie die Funktionen Ihrer App als orchestrierbare „Tools“ verfügbar machen, die von autorisierten Apps (Aufrufern) erkannt und ausgeführt werden können, um Nutzeranfragen zu erfüllen. Anrufer müssen die Berechtigung EXECUTE_APP_FUNCTIONS haben, um AppFunctions zu erkennen und auszuführen. Dazu können Agents, Apps und KI-Assistenten wie Gemini gehören.

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 Sie die Funktionen Ihrer App verfügbar machen, können Nutzer komplexe Aufgaben mithilfe natürlicher Sprache erledigen. Oft ist dann keine manuelle Navigation in Ihrer Benutzeroberfläche mehr erforderlich.

Die folgenden Szenarien veranschaulichen, wie AppFunctions in verschiedenen App-Kategorien eingesetzt werden können:

  • Aufgabenverwaltung und Produktivität
    • Nutzeranfrage: „Erinnere mich daran, heute um 17:00 Uhr mein Paket auf der Arbeit abzuholen.“
    • AppFunction-Aktion: Der Aufrufer identifiziert die relevante App für die Aufgabenverwaltung und ruft eine Funktion auf, um eine Aufgabe zu erstellen. Dabei werden die Felder für Titel, Uhrzeit und Ort automatisch anhand des Prompts des Nutzers ausgefüllt.
  • Medien und Unterhaltung
    • Nutzeranfrage: Erstelle eine neue Playlist mit den besten Jazzalben dieses Jahres.
    • AppFunction-Aktion: Der Aufrufer führt eine Funktion zum Erstellen von Playlists in einer Musik-App aus und übergibt Kontext wie „Top-Jazzalben für 2026“ als Anfrage, um die Inhalte sofort zu generieren und zu starten.
  • App-übergreifende Workflows
    • Nutzeranfrage: Suche in Lisas E-Mail nach dem Nudelrezept und füge die Zutaten meiner Einkaufsliste hinzu.
    • AppFunction-Aktion: Bei dieser Anfrage werden Funktionen aus mehreren Apps verwendet. Zuerst ruft der Anrufer die Inhalte über die Suchfunktion einer E‑Mail-App ab. 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 meiner Mutter hinzu.
    • AppFunction-Aktion: Die genehmigte Agent-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 Anrufer wie Agenten-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 Agent freigegeben und anschließend ausgeführt werden. KI-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.
  • Metadaten abrufen: Der Agent kann AppFunction-Metadaten abrufen, indem er sie abfragt.
  • AppFunction-Auswahl und -Ausführung: Basierend auf Nutzer-Prompts wählt der Agent die passende AppFunction mit den entsprechenden Parametern aus und führt sie aus.
Diagramm, das den typischen Ablauf von AppFunctions von der App-Präsentation bis zur Agent-Ausführung zeigt.
Abbildung 1: Der typische Ablauf, wie AppFunctions von einem Agenten bereitgestellt und anschließend ausgeführt werden.

Die AppFunctions Jetpack-Bibliothek vereinfacht das Bereitstellen der Funktionen Ihrer App. Mit dem Annotationsprozessor annotieren Entwickler die Funktionen, die sie verfügbar machen möchten. Anrufer können diese indexierten Funktionen dann mit AppFunctionManager ermitteln und aufrufen.

Bevor sie eine Funktion aufrufen, sollten Aufrufer prüfen, ob das Gerät die Funktion „AppFunctions“ unterstützt, indem sie versuchen, eine Instanz von AppFunctionManager abzurufen. Wenn die Funktion unterstützt wird, können Anrufer mit isAppFunctionEnabled(packageName, functionId) prüfen, ob eine bestimmte Funktion in einer Ziel-App aktiviert ist. Wenn Sie den Status von Funktionen in anderen Paketen abfragen möchten, benötigen Sie die android.permission.EXECUTE_APP_FUNCTIONS permission.

Ihre App muss nicht prüfen, ob die AppFunction-Funktion unterstützt wird. Das wird automatisch in der Jetpack-Bibliothek erledigt. Mit AppFunctionManager lässt sich beispielsweise prüfen, ob das Feature 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

Im folgenden Abschnitt finden Sie Antworten auf häufig gestellte Fragen zu AppFunctions.

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

Ja, es ist möglich, AppFunctions in Ihrer App zu implementieren und zu testen. Folgen Sie dazu der Anleitung in den vorherigen Abschnitten.

Ich habe AppFunctions in meiner App implementiert. Warum kann mein System-Agent nicht darauf zugreifen?

AppFunctions sind eine experimentelle Funktion. Um die Qualität der Gesamtnutzererfahrung während dieser Testphase sorgfältig zu bewerten, kann nur eine begrenzte Anzahl von Apps und System-Agents auf die gesamte Pipeline zugreifen.

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

Überlegen Sie, welche Funktionen Ihrer App Sie für die agentenbasierte Automatisierung zur Verfügung stellen möchten. Sie können AppFunctions in Ihrer App implementieren. Folgen Sie dazu den Schritten in den vorherigen Abschnitten auf dieser Seite und prüfen Sie, ob sie auf dem Gerät registriert sind, indem Sie adb shell cmd app_function list-app-functions aufrufen.

Kann ich Vorabzugriff auf die End-to-End-Entwicklerfunktionen für agentische KI erhalten?

Wir führen ein Early Access-Programm (EAP) durch, um ausgewählte Apps für die Einführung von AppFunctions in der Produktionsumgebung auf Android vorzubereiten. Dabei wird die erforderliche End-to-End-Entwicklerumgebung getestet. Wenn Sie Interesse an der Integration Ihrer AppFunctions haben, können Sie sich über dieses Formular für das EAP registrieren. Wenn Sie sich registrieren, erhalten Sie NICHT automatisch Zugriff auf die vollständige Integration. Wir benachrichtigen Sie per E-Mail, wenn Ihre App für das EAP ausgewählt wird oder wenn AppFunctions öffentlich verfügbar werden.

Wie kann ich Feedback zu AppFunctions geben?

Sie können Feedback zur API geben, indem Sie ein Problem melden und Ihr Interesse am Early-Access-Programm über das entsprechende Formular bekunden.