Tworzenie inteligentnych aplikacji na Androida: integracja z systemem inteligentnym Androida za pomocą AppFunctions

Witamy z powrotem w serii postów na blogu "Tworzenie inteligentnych aplikacji na Androida", w której przekształcamy podstawową aplikację na Androida w spersonalizowane, inteligentne i oparte na agentach rozwiązanie. W naszym poprzednim poście pokazaliśmy, jak wykorzystać Firebase AI Logic do tworzenia funkcji AI hostowanych w chmurze i hybrydowych.

Tradycyjne interfejsy mobilne doskonale sprawdzają się w przypadku zadań wymagających skupienia i interakcji, a system inteligentny Androida wprowadza dodatkowe funkcje, które ułatwiają wykonywanie złożonych, wieloetapowych działań. Dzięki uzupełnieniu tradycyjnych interfejsów użytkownika AppFunctions zapewniają nowy, skuteczny punkt wejścia: uprzywilejowany agent na urządzeniu może uzyskiwać dostęp do funkcji aplikacji w tle. Może to być szczególnie przydatne, gdy użytkownicy prowadzą samochód, idą lub wykonują inne czynności jednocześnie.

W tym artykule pokażemy, jak zaprojektowaliśmy i zintegrowaliśmy te funkcje z naszą aplikacją do planowania podróży JetPacker za pomocą Android AppFunctions. Omówimy uzasadnienie naszych wyborów funkcji, narzędzia specjalistyczne, których użyliśmy do przyspieszenia procesu tworzenia, oraz kod, który sprawia, że wszystko działa.

Projektowanie funkcji opartych na AI: podejmowanie decyzji, które mają znaczenie dla użytkowników

Aby wybrać funkcje, które mają być dostępne w systemie inteligentnym, szukaliśmy zadań, w których polecenie głosowe lub tekstowe jest obiektywnie szybsze niż klikanie na ekranach. Na tym nagraniu ekranu obok siebie widać ten kontrast: po lewej stronie użytkownik klika na wielu ekranach, aby zarejestrować wydatek, a po prawej stronie to samo zadanie jest wykonywane natychmiast w tle przez uprzywilejowanego agenta.

Naszym pierwszym wyborem było śledzenie wydatków. Zarejestrowanie wydatku na kawę podczas podróży zwykle wymaga kilku kliknięć – odblokowania telefonu, otwarcia aplikacji, znalezienia aktywnej podróży, przejścia do karty wydatków, kliknięcia przycisku dodawania, zrobienia zdjęcia paragonu i sprawdzenia wyniku. Dzięki udostępnieniu funkcji addExpense i getExpenses jako AppFunctions agent systemowy zajmuje się trudniejszymi zadaniami. Gdy użytkownik powie „Dodaj wydatek na kawę w Paryżu w wysokości 5 dolarów”, agent automatycznie wyszuka w tle prawidłowy identyfikator podróży i doda wydatek, pomijając ręczny przepływ interfejsu.

Priorytetem było też zarządzanie planem podróży. Znalezienie następnej aktywności w napiętym planie podróży zwykle wymaga przewijania gęstego widoku osi czasu. Dzięki udostępnieniu systemowi funkcji getItinerary i addItineraryEvent użytkownik może po prostu zapytać „Co będę robić dalej w Paryżu?” i od razu otrzymać odpowiedź.

Na koniec skupiliśmy się na rejestrowaniu notatek bez użycia rąk. Wpisywanie przypomnień lub notatek podczas chodzenia po ruchliwej ulicy jest trudne i niebezpieczne. Udostępnienie funkcji notatek głosowych pozwala użytkownikowi powiedzieć „Lot był niesamowity, widziałem piękny zachód słońca i udało mi się dobrze wyspać”, a uprzywilejowany agent automatycznie transkrybuje i zapisuje notatkę bezpośrednio w bazie danych podróży za pomocą AppFunction addVoiceNote.

Android MCP zasilany przez AppFunctions

Całe to rozwiązanie jest oparte na Android MCP. W tym projekcie aplikacja działa jako lokalny serwer MCP. Zamiast zdalnych interfejsów API udostępniasz funkcje aplikacji bezpośrednio systemowi inteligentnemu na urządzeniu.

Android AppFunctions to interfejs API, który realizuje tę koncepcję. Odczytuje on funkcje Kotlin z adnotacjami i kompiluje je do bezpiecznych typowo, odizolowanych definicji narzędzi, które uprzywilejowany agent może wykrywać i wywoływać lokalnie na urządzeniu.

W modelu Android MCP Twoja aplikacja działa jako lokalny serwer MCP, który udostępnia narzędzia strukturalne, a platforma Androida pełni funkcję centralnego rejestru narzędzi. Po stronie klienta MCP aplikacje agentów są rejestrowane w systemie inteligentnym po przyznaniu im uprawnień systemowych do uzyskiwania dostępu do rejestru.

Gdy użytkownik wchodzi w interakcję z zarejestrowanym agentem, jego model LLM określa, czy żądanie może zostać obsłużone przez AppFunction, wysyła zapytanie do metadanych platformy i wykonuje odpowiednie zarejestrowane funkcje w tle. Ten lokalny projekt klient-serwer MCP daje Ci pełną kontrolę: możesz dokładnie wybrać, które funkcje są dostępne dla agenta, a reszta danych aplikacji pozostaje prywatna.

Jak przyspieszyliśmy proces tworzenia dzięki umiejętnościom Androida

