API Gemini Live

Per le applicazioni che richiedono il supporto vocale in tempo reale e a bassa latenza, come chatbot o interazioni con agenti, l'API Gemini Live fornisce un modo ottimizzato per eseguire lo streaming di input e output per un modello Gemini. Utilizzando Firebase AI Logic, puoi chiamare l'API Gemini Live direttamente dalla tua app per Android senza la necessità di un'integrazione backend. Questa guida mostra come utilizzare l'API Gemini Live nella tua app per Android con Firebase AI Logic.

Inizia

Prima di iniziare, assicurati che la tua app abbia come target il livello API 23 o superiore.

Se non l'hai già fatto, configura un progetto Firebase e connetti la tua app a Firebase. Per maggiori dettagli, consulta la documentazione di Firebase AI Logic.

Configura il progetto Android

Aggiungi la dipendenza della libreria Firebase AI Logic al file a livello di app build.gradle.kts o build.gradle. Utilizza la distinta base di Firebase Android per gestire le versioni delle librerie.

dependencies {
  // Import the Firebase BoM
  implementation(platform("com.google.firebase:firebase-bom:34.12.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")
}

Dopo aver aggiunto la dipendenza, sincronizza il progetto Android con Gradle.

Integra Firebase AI Logic e inizializza un modello generativo

Aggiungi l'autorizzazione RECORD_AUDIO al file AndroidManifest.xml della tua applicazione:

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

Inizializza il servizio di backend dell'API Gemini Developer e accedi a LiveModel. Utilizza un modello che supporti l'API Live, ad esempio gemini-2.5-flash-native-audio-preview-12-2025. Consulta la documentazione di Firebase per i modelli disponibili.

Per specificare una voce, imposta il nome della voce all'interno dell' speechConfig oggetto come parte della configurazione del modello. Se non specifichi una voce, il valore predefinito è 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
);

Facoltativamente, puoi definire una persona o un ruolo che il modello svolge impostando un'istruzione di sistema:

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

Puoi specializzare ulteriormente la conversazione con il modello utilizzando le istruzioni di sistema per fornire un contesto specifico per la tua app (ad esempio, la cronologia attività in-app dell'utente).

Inizializza una sessione dell'API Live

Dopo aver creato l'istanza LiveModel, chiama model.connect() per creare un oggetto LiveSession e stabilire una connessione persistente con il modello con streaming a bassa latenza. LiveSession ti consente di interagire con il modello avviando e interrompendo la sessione vocale, nonché inviando e ricevendo testo.

Puoi quindi chiamare startAudioConversation() per avviare la conversazione con il modello:

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

Tieni presente che il modello non gestisce le interruzioni nelle conversazioni. Inoltre, l'API Live è bidirezionale, quindi utilizzi la stessa connessione per inviare e ricevere contenuti.

Puoi anche utilizzare l'API Gemini Live per generare audio da diverse modalità di input:

Chiamata di funzioni: connetti l'API Gemini Live alla tua app

Per fare un passo in più, puoi anche consentire al modello di interagire direttamente con la logica della tua app utilizzando la chiamata di funzioni.

La chiamata di funzioni (o chiamata di strumenti) è una funzionalità delle implementazioni di AI generativa che consente al modello di chiamare le funzioni di propria iniziativa per eseguire azioni. Se la funzione ha un output, il modello lo aggiunge al suo contesto e lo utilizza per le generazioni successive.

Diagramma che illustra come l&#39;API Gemini Live consente a un prompt utente di essere interpretato da un modello, attivando una funzione predefinita con argomenti pertinenti in un&#39;app per Android, che poi riceve una risposta di conferma dal modello.
Figura 1: diagramma che illustra come l'API Gemini Live consente a un prompt dell'utente di essere interpretato da un modello, attivando una funzione predefinita con argomenti pertinenti in un'app per Android, che poi riceve una risposta di conferma dal modello.

Per implementare la chiamata di funzioni nella tua app, inizia creando un oggetto FunctionDeclaration per ogni funzione che vuoi esporre al modello.

Ad esempio, per esporre una funzione addList che aggiunge una stringa a un elenco di stringhe a Gemini, inizia creando una variabile FunctionDeclaration con un nome e una breve descrizione in inglese semplice della funzione e del relativo parametro:

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

Quindi, passa questo FunctionDeclaration come Tool al modello quando lo crei:

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

Infine, implementa una funzione di gestione per gestire la chiamata di strumenti effettuata dal modello e restituisci la risposta. Questa funzione di gestione fornita a LiveSession quando chiami startAudioConversation accetta un parametro FunctionCallPart e restituisce 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());

Passaggi successivi