Gemini Live API

Für Anwendungen, die Echtzeit- und Sprachunterstützung mit niedriger Latenz erfordern, z. B. Chatbots oder agentische Interaktionen, bietet die Gemini Live API eine optimierte Möglichkeit, sowohl Eingaben als auch Ausgaben für ein Gemini-Modell zu streamen. Mit Firebase AI Logic können Sie die Gemini Live API direkt über Ihre Android-App aufrufen, ohne eine Backend-Integration zu benötigen. In dieser Anleitung erfahren Sie, wie Sie die Gemini Live API mit Firebase AI Logic in Ihrer Android-App verwenden.

Jetzt starten

Bevor Sie beginnen, muss Ihre App auf API-Level 23 oder höher ausgerichtet sein.

Falls noch nicht geschehen, richten Sie ein Firebase-Projekt ein und verbinden Sie Ihre App mit Firebase. Weitere Informationen finden Sie in der Dokumentation zu Firebase AI Logic.

Android-Projekt einrichten

Fügen Sie die Firebase AI Logic-Bibliothek und die App Check-Abhängigkeiten der Datei build.gradle.kts oder build.gradle auf Anwendungsebene hinzu. Verwenden Sie die Firebase Android BoM, um Bibliotheksversionen zu verwalten.

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")
}

Nachdem Sie die Abhängigkeiten hinzugefügt haben, synchronisieren Sie Ihr Android-Projekt mit Gradle.

App Check-Debug-Anbieter für die lokale Entwicklung konfigurieren

Ab Anfang Juli 2026 wird Firebase App Check im Rahmen des geführten Einrichtungsworkflows für AI Logic in der Firebase Console automatisch erzwungen, um die Gemini API zu schützen. Für die lokale Entwicklung müssen Sie den Debug-Anbieter von App Check konfigurieren, um die Attestierung zu umgehen, während die Erzwingung von App Check beibehalten wird.

  1. Konfigurieren Sie App Check in Ihrem Debug-Build so, dass die Debug-Anbieter-Factory verwendet wird:

    Kotlin

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

    Java

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

  2. Rufen Sie Ihr Debug-Token ab:

    1. Führen Sie Ihre App im Emulator oder auf Ihrem Testgerät aus.

    2. Suchen Sie in Ihren Logs nach dem App Check-Debug-Token. Beispiel:

      D DebugAppCheckProvider: Enter this debug secret into the allow list
in the Firebase Console for your project: 123a4567-b89c-12d3-e456-789012345678

    3. Kopieren Sie das Token (z. B. 123a4567-b89c-12d3-e456-789012345678).

  3. Registrieren Sie Ihr Debug-Token bei App Check:

    1. Rufen Sie in der Firebase Console den Tab Sicherheit > App Check > Apps auf.

    2. Suchen Sie Ihre App, klicken Sie auf das Dreipunkt-Menü () und wählen Sie Debug-Tokens verwalten aus.

    3. Folgen Sie der Anleitung auf dem Bildschirm, um Ihr Debug-Token zu registrieren.

Weitere Informationen zum Debug-Anbieter (einschließlich des Abrufs eines neuen Debug-Tokens) finden Sie in der offiziellen App Check-Dokumentation.

Firebase AI Logic einbinden und ein generatives Modell initialisieren

Fügen Sie der Datei AndroidManifest.xml Ihrer Anwendung die Berechtigung RECORD_AUDIO hinzu:

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

Initialisieren Sie den Backend-Dienst der Gemini Developer API und greifen Sie auf die LiveModel zu. Verwenden Sie ein Modell, das die Live API unterstützt, z. B. gemini-2.5-flash-native-audio-preview-12-2025. Informationen zu den verfügbaren Live API-Modellen finden Sie in der Firebase-Dokumentation.

Wenn Sie eine Stimme angeben möchten, legen Sie den Stimmennamen im speechConfig-Objekt als Teil der Modellkonfiguration fest. Wenn Sie keine Stimme angeben, wird standardmäßig Puck verwendet.

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"))
    }
)

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
);

Sie können optional eine Persona oder Rolle definieren, die das Modell übernimmt, indem Sie eine Systemanweisung festlegen:

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

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
);

Sie können die Unterhaltung mit dem Modell weiter spezialisieren, indem Sie Systemanweisungen verwenden, um Kontext speziell für Ihre App bereitzustellen (z. B. den Verlauf der In-App-Aktivitäten des Nutzers).

Live API-Sitzung initialisieren

Nachdem Sie die LiveModel-Instanz erstellt haben, rufen Sie model.connect() auf, um ein LiveSession-Objekt zu erstellen und eine persistente Verbindung zum Modell mit Streaming mit niedriger Latenz herzustellen. Mit LiveSession können Sie mit dem Modell interagieren, indem Sie die Sprachsession starten und beenden sowie Text senden und empfangen.

Anschließend können Sie startAudioConversation() aufrufen, um die Unterhaltung mit dem Modell zu starten:

Kotlin

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

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);

Beachten Sie, dass das Modell in Ihren Unterhaltungen keine Unterbrechungen verarbeitet. Außerdem ist die Live API bidirektional, d. h., Sie verwenden dieselbe Verbindung zum Senden und Empfangen von Inhalten.

Sie können die Gemini Live API auch verwenden, um Audio aus verschiedenen Eingabemodalitäten zu generieren:

Funktionsaufrufe: Gemini Live API mit Ihrer App verbinden

Sie können das Modell auch so konfigurieren, dass es über Funktionsaufrufe direkt mit der Logik Ihrer App interagiert.

Funktionsaufrufe (oder Toolaufrufe) sind eine Funktion von generativen KI-Implementierungen, mit der das Modell Funktionen auf eigene Initiative aufrufen kann, um Aktionen auszuführen. Wenn die Funktion eine Ausgabe hat, fügt das Modell sie seinem Kontext hinzu und verwendet sie für nachfolgende Generierungen.

Diagramm, das zeigt, wie die Gemini Live API es ermöglicht, dass ein Nutzer-Prompt von einem Modell interpretiert wird, wodurch eine vordefinierte Funktion mit relevanten Argumenten in einer Android-App ausgelöst wird, die dann eine Bestätigungsantwort vom Modell erhält.
Abbildung 1: Diagramm, das zeigt, wie die Gemini Live API es ermöglicht, dass ein Nutzerprompt von einem Modell interpretiert wird, wodurch eine vordefinierte Funktion mit relevanten Argumenten in einer Android-App ausgelöst wird, die dann eine Bestätigungsantwort vom Modell erhält.

Wenn Sie Funktionsaufrufe in Ihrer Anwendung implementieren möchten, erstellen Sie zuerst ein FunctionDeclaration-Objekt für jede Funktion, die Sie dem Modell zur Verfügung stellen möchten.

Wenn Sie beispielsweise eine addList-Funktion, die einen String an eine Liste von Strings anhängt, für Gemini verfügbar machen möchten, erstellen Sie zuerst eine FunctionDeclaration-Variable mit einem Namen und einer kurzen Beschreibung der Funktion und ihres Parameters in einfachem Englisch:

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")
    )
)

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()
);

Übergeben Sie dann diese FunctionDeclaration als Tool an das Modell, wenn Sie es instanziieren:

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

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
        );

Implementieren Sie schließlich eine Handler-Funktion, um den Toolaufruf des Modells zu verarbeiten und die Antwort zurückzugeben. Diese Handler-Funktion, die beim Aufruf von startAudioConversation an LiveSession übergeben wird, verwendet den Parameter FunctionCallPart und gibt FunctionResponsePart zurück:

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)
        }
    }
}

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());

Nächste Schritte