Aby usprawnić proces integracji, wykorzystaliśmy umiejętność tworzenia AppFunctions. Umiejętność tworzenia AppFunctions to kompletny towarzysz programowania. Przeprowadził nas przez cały cykl życia: mapowanie klas danych Kotlin w celu serializacji parametrów, generowanie niezbędnych punktów wejścia Service, dopracowywanie dokumentacji KDoc, aby model LLM rozumiał granice parametrów, oraz konfigurowanie automatycznych testów za pomocą ADB.

Udostępnianie funkcji aplikacji systemowi inteligentnemu

Dość teorii, przejdźmy do implementacji.

Konfiguracja i konfiguracja zależności

Zaczynamy od dodania zależności AppFunctions. Jedna dla interfejsu API, a druga dla kompilatora Kotlin Symbol Processing.

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

Modelowanie niestandardowych typów danych

Każdy obiekt niestandardowy wymieniany z agentem musi mieć adnotację @AppFunctionSerializable. W pliku TripSerializable.kt definiujemy model danych o podróży:

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

Udostępnianie funkcji za pomocą adnotacji @AppFunction

Następnie umiejętność napisała funkcje Kotlin, które wykonują zapytania do bazy danych, i dodała do nich adnotację @AppFunction. Możemy to zobaczyć w searchTrip:

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

Ponieważ AppFunctions domyślnie działają w wątku UI, używamy withContext(Dispatchers.IO), aby przełączyć się na dyspozytor w tle. Dodatkowo dopracowujemy KDoc, aby używać jasnych, imperatywnych czasowników i określać ograniczenia parametrów. Ta dokumentacja jest kompilowana bezpośrednio do schematu narzędzia, którego uprzywilejowany agent używa do rozwiązywania parametrów i obsługi błędów wykonania.

Punkt wejścia usługi i integracja Hilt

Aby zarejestrować te funkcje w systemie inteligentnym, tworzymy abstrakcyjną klasę bazową, która rozszerza AppFunctionService. Dodajemy do niej adnotację @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...
}

Podczas kompilacji KSP generuje końcową konkretną podklasę usługi, JetPackerAppFunctionService, zgodnie z deklaracją w parametrze serviceName. W manifeście aplikacji rejestrujemy też app_metadata.xml. Ten plik zawiera globalne reguły operacyjne dla zadeklarowanych AppFunctions JetPacker.

Testowanie i weryfikowanie AppFunctions

Po implementacji należy sprawdzić, czy AppFunctions są zarejestrowane i działają prawidłowo.

Na urządzeniach lub emulatorach z Androidem 17 lub nowszym możesz używać poleceń ADB z terminala, aby wyświetlać i wywoływać funkcje. Uruchomienie adb shell cmd app_function list-app-functions wyświetla wszystkie zarejestrowane funkcje dla Twojego pakietu. Następnie możesz wykonać konkretną funkcję i przetestować jej integrację z bazą danych, uruchamiając adb shell cmd app_function execute-app-function i przekazując ciąg parametrów JSON.

Zamiast tych poleceń ADB możesz też użyć agenta testującego AppFunctions, aby sprawdzić konfigurację, wyświetlić i wykonać AppFunctions, a nawet zobaczyć, jak działają one w rzeczywistym przepływie rozmowy.

Podsumowanie

Zastanawiając się nad funkcjami aplikacji, które można udostępnić systemowi inteligentnemu za pomocą AppFunctions, trzeba nieco zmienić sposób myślenia o kodzie i dokumentacji. AppFunctions umożliwiają korzystanie z tego nowego modelu interakcji z aplikacjami, który pozwala agentowi uzyskiwać dostęp do funkcji aplikacji.

Po pierwsze, umiejętność tworzenia AppFunctions jest niezbędnym narzędziem cyklu życia, które pomaga odkrywać funkcje, implementować i udoskonalać AppFunctions w aplikacjach. Po drugie, komentarze KDoc są skompilowanym zasobem interfejsu API. Jasne opisy parametrów mają bezpośredni wpływ na dokładność wykonywania zadań przez agenta systemowego. Po trzecie, Android MCP zapewnia wykonywanie zadań lokalnie, co umożliwia aplikacjom bezpieczną współpracę z agentami AI.

Udostępnianie funkcji aplikacji za pomocą AppFunctions sprawia, że aplikacja jest gotowa do współpracy z systemem inteligentnym. Daj nam znać, jak dostosowujesz swoje aplikacje do ery agentów.

Więcej informacji

Zapoznaj się z innymi częściami tej serii postów na blogu:
Część 1: wprowadzenie do aplikacji i ogólny przegląd.
Część 2: inteligencja na urządzeniu. Szczegółowe informacje o interfejsach GenAI API w ML Kit i Gemini Nano, które umożliwiają tworzenie funkcji z myślą o prywatności, takich jak podsumowywanie planu podróży, analizowanie paragonów i lokalne przetwarzanie dźwięku.
Część 3: wnioskowanie hybrydowe i w chmurze. Dowiedz się, jak używać Firebase AI Logic do grounding odpowiedzi LLM z użyciem danych z rzeczywistego świata, takich jak Mapy Google i kontekst internetowy.
Część 4 (ten post): Integracja z systemem. Integracja z systemem inteligentnym Androida za pomocą AppFunctions.
Część 5 (wkrótce): przepływy pracy agentów w aplikacji. Rozszerz aplikację o kompleksowego asystenta rezerwacji opartego na A2UI i ADK.

Chcesz dowiedzieć się więcej o tworzeniu aplikacji na Androida? Obserwuj Android Developers na YouTube lub LinkedIn.

Wszystkie fragmenty kodu w tym poście na blogu są objęte tym powiadomieniem o prawach autorskich:

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