Gemini Live API

Für Anwendungen, die Sprachunterstützung in Echtzeit und mit geringer Latenz erfordern, z. B. Chatbots oder Agenteninteraktionen, 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 dass eine Backend-Integration erforderlich ist. In dieser Anleitung erfahren Sie, wie Sie die Gemini Live API in Ihrer Android-App mit Firebase AI Logic verwenden.

Jetzt starten

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

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

Android-Projekt einrichten

Fügen Sie die Firebase AI Logic-Bibliotheksabhängigkeit der Datei auf App-Ebene build.gradle.kts oder build.gradle hinzu. Verwenden Sie die Firebase Android BoM, um Bibliotheksversionen zu verwalten.

dependencies {
  // Import the Firebase BoM
  implementation(platform("com.google.firebase:firebase-bom:34.11.0"))
  // Add the dependency for the Firebase AI Logic library
  // When using the BoM, you don't specify versions in Firebase library dependencies
  implementation("com.google.firebase:firebase-ai")
}

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

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 LiveModel zu. Verwenden Sie ein Modell, das die Live API unterstützt, z. B. gemini-2.5-flash-native-audio-preview-12-2025. Verfügbare Modelle finden Sie in der Firebase-Dokumentation für verfügbare Modelle.

Wenn Sie eine Stimme angeben möchten, legen Sie den Namen der Stimme 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"))
    }
)
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
);

Optional können Sie eine Persona oder Rolle definieren, die das Modell spielt, 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,
)
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
);

Sie können die Unterhaltung mit dem Modell weiter spezialisieren, indem Sie Systemanweisungen verwenden, um kontextbezogene Informationen für Ihre App bereitzustellen (z. B. den Aktivitätsverlauf von Nutzern in der App).

Live API-Sitzung initialisieren

Nachdem Sie die LiveModel-Instanz erstellt haben, rufen Sie model.connect() auf, um ein LiveSession-Objekt zu erstellen und eine dauerhafte Verbindung mit dem Modell mit Streaming mit geringer Latenz herzustellen. Mit LiveSession können Sie mit dem Modell interagieren, indem Sie die Sprachsitzung 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()
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);

Bei Unterhaltungen mit dem Modell werden Unterbrechungen nicht verarbeitet. Außerdem ist die Live API bidirektional. Sie verwenden also dieselbe Verbindung, um Inhalte zu senden und zu empfangen.

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 direkt mit der Logik Ihrer App interagieren lassen, indem Sie Funktionsaufrufe verwenden.

Funktionsaufrufe (oder Tool-Aufrufe) sind eine Funktion generativer 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 veranschaulicht, 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 veranschaulicht, wie die Gemini Live API es ermöglicht, einen Nutzerprompt von einem Modell interpretieren zu lassen, 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 App 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 zur Verfügung stellen möchten, mit der ein String an eine Liste von Strings angehängt wird, 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")
    )
)
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"));
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 diese FunctionDeclaration dann 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)
)
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
        );

Implementieren Sie schließlich eine Handler-Funktion, um den Tool-Aufruf des Modells zu verarbeiten und die Antwort zurückzugeben. Diese Handler-Funktion, die LiveSession beim Aufruf von startAudioConversation zur Verfügung gestellt wird, verwendet einen FunctionCallPart-Parameter 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)
        }
    }
}
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());

Nächste Schritte