Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Gemini Live API

W przypadku aplikacji, które wymagają obsługi głosowej w czasie rzeczywistym i z krótkim czasem oczekiwania, takich jak chatboty czy interakcje z agentami, Gemini Live API zapewnia zoptymalizowany sposób przesyłania strumieniowego danych wejściowych i wyjściowych modelu Gemini. Dzięki Firebase AI Logic możesz wywoływać Gemini Live API bezpośrednio z aplikacji na Androida bez konieczności integracji z backendem. Z tego przewodnika dowiesz się, jak używać Gemini Live API w aplikacji na Androida z Firebase AI Logic.

Rozpocznij

Zanim zaczniesz, upewnij się, że Twoja aplikacja jest kierowana na poziom interfejsu API 23 lub nowszy.

Jeśli jeszcze tego nie zrobisz, skonfiguruj projekt Firebase i połącz aplikację z Firebase. Więcej informacji znajdziesz w dokumentacji Firebase AI Logic.

Konfigurowanie projektu na Androida

Dodaj bibliotekę Firebase AI Logic i zależności Sprawdzania aplikacji do pliku na poziomie aplikacji build.gradle.kts lub build.gradle. Do zarządzania wersjami bibliotek używaj Firebase Android BoM.

dependencies {
  // Import the Firebase BoM
  implementation(platform("com.google.firebase:firebase-bom:34.15.0"))

  // Add the dependencies for the Firebase AI Logic and App Check libraries
  // When using the BoM, you don't specify versions in Firebase library dependencies
  implementation("com.google.firebase:firebase-ai")
  implementation("com.google.firebase:firebase-appcheck-debug")
}

Po dodaniu zależności zsynchronizuj projekt na Androida z Gradle.

Konfigurowanie dostawcy debugowania Sprawdzania aplikacji na potrzeby programowania lokalnego

Od początku lipca 2026 r. w ramach procesu konfiguracji z przewodnikiem dla AI Logic w konsoli Firebase Sprawdzanie aplikacji Firebase będzie automatycznie wymuszane w celu ochrony Gemini API. W przypadku programowania lokalnego musisz skonfigurować dostawcę debugowania Sprawdzania aplikacji, aby pominąć atestowanie, ale nadal wymuszać Sprawdzanie aplikacji.

W kompilacji debugowania skonfiguruj Sprawdzanie aplikacji tak, aby używała fabryki dostawcy debugowania:

Kotlin

Firebase.initialize(context = this)
Firebase.appCheck.installAppCheckProviderFactory(
    DebugAppCheckProviderFactory.getInstance(),
)

Java

FirebaseApp.initializeApp(/*context=*/ this);
FirebaseAppCheck firebaseAppCheck = FirebaseAppCheck.getInstance();
firebaseAppCheck.installAppCheckProviderFactory(
        DebugAppCheckProviderFactory.getInstance());

Uzyskaj token debugowania:
1. Uruchom aplikację w emulatorze lub na urządzeniu testowym.
2. W dziennikach poszukaj tokena debugowania Sprawdzania aplikacji. Przykład:
```
D DebugAppCheckProvider: Enter this debug secret into the allow list
in the Firebase Console for your project: 123a4567-b89c-12d3-e456-789012345678
```
3. Skopiuj token (np. 123a4567-b89c-12d3-e456-789012345678).
Zarejestruj token debugowania w Sprawdzaniu aplikacji:
1. W konsoli Firebase otwórz kartę Zabezpieczenia > Sprawdzanie aplikacji > Aplikacje.
2. Znajdź swoją aplikację, kliknij menu przepełnienia (), a następnie wybierz Zarządzaj tokenami debugowania.
3. Postępuj zgodnie z instrukcjami wyświetlanymi na ekranie, aby zarejestrować token debugowania.

Więcej informacji o dostawcy debugowania (w tym o tym, jak uzyskać nowy token debugowania) znajdziesz w oficjalnej dokumentacji Sprawdzania aplikacji.

Integracja Firebase AI Logic i inicjowanie modelu generatywnego

Dodaj uprawnienie RECORD_AUDIO do pliku AndroidManifest.xml aplikacji:

<uses-permission android:name="android.permission.RECORD_AUDIO" />

Zainicjuj usługę backendu Gemini Developer API i uzyskaj dostęp do LiveModel. Użyj modelu, który obsługuje Live API, np. gemini-2.5-flash-native-audio-preview-12-2025. Dostępne modele Live API znajdziesz w dokumentacji Firebase.

Aby określić głos, ustaw nazwę głosu w obiekcie speechConfig w ramach konfiguracji modelu. Jeśli nie określisz głosu, domyślnie używany jest głos Puck.

Kotlin

// Initialize the `LiveModel`
val model = Firebase.ai(backend = GenerativeBackend.googleAI()).liveModel(
    modelName = "gemini-2.5-flash-native-audio-preview-12-2025",
    generationConfig = liveGenerationConfig {
        responseModality = ResponseModality.AUDIO
        speechConfig = SpeechConfig(voice = Voice("FENRIR"))
    }
)GeminiLive.kt

Java

