Gemini Live API

W przypadku aplikacji, które wymagają obsługi głosu w czasie rzeczywistym i z krótkim czasem oczekiwania, takich jak chatboty lub interakcje z agentami, Gemini Live API zapewnia zoptymalizowany sposób przesyłania strumieniowego zarówno danych wejściowych, jak i wyjściowych dla modelu Gemini. Dzięki Firebase AI Logic możesz wywoływać interfejs Gemini Live API bezpośrednio z aplikacji na Androida bez konieczności integracji z backendem. Ten przewodnik pokazuje, jak używać interfejsu Gemini Live API w aplikacji na Androida za pomocą Firebase AI Logic.

Uwaga: korzystanie z interfejsu Gemini Live API z Firebase AI Logic jest dostępne w wersji przedpremierowej dla programistów. Możliwe są zmiany niezgodne wstecznie, a usługa ma te ograniczenia.

Rozpocznij

Zanim zaczniesz, upewnij się, że aplikacja jest kierowana na interfejs API na poziomie 23 lub wyższym.

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

Konfigurowanie projektu aplikacji na Androida

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

dependencies {
  // Import the Firebase BoM
  implementation(platform("com.google.firebase:firebase-bom:35.1.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 aplikacji na Androida z Gradle.

Konfigurowanie dostawcy debugowania Sprawdzania aplikacji na potrzeby programowania lokalnego

Od początku lipca 2026 r. w ramach procesu konfiguracji z pomocą AI Logic w konsoli Firebase automatycznie wymuszane jest Sprawdzanie aplikacji Firebase, aby chronić interfejs Gemini API. W przypadku programowania lokalnego musisz skonfigurować dostawcę debugowania Sprawdzania aplikacji, aby pominąć atestację, zachowując jednocześnie egzekwowanie Sprawdzania aplikacji.

1. W kompilacji do debugowania skonfiguruj Sprawdzanie aplikacji tak, aby korzystało z 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());
   

2. Uzyskaj token debugowania:

   1. Uruchom aplikację w emulatorze lub na urządzeniu testowym.

   2. Poszukaj w dziennikach tokena debugowania funkcji Sprawdzanie 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 (na przykład 123a4567-b89c-12d3-e456-789012345678).

3. Zarejestruj token debugowania w Sprawdzaniu aplikacji:

   1. W konsoli Firebase otwórz kartę Zabezpieczenia > Sprawdzanie aplikacji > Aplikacje.

   2. Znajdź aplikację, kliknij rozszerzone menu (), a następnie wybierz Zarządzaj tokenami debugowania.

   3. Aby zarejestrować token debugowania, postępuj zgodnie z instrukcjami wyświetlanymi na ekranie.

Szczegółowe informacje o dostawcy debugowania (w tym o tym, jak uzyskać nowy token debugowania) znajdziesz w oficjalnej dokumentacji Sprawdzania aplikacji.

Oto kilka ważnych informacji o dostawcy debugowania Sprawdzania aplikacji:

• Nie udostępniaj tokena debugowania ani kompilacji do debugowania. Nie zapisuj tokena debugowania w publicznym repozytorium ani nie dołączaj go ani kompilacji do debugowania do kompilacji produkcyjnych aplikacji.
• Zarejestruj aplikację u dostawcy atestów produkcyjnych przed udostępnieniem jej użytkownikom. Musisz zarejestrować aplikację u dostawcy atestów sprawdzania aplikacji w środowisku produkcyjnym (np. Play Integrity), aby użytkownicy mogli korzystać z funkcji z wymuszonym sprawdzaniem 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. W dokumentacji Firebase znajdziesz informacje o dostępnych modelach Live API.

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 zostanie użyty 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
);

Możesz opcjonalnie zdefiniować postać lub rolę, którą model ma odgrywać, 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 jeszcze bardziej dostosować rozmowę z modelem, używając instrukcji systemowych, aby podać kontekst dotyczący 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 o niskim opóźnieniu. LiveSession umożliwia interakcję z modelem przez rozpoczynanie i zatrzymywanie 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 podczas rozmów z modelem nie obsługuje on przerw. Interfejs Live API jest też dwukierunkowy, więc możesz używać tego samego połączenia do wysyłania i odbierania treści.

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

• Wysyłanie danych tekstowych i głosowych.
• wysyłać dane wejściowe wideo (zapoznaj się z aplikacją Firebase do szybkiego startu).

Wywoływanie funkcji: połącz interfejs Gemini Live API ze swoją aplikacją.

Możesz też pójść o krok dalej i umożliwić modelowi bezpośrednią interakcję z logiką aplikacji za pomocą wywoływania funkcji.

Wywoływanie funkcji (lub 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 swojego kontekstu i używa ich do kolejnych generacji.

Rysunek 1. Diagram ilustrujący, jak interfejs Gemini Live API umożliwia interpretowanie promptu użytkownika przez model, co powoduje wywołanie wstępnie zdefiniowanej funkcji z odpowiednimi argumentami w aplikacji na Androida, która następnie otrzymuje odpowiedź z potwierdzeniem od modelu.

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

Na przykład, aby udostępnić Gemini funkcję addList, która dołącza ciąg znaków do listy ciągów znaków, zacznij od utworzenia zmiennej FunctionDeclaration z nazwą i krótkim opisem funkcji i 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 obiekt 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()
        .setResponseModality(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 interfejs Gemini Live API w przykładowej aplikacji z katalogu AI na Androida.
• Więcej informacji o interfejsie 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.