Anleitungen

Intelligente Android-Apps entwickeln: Mit AppFunctions in das intelligente System von Android einbinden

Lesezeit: 6 Minuten
Profil von Ben Weiss ansehen
Ben Weiss Developer Relations Engineer

Willkommen zurück bei der Blogpost-Reihe Intelligente Android-Apps entwickeln. Hier zeigen wir Ihnen, wie Sie eine einfache Android-App in eine personalisierte, intelligente und agentische Anwendung verwandeln. In unserem vorherigen Beitrag haben wir uns angesehen, wie Sie mit Firebase AI Logic cloudbasierte und hybride KI-Funktionen erstellen können.

Herkömmliche mobile Benutzeroberflächen eignen sich hervorragend für fokussierte, praktische Aufgaben. Das Android-Intelligenzsystem führt ergänzende Funktionen ein, um komplexe, mehrstufige Aktionen noch einfacher zu machen. AppFunctions ergänzen herkömmliche 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 gerade Auto fahren, zu Fuß unterwegs sind oder andere Dinge tun.

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 die Auswahl der Funktionen, besprechen die speziellen Tools, die wir zur Beschleunigung der Entwicklung verwendet haben, und gehen auf den Code ein, der alles möglich macht.

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

Bei der Auswahl der Funktionen, die dem KI-System zur Verfügung gestellt werden sollen, haben wir nach Aufgaben gesucht, bei denen ein Sprach- oder Textbefehl objektiv schneller ist als das Tippen auf dem Display. In dieser Bildschirmaufzeichnung ist der Unterschied deutlich zu sehen: Links tippt ein Nutzer auf mehrere Bildschirme, um eine Ausgabe zu erfassen. Rechts wird dieselbe Aufgabe sofort im Hintergrund über einen privilegierten Agenten erledigt.

Unsere erste Wahl war die Ausgabenverfolgung. Wenn Sie während einer Reise die Ausgaben für einen Kaffee erfassen möchten, sind normalerweise viele Schritte erforderlich: Smartphone entsperren, App öffnen, aktive Reise suchen, zum Tab „Ausgaben“ wechseln, auf die Schaltfläche „Hinzufügen“ tippen, ein Foto des Belegs machen und das Ergebnis prüfen. Wenn Sie die Funktionen addExpense und getExpenses als AppFunctions bereitstellen, übernimmt der System-Agent die meiste Arbeit. Wenn der Nutzer sagt: „Füge meiner Paris-Reise eine Ausgabe von 5 € für Kaffee hinzu“, sucht der KI-Agent im Hintergrund automatisch 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 Verwaltung von Reiseplänen priorisiert. Wenn Sie herausfinden möchten, welche Aktivität als Nächstes auf einem vollen Reiseplan steht, müssen Sie normalerweise durch eine dichte Zeitachse scrollen. Wenn der Nutzer dem System getItinerary und addItineraryEvent zur Verfügung stellt, kann er einfach fragen: „Was mache ich als Nächstes in Paris?“ und erhält sofort eine Antwort.

Schließlich haben wir uns auf das Erstellen von Notizen per Sprachbefehl konzentriert. Erinnerungen oder Notizen einzutippen, während man eine belebte Straße entlanggeht, ist schwierig und unsicher. Wenn eine Sprachnotizfunktion verfügbar ist, kann der Nutzer sagen: „Der Flug war fantastisch, ich habe einen wunderschönen Sonnenuntergang gesehen und konnte gut schlafen.“ Der privilegierte Agent transkribiert die Sprachnotiz dann automatisch und speichert sie mit der AppFunction „addVoiceNote“ direkt in der Reisedatenbank.

Android MCP mit AppFunctions

Diese gesamte Funktion basiert auf der Android MCP. Bei diesem Design fungiert die App als lokaler MCP-Server. Anstatt Remote-APIs zu verwenden, stellen Sie Ihre App-Funktionen direkt dem On-Device-Intelligence-System 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 finden und aufrufen kann.

Android MCP diagram.png
Diagramm, das zeigt, wie unsere Apps, die Android-Plattform und System-Agents AppFunctions koordinieren.

