Intelligente Android-Apps entwickeln: Mit AppFunctions in das Android-Intelligenzsystem einbinden

Willkommen zurück zu unserer Blogpost-Reihe „Intelligente Android-Apps entwickeln“. Hier zeigen wir, wie Sie eine einfache Android-App in eine personalisierte, intelligente und agentenbasierte Anwendung umwandeln. In unserem letzten Beitrag haben wir uns angesehen, wie Sie mit Firebase AI Logic cloudbasierte und hybride KI-Funktionen entwickeln können.

Traditionelle mobile Benutzeroberflächen eignen sich hervorragend für gezielte, praktische Aufgaben. Das Android-Intelligenzsystem führt ergänzende Funktionen ein, um komplexe, mehrstufige Aktionen noch einfacher zu gestalten. AppFunctions ergänzen traditionelle Benutzeroberflächen und bieten einen leistungsstarken neuen Einstiegspunkt: Ein privilegierter Agent auf dem Gerät kann im Hintergrund auf App-Funktionen zugreifen. Das kann besonders hilfreich sein, wenn Nutzer Auto fahren, zu Fuß unterwegs sind oder andere Multitasking-Aufgaben ausführen.

In diesem Artikel zeigen wir Ihnen, wie wir diese Funktionen mit Android AppFunctions in unsere Reiseplanungs-App JetPacker integriert haben. Wir erläutern die Gründe für unsere Funktionsauswahl, besprechen die speziellen Tools, die wir zur Beschleunigung der Entwicklung verwendet haben, und gehen auf den Code ein, der alles zum Laufen bringt.

KI-fähige Funktionen entwickeln: Entscheidungen treffen, die für Ihre Nutzer wichtig sind

Um auszuwählen, welche Funktionen dem Intelligenzsystem zur Verfügung gestellt werden sollen, haben wir uns Aufgaben angesehen, bei denen ein Sprach- oder Textbefehl objektiv schneller ist als das Tippen auf dem Bildschirm. In dieser nebeneinander angeordneten Bildschirmaufzeichnung sehen Sie diesen Unterschied perfekt: Links tippt ein Nutzer auf mehreren Bildschirmen, um eine Ausgabe zu protokollieren. Rechts wird dieselbe Aufgabe sofort im Hintergrund über einen privilegierten Agenten erledigt.

Unsere erste Wahl war die Ausgabenverfolgung. Das Protokollieren einer Ausgabe für einen Kaffee während einer Reise erfordert in der Regel einige Schritte: Entsperren des Smartphones, Öffnen der App, Suchen der aktiven Reise, Navigieren zum Tab „Ausgaben“, Tippen auf die Schaltfläche „Hinzufügen“, Fotografieren des Belegs und Überprüfen des Ergebnisses. Wenn die Funktionen addExpense und getExpenses als AppFunctions bereitgestellt werden, übernimmt der Systemagent die Hauptarbeit. Wenn der Nutzer sagt: „Füge meiner Reise nach Paris eine Ausgabe für einen Kaffee im Wert von fünf Euro hinzu“, sucht der Agent automatisch im Hintergrund nach der richtigen Reise-ID und fügt die Ausgabe ein. Der manuelle UI-Ablauf wird dabei vollständig übersprungen.

Außerdem haben wir die Reiseplanverwaltung priorisiert. Um herauszufinden, welche Aktivität als Nächstes auf dem Reiseplan steht, muss in der Regel durch eine dichte Zeitachse gescrollt werden. Wenn Sie dem System getItinerary und addItineraryEvent zur Verfügung stellen, kann der Nutzer einfach fragen: „Was mache ich als Nächstes in Paris?“ und erhält sofort eine Antwort.

Schließlich haben wir uns auf die freihändige Notizenerfassung konzentriert. Das Eingeben von Erinnerungen oder Notizen, während man auf einer belebten Straße unterwegs ist, ist schwierig und gefährlich. Wenn Sie eine Sprachnotizfunktion bereitstellen, kann der Nutzer sagen: „Der Flug war toll, ich habe einen wunderschönen Sonnenuntergang gesehen und gut geschlafen.“ Der privilegierte Agent transkribiert die Notiz automatisch und speichert sie mit der AppFunction „addVoiceNote“ direkt in der Reisedatenbank.