// Initialize the `LiveModel`
LiveGenerativeModel model = FirebaseAI
       .getInstance(GenerativeBackend.googleAI())
       .liveModel(
              "gemini-2.5-flash-native-audio-preview-12-2025",
              new LiveGenerationConfig.Builder()
                     .setResponseModality(ResponseModality.AUDIO)
                     .setSpeechConfig(new SpeechConfig(new Voice("FENRIR"))
              ).build(),
        null,
        null
);

Opcjonalnie możesz zdefiniować personę lub rolę, jaką ma odgrywać model, ustawiając instrukcję systemową:

Kotlin

val systemInstruction = content {
    text("You are a helpful assistant, you main role is [...]")
}

val model = Firebase.ai(backend = GenerativeBackend.googleAI()).liveModel(
    modelName = "gemini-2.5-flash-native-audio-preview-12-2025",
    generationConfig = liveGenerationConfig {
        responseModality = ResponseModality.AUDIO
        speechConfig = SpeechConfig(voice = Voice("FENRIR"))
    },
    systemInstruction = systemInstruction,
)GeminiLive.kt

Java

Content systemInstruction = new Content.Builder()
       .addText("You are a helpful assistant, you main role is [...]")
       .build();

LiveGenerativeModel model = FirebaseAI
       .getInstance(GenerativeBackend.googleAI())
       .liveModel(
              "gemini-2.5-flash-native-audio-preview-12-2025",
              new LiveGenerationConfig.Builder()
                     .setResponseModality(ResponseModality.AUDIO)
                     .setSpeechConfig(new SpeechConfig(new Voice("FENRIR"))
              ).build(),
        tools, // null if you don't want to use function calling
        systemInstruction
);

Możesz dodatkowo dostosować rozmowę z modelem, używając instrukcji systemowych, aby podać kontekst specyficzny dla Twojej aplikacji (np. historię aktywności użytkownika w aplikacji).

Inicjowanie sesji Live API

Po utworzeniu instancji LiveModel wywołaj model.connect(), aby utworzyć obiekt LiveSession i nawiązać trwałe połączenie z modelem za pomocą strumieniowania z krótkim czasem oczekiwania. LiveSession umożliwia interakcję z modelem przez rozpoczęcie i zatrzymanie sesji głosowej oraz wysyłanie i odbieranie tekstu.

Następnie możesz wywołać startAudioConversation(), aby rozpocząć rozmowę z modelem:

Kotlin

val session = model.connect()
session.startAudioConversation()GeminiLive.kt

Java

LiveModelFutures model = LiveModelFutures.from(liveModel);
ListenableFuture<LiveSession> sessionFuture = model.connect();

Futures.addCallback(sessionFuture, new FutureCallback<LiveSession>() {
    @Override
    public void onSuccess(LiveSession ses) {
        LiveSessionFutures session = LiveSessionFutures.from(ses);
        session.startAudioConversation();
    }
    @Override
    public void onFailure(Throwable t) {
        // Handle exceptions
    }
}, executor);

Pamiętaj, że model nie obsługuje przerw w rozmowach. Ponadto Live API jest dwukierunkowe, więc do wysyłania i odbierania treści używasz tego samego połączenia.

Możesz też użyć Gemini Live API do generowania dźwięku z różnych danych wejściowych:

Wysyłanie tekstu i dźwięku.
Wysyłanie danych wideo (zapoznaj się z aplikacją Firebase w wersji demonstracyjnej).

Wywoływanie funkcji: łączenie Gemini Live API z aplikacją

Możesz też włączyć model, aby bezpośrednio wchodził w interakcje z logiką aplikacji za pomocą wywoływania funkcji.

Wywoływanie funkcji (lub wywoływanie narzędzi) to funkcja implementacji generatywnej AI, która umożliwia modelowi wywoływanie funkcji z własnej inicjatywy w celu wykonywania działań. Jeśli funkcja ma dane wyjściowe, model dodaje je do kontekstu i używa ich do kolejnych generacji.

Diagram ilustrujący, jak interfejs Gemini Live API umożliwia interpretację promptu użytkownika przez model, co wywołuje predefiniowaną funkcję z odpowiednimi argumentami w aplikacji na Androida, która następnie otrzymuje od modelu odpowiedź z potwierdzeniem. — **Rysunek 1:** schemat ilustrujący, jak Gemini Live API umożliwia interpretowanie prompta użytkownika przez model, co powoduje wywołanie predefiniowanej funkcji z odpowiednimi argumentami w aplikacji na Androida, która następnie otrzymuje od modelu odpowiedź potwierdzającą.

Aby zaimplementować wywoływanie funkcji w aplikacji, zacznij od utworzenia obiektu FunctionDeclaration dla każdej funkcji, którą chcesz udostępnić modelowi.

Aby na przykład udostępnić Gemini funkcję addList, która dodaje ciąg znaków do listy ciągów znaków, zacznij od utworzenia zmiennej FunctionDeclaration z nazwą i krótkim opisem funkcji oraz jej parametru w języku angielskim:

Kotlin

val itemList = mutableListOf<String>()