Im Android-MCP-Modell fungiert Ihre App als lokaler MCP-Server, der strukturierte Tools bereitstellt, während die Android-Plattform als zentrale Tool-Registry dient. Auf der MCP-Clientseite werden Agent-Anwendungen beim KI-System registriert, nachdem ihnen systemprivilegierte Berechtigungen für den Zugriff auf die Registry gewährt wurden.

Wenn ein Nutzer mit einem registrierten Agenten interagiert, bestimmt 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 volle Kontrolle: Sie können genau festlegen, auf welche Funktionen der KI-Agent zugreifen darf, während die restlichen Daten Ihrer App privat bleiben.

Wie wir die Entwicklung mit Android-Kenntnissen beschleunigt haben

Um den Integrationsprozess zu optimieren, haben wir die AppFunctions-Entwicklungsfunktion genutzt. Der AppFunctions-Entwicklungsskill ist ein umfassender Entwicklungsbegleiter. Es hat uns durch den gesamten Lebenszyklus geführt: Zuordnung von Kotlin-Datenklassen zur Serialisierung von Parametern, Generierung der erforderlichen Service-Einstiegspunkte, Verfeinerung unserer KDoc-Dokumentation, damit das LLM die Parametergrenzen versteht, und Einrichtung automatisierter Tests mit ADB.

Bereitstellung von App-Funktionen für das KI-System

Genug der Theorie, kommen wir zur Implementierung.

Konfiguration und Abhängigkeitseinrichtung

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

Alle benutzerdefinierten Objekte, die mit dem Agenten ausgetauscht werden, müssen mit @AppFunctionSerializable annotiert werden. In der Datei TripSerializable.kt definieren wir das Datenmodell für die Fahrt:

@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. Wir können uns das in searchTrip ansehen:

/**
 * 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, verwenden wir withContext(Dispatchers.IO), um zu einem Hintergrund-Dispatcher zu wechseln. Außerdem verfeinern wir unser KDoc, um klare, imperative Verben zu verwenden und Parameterbeschränkungen anzugeben. Diese Dokumentation wird direkt in das Schema des Tools kompiliert, das der privilegierte Agent verwendet, um Parameter aufzulösen und Laufzeitfehler zu beheben.

Der Diensteinstiegspunkt und die Hilt-Integration

Um diese Funktionen beim KI-System 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 Dienstunterklasse 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 prüfen

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

Wenn Sie Geräte oder Emulatoren mit Android 17 oder höher verwenden, können Sie ADB-Befehle über Ihr 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 ihre Datenbankintegration testen, indem Sie adb shell cmd app_function execute-app-function ausführen und einen JSON-Rohparameterstring übergeben.

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

Zusammenfassung

Wenn wir über App-Funktionen nachdenken, die mithilfe von AppFunctions zum KI-System beitragen können, müssen wir unsere Denkweise in Bezug auf Code und Dokumentation etwas ändern. Mit AppFunctions können Sie dieses neue Interaktionsmodell für Apps verwenden, bei dem ein KI-Agent auf App-Funktionen zugreift.

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

Wenn Sie App-Funktionen über AppFunctions bereitstellen, ist Ihre Anwendung für das KI-System bereit. Teilen Sie uns mit, wie Sie Ihre Apps für das Zeitalter der agentischen KI anpassen.

Weitere Informationen

Weitere Teile dieser Blogpost-Reihe:
Teil 1: Einführung in die App und allgemeiner Überblick
Teil 2: On-Device-Intelligence In diesem Teil geht es um die GenAI APIs von ML Kit und Gemini Nano, mit denen Sie datenschutzorientierte Funktionen wie die Zusammenfassung von Reiseplänen, das Parsen von Belegen und die lokale Audioverarbeitung erstellen können.
Teil 3: Hybrid- und Cloud-Reasoning. Hier erfahren Sie, wie Sie mit Firebase AI Logic LLM-Antworten mit realen Daten wie Google Maps und Webinhalten fundieren können.
Teil 4 (dieser Beitrag): System integration. Integration in das Android-Intelligenzsystem mit AppFunctions.
Teil 5 (demnächst verfügbar): Agentische Workflows in der App. Erweitern Sie die Anwendung um einen End-to-End-Buchungsassistenten, der auf A2UI und ADK basiert.

Möchten Sie mehr über die Android-Entwicklung erfahren? Folgt Android-Entwickler 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
Verfasst von:
Weiterlesen