Gemini Live API

Chatbot'lar veya temsilci etkileşimleri gibi anlık ve düşük gecikmeli ses desteği gerektiren uygulamalar için Gemini Live API, Gemini modelinin hem girişini hem de çıkışını yayınlamak için optimize edilmiş bir yol sunar. Firebase AI Logic'i kullanarak Gemini Live API'yi arka uç entegrasyonuna gerek kalmadan doğrudan Android uygulamanızdan çağırabilirsiniz. Bu kılavuzda, Firebase AI Logic ile Android uygulamanızda Gemini Live API'yi nasıl kullanacağınız gösterilmektedir.

Başlayın

Başlamadan önce uygulamanızın API düzeyi 23 veya sonraki sürümleri hedeflediğinden emin olun.

Henüz yapmadıysanız bir Firebase projesi oluşturun ve uygulamanızı Firebase'e bağlayın. Ayrıntılar için Firebase AI Logic belgelerine bakın.

Android projenizi oluşturma

Firebase AI Logic kitaplığını ve App Check bağımlılıklarını uygulama düzeyindeki build.gradle.kts veya build.gradle dosyanıza ekleyin. Kitaplık sürümlerini yönetmek için Firebase Android BoM'u kullanın.

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

Bağımlılıkları ekledikten sonra Android projenizi Gradle ile senkronize edin.

Yerel geliştirme için Uygulama Kontrolü hata ayıklama sağlayıcısını yapılandırma

Temmuz 2026'nın başlarından itibaren, Firebase Console'daki AI Logic için rehberli kurulum iş akışı kapsamında Gemini API'yi korumak amacıyla Firebase Uygulama Kontrolü otomatik olarak zorunlu kılınacak. Yerel geliştirme için, Uygulama Kontrolü'nün zorunlu kılınmasını sürdürürken onaylamayı atlamak üzere Uygulama Kontrolü hata ayıklama sağlayıcısını yapılandırmanız gerekir.

  1. Hata ayıklama derlemenizde, hata ayıklama sağlayıcı fabrikasını kullanmak için App Check'i yapılandırın:

    Kotlin

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

    Java

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

  2. Hata ayıklama jetonunuzu alın:

    1. Uygulamanızı emülatörde veya test cihazınızda çalıştırın.

    2. Günlüklerinizde uygulama denetimi hata ayıklama jetonunu bulun. Örneğin:

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

    3. Jetonu kopyalayın (örneğin, 123a4567-b89c-12d3-e456-789012345678).

  3. Hata ayıklama jetonunuzu Uygulama Kontrolü'ne kaydedin:

    1. Firebase konsolunda Güvenlik > App Check > Uygulamalar sekmesine gidin.

    2. Uygulamanızı bulun, taşma menüsünü () tıklayın ve Hata ayıklama jetonlarını yönet'i seçin.

    3. Hata ayıklama jetonunuzu kaydetmek için ekrandaki talimatları uygulayın.

Hata ayıklama sağlayıcısı hakkında ayrıntılı bilgi (yeni bir hata ayıklama jetonunun nasıl alınacağı dahil) için resmi App Check belgelerine göz atın.

Firebase AI Logic'i entegre etme ve üretken modeli başlatma

Uygulamanızın AndroidManifest.xml dosyasına RECORD_AUDIO iznini ekleyin:

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

Gemini Developer API arka uç hizmetini başlatın ve LiveModel erişin. gemini-2.5-flash-native-audio-preview-12-2025 gibi Live API'yi destekleyen bir model kullanın. Kullanılabilir Live API modelleri için Firebase belgelerine bakın.

Bir ses belirtmek için voice name'i speechConfig nesnesinde model yapılandırmasının bir parçası olarak ayarlayın. Ses belirtmezseniz varsayılan olarak Puck kullanılır.

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

İsteğe bağlı olarak bir sistem talimatı ayarlayarak modelin oynadığı karakteri veya rolü tanımlayabilirsiniz:

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

Uygulamanıza özel bağlam sağlamak için (ör. kullanıcı uygulama içi etkinlik geçmişi) sistem talimatlarını kullanarak modelle olan sohbeti daha da özelleştirebilirsiniz.

Live API oturumu başlatma

LiveModel örneğini oluşturduktan sonra model.connect() işlevini çağırarak LiveSession nesnesi oluşturun ve düşük gecikmeli akışla modelle kalıcı bir bağlantı kurun. LiveSession, ses oturumunu başlatıp durdurarak ve metin gönderip alarak modelle etkileşime geçmenizi sağlar.

Ardından, modelle görüşmeyi başlatmak için startAudioConversation()'ı arayabilirsiniz:

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

Modelle olan görüşmelerinizde, modelin kesintileri ele almadığını unutmayın. Ayrıca, Live API iki yönlüdür. Bu nedenle, içerik göndermek ve almak için aynı bağlantıyı kullanırsınız.

Farklı giriş biçimlerinden ses oluşturmak için Gemini Live API'yi de kullanabilirsiniz:

İşlev çağırma: Gemini Live API'yi uygulamanıza bağlama

Bir adım daha ileri giderek işlev çağrısı özelliğini kullanarak modelin doğrudan uygulamanızın mantığıyla etkileşim kurmasını da sağlayabilirsiniz.

İşlev çağrısı (veya araç çağrısı), üretken yapay zeka uygulamalarında kullanılan ve modelin kendi inisiyatifiyle işlev çağırarak işlemler yapmasına olanak tanıyan bir özelliktir. İşlevin bir çıkışı varsa model bunu bağlamına ekler ve sonraki oluşturma işlemlerinde kullanır.

Gemini Live API&#39;nin, kullanıcı isteminin bir model tarafından nasıl yorumlanmasına olanak tanıdığını, Android uygulamasında ilgili bağımsız değişkenlerle önceden tanımlanmış bir işlevi nasıl tetiklediğini ve ardından modelden nasıl onay yanıtı aldığını gösteren şema.
Şekil 1: Gemini Live API'nin, kullanıcı isteminin bir model tarafından yorumlanmasına nasıl izin verdiğini gösteren şema. Bu yorumlama, Android uygulamasında önceden tanımlanmış bir işlevi ilgili bağımsız değişkenlerle tetikler. Ardından, modelden bir onay yanıtı alınır.

Uygulamanızda işlev çağrısını uygulamak için modele sunmak istediğiniz her işlev için bir FunctionDeclaration nesnesi oluşturarak başlayın.

Örneğin, bir dize listesine dize ekleyen bir addList işlevini Gemini'da kullanıma sunmak için işlevin ve parametresinin adını ve kısa açıklamasını düz İngilizce olarak içeren bir FunctionDeclaration değişkeni oluşturarak başlayın:

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

Ardından, modeli oluştururken bu FunctionDeclaration öğesini Tool olarak modele aktarın:

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()
        .setResponseModalities(ResponseModality.AUDIO)
        .setSpeechConfig(new SpeechConfig(new Voice("FENRIR")))
        .build(),
  List.of(Tool.functionDeclarations(List.of(addListFunctionDeclaration))),
               null,
               systemInstruction
        );

Son olarak, modelin yaptığı araç çağrısını işlemek ve yanıtı geri iletmek için bir işleyici işlevi uygulayın. startAudioConversation işlevini çağırdığınızda LiveSession öğesine sağlanan bu işleyici işlevi, FunctionCallPart parametresini alır ve FunctionResponsePart değerini döndürür:

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

Sonraki adımlar