fun addList(item: String) {
    itemList.add(item)
}

val addListFunctionDeclaration = FunctionDeclaration(
    name = "addList",
    description = "Function adding an item the list",
    parameters = mapOf(
        "item" to Schema.string("A short string describing the item to add to the list")
    )
)GeminiLive.kt

Java

HashMap<String, Schema> addListParams = new HashMap<String, Schema>(1);

addListParams.put("item", Schema.str("A short string describing the item to add to the list"));

FunctionDeclaration addListFunctionDeclaration = new FunctionDeclaration(
    "addList",
    "Function adding an item the list",
    addListParams,
    Collections.emptyList()
);

Następnie przekaż ten FunctionDeclaration jako Tool do modelu podczas jego tworzenia:

Kotlin

val addListTool = Tool.functionDeclarations(listOf(addListFunctionDeclaration))

val model = Firebase.ai(backend = GenerativeBackend.googleAI()).liveModel(
    modelName = "gemini-2.5-flash-native-audio-preview-12-2025",
    generationConfig = liveGenerationConfig {
        responseModality = ResponseModality.AUDIO
        speechConfig = SpeechConfig(voice = Voice("FENRIR"))
    },
    systemInstruction = systemInstruction,
    tools = listOf(addListTool)
)GeminiLive.kt

Java

LiveGenerativeModel model = FirebaseAI.getInstance(
    GenerativeBackend.googleAI()).liveModel(
        "gemini-2.5-flash-native-audio-preview-12-2025",
  new LiveGenerationConfig.Builder()
        .setResponseModalities(ResponseModality.AUDIO)
        .setSpeechConfig(new SpeechConfig(new Voice("FENRIR")))
        .build(),
  List.of(Tool.functionDeclarations(List.of(addListFunctionDeclaration))),
               null,
               systemInstruction
        );

Na koniec zaimplementuj funkcję obsługi, która będzie obsługiwać wywołanie narzędzia przez model i przekazywać mu odpowiedź. Ta funkcja obsługi przekazywana do LiveSession podczas wywoływania startAudioConversation przyjmuje parametr FunctionCallPart i zwraca FunctionResponsePart:

Kotlin

session.startAudioConversation(::functionCallHandler)

// ...

fun functionCallHandler(functionCall: FunctionCallPart): FunctionResponsePart {
    return when (functionCall.name) {
        "addList" -> {
            // Extract function parameter from functionCallPart
            val itemName = functionCall.args["item"]!!.jsonPrimitive.content
            // Call function with parameter
            addList(itemName)
            // Confirm the function call to the model
            val response = JsonObject(
                mapOf(
                    "success" to JsonPrimitive(true),
                    "message" to JsonPrimitive("Item $itemName added to the todo list")
                )
            )
            FunctionResponsePart(functionCall.name, response)
        }
        else -> {
            val response = JsonObject(
                mapOf(
                    "error" to JsonPrimitive("Unknown function: ${functionCall.name}")
                )
            )
            FunctionResponsePart(functionCall.name, response)
        }
    }
}GeminiLive.kt

Java

Futures.addCallback(sessionFuture, new FutureCallback<LiveSessionFutures>() {

    @RequiresPermission(Manifest.permission.RECORD_AUDIO)
    @Override
    @OptIn(markerClass = PublicPreviewAPI.class)
    public void onSuccess(LiveSessionFutures ses) {
        ses.startAudioConversation(::handleFunctionCallFuture);
    }

    @Override
    public void onFailure(Throwable t) {
        // Handle exceptions
    }
}, executor);

// ...

ListenableFuture<JsonObject> handleFunctionCallFuture = Futures.transform(response, result -> {
    for (FunctionCallPart functionCall : result.getFunctionCalls()) {
        if (functionCall.getName().equals("addList")) {
            Map<String, JsonElement> args = functionCall.getArgs();
            String item =
                    JsonElementKt.getContentOrNull(
                            JsonElementKt.getJsonPrimitive(
                                    locationJsonObject.get("item")));
            return addList(item);
        }
    }
    return null;
}, Executors.newSingleThreadExecutor());

Dalsze kroki

Wypróbuj Gemini Live API w aplikacji demonstracyjnej katalogu AI na Androida.
Więcej informacji o Gemini Live API znajdziesz w dokumentacji Firebase AI Logic.
Dowiedz się więcej o dostępnych modelach Gemini.
Dowiedz się więcej o wywoływaniu funkcji.
Poznaj strategie projektowania promptów.

Gemini Live API Zadbaj o dobrą organizację dzięki kolekcji Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.

Rozpocznij

Konfigurowanie projektu na Androida

Konfigurowanie dostawcy debugowania Sprawdzania aplikacji na potrzeby programowania lokalnego

Kotlin

Java

Integracja Firebase AI Logic i inicjowanie modelu generatywnego

Kotlin

Java

Kotlin

Java

Inicjowanie sesji Live API

Kotlin

Java

Wywoływanie funkcji: łączenie Gemini Live API z aplikacją

Kotlin

Java

Kotlin

Java

Kotlin

Java

Dalsze kroki

Gemini Live API