Gemini Live API

Untuk aplikasi yang memerlukan dukungan suara real-time dan latensi rendah, seperti chatbot atau interaksi agen, Gemini Live API menyediakan cara yang dioptimalkan untuk melakukan streaming input dan output untuk model Gemini. Dengan menggunakan Firebase AI Logic, Anda dapat memanggil Gemini Live API langsung dari aplikasi Android tanpa memerlukan integrasi backend. Panduan ini menunjukkan cara menggunakan Gemini Live API di aplikasi Android dengan Firebase AI Logic.

Mulai

Sebelum memulai, pastikan aplikasi Anda menargetkan API level 23 atau yang lebih tinggi.

Jika belum, siapkan project Firebase dan hubungkan aplikasi Anda ke Firebase. Untuk mengetahui detailnya, lihat dokumentasi Firebase AI Logic.

Menyiapkan project Android Anda

Tambahkan dependensi library Firebase AI Logic ke file level aplikasi Anda build.gradle.kts atau build.gradle. Gunakan Firebase Android BoM untuk mengelola versi library.

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

Setelah menambahkan dependensi, sinkronkan project Android Anda dengan Gradle.

Mengintegrasikan Firebase AI Logic dan menginisialisasi model generatif

Tambahkan izin RECORD_AUDIO ke file AndroidManifest.xml aplikasi Anda:

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

Inisialisasi layanan backend Gemini Developer API dan akses LiveModel. Gunakan model yang mendukung Live API, seperti gemini-2.5-flash-native-audio-preview-12-2025. Lihat dokumentasi Firebase untuk mengetahui model yang tersedia.

Untuk menentukan suara, tetapkan nama suara dalam objek speechConfig sebagai bagian dari konfigurasi model. Jika Anda tidak menentukan suara, defaultnya adalah 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
);

Anda dapat menentukan persona atau peran yang dimainkan model dengan menetapkan petunjuk sistem:

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

Anda dapat lebih mengkhususkan percakapan dengan model menggunakan petunjuk sistem untuk memberikan konteks khusus untuk aplikasi Anda (misalnya, histori aktivitas dalam aplikasi pengguna).

Menginisialisasi sesi Live API

Setelah membuat instance LiveModel, panggil model.connect() untuk membuat objek LiveSession dan membuat koneksi persisten dengan model menggunakan streaming latensi rendah. LiveSession memungkinkan Anda berinteraksi dengan model dengan memulai dan menghentikan sesi suara, serta mengirim dan menerima teks.

Kemudian, Anda dapat memanggil startAudioConversation() untuk memulai percakapan dengan model:

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

Dalam percakapan Anda dengan model, perhatikan bahwa model tidak menangani gangguan. Selain itu, Live API bersifat dua arah sehingga Anda menggunakan koneksi yang sama untuk mengirim dan menerima konten.

Anda juga dapat menggunakan Gemini Live API untuk membuat audio dari berbagai modalitas input:

Pemanggilan fungsi: menghubungkan Gemini Live API ke aplikasi Anda

Untuk melangkah lebih jauh, Anda juga dapat mengizinkan model berinteraksi langsung dengan logika aplikasi menggunakan pemanggilan fungsi.

Pemanggilan fungsi (atau pemanggilan alat) adalah fitur penerapan AI generatif yang memungkinkan model memanggil fungsi atas inisiatifnya sendiri untuk melakukan tindakan. Jika fungsi memiliki output, model akan menambahkannya ke konteksnya dan menggunakannya untuk generasi berikutnya.

Diagram yang menggambarkan cara Gemini Live API memungkinkan perintah pengguna ditafsirkan oleh model, memicu fungsi yang telah ditentukan sebelumnya dengan argumen yang relevan di aplikasi Android, yang kemudian menerima respons konfirmasi dari model.
Gambar 1: Diagram yang menggambarkan bagaimana Gemini Live API memungkinkan perintah pengguna ditafsirkan oleh model, yang memicu fungsi yang telah ditentukan dengan argumen yang relevan di aplikasi Android, yang kemudian menerima respons konfirmasi dari model.

Untuk menerapkan pemanggilan fungsi di aplikasi, mulailah dengan membuat objek FunctionDeclaration untuk setiap fungsi yang ingin Anda ekspos ke model.

Misalnya, untuk mengekspos fungsi addList yang menambahkan string ke daftar string ke Gemini, mulailah dengan membuat variabel FunctionDeclaration dengan nama dan deskripsi singkat dalam bahasa Inggris sederhana tentang fungsi dan parameternya:

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

Kemudian, teruskan FunctionDeclaration ini sebagai Tool ke model saat Anda membuat instance-nya:

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

Terakhir, terapkan fungsi pengendali untuk menangani pemanggilan alat yang dilakukan model dan meneruskan responsnya kembali. Fungsi pengendali ini yang diberikan ke LiveSession saat Anda memanggil startAudioConversation, menggunakan parameter FunctionCallPart dan menampilkan 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());

Langkah berikutnya