Gemini Live API

Untuk aplikasi yang memerlukan dukungan suara real-time dan latensi rendah, seperti chatbot atau interaksi agentic, 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 Anda dengan Firebase AI Logic.

Catatan: Penggunaan Gemini Live API dengan Firebase AI Logic masih dalam pratinjau developer. Perubahan yang tidak kompatibel dengan versi lama dapat terjadi, dan memiliki batasan berikut.

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 library Firebase AI Logic dan dependensi App Check ke file build.gradle.kts atau build.gradle level aplikasi Anda. Gunakan Firebase Android BoM untuk mengelola versi library.

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

Setelah menambahkan dependensi, sinkronkan project Android Anda dengan Gradle.

Mengonfigurasi penyedia debug App Check untuk pengembangan lokal

Mulai awal Juli 2026, sebagai bagian dari alur kerja penyiapan terpandu untuk AI Logic di Firebase console, Firebase App Check akan otomatis diterapkan untuk melindungi Gemini API. Untuk pengembangan lokal, Anda perlu mengonfigurasi penyedia debug App Check untuk mengabaikan pengesahan sambil tetap mempertahankan penerapan App Check.

1. Pada build debug, konfigurasikan App Check untuk menggunakan factory penyedia debug:

   Kotlin

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

   Java

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

2. Dapatkan token debug Anda:

   1. Jalankan aplikasi Anda di emulator atau di perangkat pengujian.

   2. Cari token debug App Check di log Anda. Contoh:

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

   3. Salin token (misalnya, 123a4567-b89c-12d3-e456-789012345678).

3. Daftarkan token debug Anda ke App Check:

   1. Di Firebase console, buka tab Security > App Check > Apps.

   2. Temukan aplikasi Anda, klik menu tambahan (), lalu pilih Manage debug tokens.

   3. Ikuti petunjuk di layar untuk mendaftarkan token debug Anda.

Untuk mengetahui detail tentang penyedia debug (termasuk cara mendapatkan token debug baru), lihat dokumentasi resmi App Check.

Berikut beberapa poin penting tentang penyedia debug App Check:

• Jaga kerahasiaan token debug dan build debug Anda. Jangan meng-commit token debug ke repositori publik, dan jangan mengirimkan token debug atau build debug dalam build produksi aplikasi Anda.
• Daftarkan aplikasi Anda ke penyedia pengesahan produksi sebelum merilisnya kepada pengguna akhir. Anda harus mendaftarkan aplikasi ke penyedia pengesahan App Check produksi (misalnya, Play Integrity) agar pengguna akhir dapat menggunakan fitur Anda dengan App Check yang diterapkan.

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

Lakukan 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 Live API 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).

Melakukan inisialisasi sesi Live API

Setelah Anda membuat instance LiveModel, panggil model.connect() untuk membuat objek LiveSession dan buat koneksi persisten dengan model dengan 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 interupsi. Selain itu, Live API bersifat bidirectional 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:

• Mengirim input teks dan audio.
• Mengirim input video (lihat aplikasi panduan memulai Firebase).

Pemanggilan fungsi: menghubungkan Gemini Live API ke aplikasi Anda

Untuk melangkah lebih jauh, Anda juga dapat mengaktifkan model untuk berinteraksi langsung dengan logika aplikasi Anda menggunakan panggilan fungsi.

Pemanggilan fungsi (atau pemanggilan alat) adalah fitur implementasi 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 pembuatan berikutnya.

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

Untuk mengimplementasikan panggilan fungsi di aplikasi Anda, 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 biasa 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()
        .setResponseModality(ResponseModality.AUDIO)
        .setSpeechConfig(new SpeechConfig(new Voice("FENRIR")))
        .build(),
  List.of(Tool.functionDeclarations(List.of(addListFunctionDeclaration))),
               null,
               systemInstruction
        );

Terakhir, terapkan fungsi pengendali untuk menangani panggilan alat yang dibuat model dan meneruskan kembali responsnya. Fungsi pengendali ini disediakan untuk 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

• Coba Gemini Live API di aplikasi contoh Android AI catalog.
• Baca selengkapnya tentang Gemini Live API di dokumentasi Firebase AI Logic.
• Pelajari lebih lanjut model Gemini yang tersedia.
• Pelajari lebih lanjut pemanggilan fungsi.
• Pelajari strategi desain perintah.