Android MCP mit AppFunctions

Die gesamte Funktion basiert auf Android MCP. Bei diesem Design fungiert die App als lokaler MCP-Server. Anstatt Remote-APIs stellen Sie die App-Funktionen direkt dem Intelligenzsystem auf dem Gerät zur Verfügung.

Android AppFunctions ist die API, die dieses Konzept umsetzt. Sie liest annotierte Kotlin-Funktionen und kompiliert sie in typsichere, in einer Sandbox ausgeführte Tooldefinitionen, die der privilegierte Agent lokal auf dem Gerät erkennen und aufrufen kann.

Im Android MCP-Modell fungiert Ihre App als lokaler MCP-Server, der strukturierte Tools bereitstellt. Die Android-Plattform dient als zentrale Toolregistrierung. Auf der MCP-Clientseite werden Agent-Apps beim Intelligenzsystem registriert, nachdem ihnen Berechtigungen mit Systemprivilegien für den Zugriff auf die Registrierung gewährt wurden.

Wenn ein Nutzer mit einem registrierten Agenten interagiert, ermittelt das LLM, ob die Anfrage von einer AppFunction verarbeitet werden kann, fragt die Metadaten der Plattform ab und führt die entsprechenden registrierten Funktionen im Hintergrund aus. Dieses lokale MCP-Client-Server-Design gibt Ihnen die vollständige Kontrolle: Sie wählen genau aus, auf welche Funktionen der Agent zugreifen kann. Die übrigen Daten Ihrer App bleiben privat.

So haben wir die Entwicklung mit Android-Skills beschleunigt

Um den Integrationsprozess zu optimieren, haben wir den AppFunctions-Entwicklungsskill genutzt. Der AppFunctions-Entwicklungsskill ist ein umfassender Entwicklungsbegleiter. Er hat uns durch den gesamten Lebenszyklus geführt: Zuordnung von Kotlin-Datenklassen zum Serialisieren von Parametern, Generieren der erforderlichen Service-Einstiegspunkte, Optimieren unserer KDoc-Dokumentation, um sicherzustellen, dass das LLM die Parametergrenzen versteht, und Einrichten automatisierter Tests mit ADB.

App-Funktionen für das Intelligenzsystem bereitstellen

Genug mit der Theorie, jetzt geht es an die Implementierung.

Konfiguration und Einrichtung von Abhängigkeiten

Zuerst fügen wir die AppFunctions-Abhängigkeiten hinzu. Eine für die API und eine für den Kotlin Symbol Processing-Compiler.

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

Benutzerdefinierte Datentypen modellieren

Jedes benutzerdefinierte Objekt, das mit dem Agenten ausgetauscht wird, muss mit @AppFunctionSerializable annotiert sein. In unserer Datei TripSerializable.kt definieren wir unser Fahrtdatenmodell:

@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>,
)

Funktionen mit der Annotation „@AppFunction“ bereitstellen

Als Nächstes hat der Skill die Kotlin-Funktionen geschrieben, die die Datenbankabfragen ausführen, und sie mit @AppFunction annotiert. Das können wir in searchTrip sehen:

/**
 * 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
}

Da AppFunctions standardmäßig im UI-Thread ausgeführt werden, wechseln wir mit withContext(Dispatchers.IO) zu einem Hintergrund-Dispatcher. Außerdem optimieren wir unsere KDoc-Kommentare, indem wir klare, imperative Verben verwenden und Parameterbeschränkungen angeben. Diese Dokumentation wird direkt in das Schema des Tools kompiliert, das der privilegierte Agent verwendet, um Parameter aufzulösen und Laufzeitfehler zu beheben.

Der Service-Einstiegspunkt und die Hilt-Integration

Um diese Funktionen beim Intelligenzsystem zu registrieren, erstellen wir eine abstrakte Basisklasse, die AppFunctionService erweitert. Wir annotieren sie mit @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...
}

Während der Kompilierung generiert KSP die endgültige konkrete Service-Unterklasse JetPackerAppFunctionService, wie mit dem Parameter serviceName deklariert. Außerdem registrieren wir app_metadata.xml im Manifest der App. Diese Datei enthält globale Betriebsregeln für die deklarierten AppFunctions von JetPacker.

AppFunctions testen und überprüfen

Nach der Implementierung sollten Sie überprüfen, ob Ihre AppFunctions registriert sind und ordnungsgemäß funktionieren.

Auf Geräten oder Emulatoren mit Android 17 oder höher können Sie ADB-Befehle über das Terminal verwenden, um Ihre Funktionen aufzulisten und aufzurufen. Wenn Sie adb shell cmd app_function list-app-functions ausführen, werden alle registrierten Funktionen für Ihr Paket angezeigt. Anschließend können Sie eine bestimmte Funktion ausführen und die Datenbankintegration testen, indem Sie adb shell cmd app_function execute-app-function ausführen und dabei eine JSON-Parameterzeichenfolge übergeben.

Anstelle dieser ADB-Befehle können Sie auch den AppFunctions-Testagenten verwenden, um Ihre Konfiguration zu prüfen, AppFunctions aufzulisten und auszuführen und sogar zu sehen, wie sich Ihre AppFunctions in einem echten Gesprächsablauf verhalten.

Zusammenfassung

Wenn Sie über App-Funktionen nachdenken, die mit AppFunctions zum Intelligenzsystem beitragen können, müssen Sie Ihre Denkweise in Bezug auf Code und Dokumentation etwas ändern. Mit AppFunctions können Sie dieses neue Interaktionsmodell für Apps verwenden, mit dem ein Agent auf App-Funktionen zugreifen kann.

Erstens ist der AppFunctions-Entwicklungsskill ein wichtiges Tool für den Lebenszyklus, mit dem Sie Funktionen entdecken und AppFunctions für Ihre Apps implementieren und optimieren können. Zweitens sind KDoc-Kommentare ein kompiliertes API-Asset. Klare Parameterbeschreibungen wirken sich direkt auf die Ausführungsgenauigkeit des Systemagenten aus. Schließlich bietet Android MCP eine lokale Ausführung, mit der Apps sicher mit KI-Agenten zusammenarbeiten können.

Wenn Sie App-Funktionen über AppFunctions beitragen, ist Ihre Anwendung für das Intelligenzsystem bereit. Teilen Sie uns mit, wie Sie Ihre Apps für das agentenbasierte Zeitalter anpassen.

Weitere Informationen

Weitere Teile dieser Blogpost-Reihe:
Teil 1: Einführung in die App und allgemeiner Überblick.
Teil 2: On-Device-Intelligenz. Detaillierte Informationen zu den GenAI-APIs von ML Kit und Gemini Nano zum Entwickeln von Funktionen, bei denen der Datenschutz im Vordergrund steht, wie z. B. Zusammenfassung von Reiseplänen, Beleganalyse und lokale Audioverarbeitung.
Teil 3: Hybride und Cloud-basierte Schlussfolgerungen. Informationen zur Verwendung von Firebase AI Logic, um LLM-Antworten mit realen Daten wie Google Maps und Webkontext zu fundieren.
Teil 4 (dieser Beitrag): System integration. Integration in das Android-Intelligenzsystem mit AppFunctions.
Teil 5 (bald verfügbar): Agentenbasierte In-App-Workflows. Erweitern Sie die App mit einem End-to-End-Buchungsassistenten, der auf A2UI und ADK basiert.

Möchten Sie mehr über die Android-Entwicklung erfahren? Folgen Sie Android Developers auf YouTube oder LinkedIn.

Für alle Code-Snippets in diesem Blogpost gilt der folgende Urheberrechtshinweis:

Copyright 2026 Google LLC.
SPDX-License-Identifier: Apache-2.0