Ü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 ermöglichen Sie Ihrer App, dem Android-Betriebssystem Dienste, Daten und Aktionen bereitzustellen. So können Nutzer Aufgaben über KI-Agents und Interaktionen auf Systemebene erledigen.

AppFunctions sind das mobile Äquivalent von Tools im Model Context Protocol (MCP). Während MCP traditionell standardisiert, wie KI-Agenten 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. Aufrufer 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. Die Felder für Titel, Uhrzeit und Ort werden automatisch anhand des Nutzer-Prompts 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 von Mama hinzu.
  • AppFunction-Aktion: Die genehmigte agentenbasierte 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 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. 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.
• Abrufen von Metadaten: 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.

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. Aufrufer können diese indexierten Funktionen dann mit AppFunctionManager ermitteln und aufrufen.

Ihre 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.

class NoteFunctions(
  private val noteRepository: NoteRepository
) {
    /**
     * A note.
     *
     * @param id The note's ID.
     * @param title The note's title.
     * @param content The note's content.
     */
    @AppFunctionSerializable(isDescribedByKDoc = true)
    data class Note(val id: Int, val title: String, val content: String)

    /**
     * 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 if (noteRepository.appNotes.isEmpty()) null else viewModel.appNotes
    }

    /**
     * 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 new 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: String,
      title: String?,
      content: String,
    ): Note? {
        return noteRepository.updateNote(noteId, title, content)
    }
}