Gemini Live API

Chatbot'lar veya temsilci etkileşimleri gibi gerçek zamanlı 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 arka uç entegrasyonuna gerek kalmadan Gemini Live API'yi 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ığı bağımlılığı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.5.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")
}

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

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-live-2.5-flash-preview gibi Live API'yi destekleyen bir model kullanın. Kullanılabilir modeller için Firebase belgelerine bakın.

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

Kotlin

// Initialize the `LiveModel`
val model = Firebase.ai(backend = GenerativeBackend.googleAI()).liveModel(
       modelName = "gemini-live-2.5-flash-preview",
       generationConfig = liveGenerationConfig {
          responseModality = ResponseModality.AUDIO
          speechConfig = SpeechConfig(voice = Voice("FENRIR"))
       })

Java

// Initialize the `LiveModel`
LiveGenerativeModel model = FirebaseAI
       .getInstance(GenerativeBackend.googleAI())
       .liveModel(
              "gemini-live-2.5-flash-preview",
              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-live-2.5-flash-preview",
       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-live-2.5-flash-preview",
              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 etkileşimi 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 sohbeti 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);

Ayrıca, modelle olan görüşmelerinizde modelin kesintileri ele almadığını unutmayın.

Ayrıca, Gemini Live API'yi kullanarak metinden akışlı ses oluşturabilir ve akışlı sesten metin oluşturabilirsiniz. Live API'nin çift yönlü olduğunu, bu nedenle içerik göndermek ve almak için aynı bağlantıyı kullandığınızı unutmayın. Zamanla modele resim ve canlı video yayını da gönderebileceksiniz.

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

Bir adım daha ileri giderek, işlev çağrısını kullanarak modelin doğrudan uygulamanızın mantığıyla etkileşime girmesini de sağlayabilirsiniz.

İşlev çağrısı (veya araç çağrısı), üretken yapay zeka uygulamalarının bir özelliğidir. Bu özellik, modelin kendi inisiyatifiyle işlevleri çağırarak işlemler yapmasına olanak tanır. İş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 yorumlanmasına nasıl olanak tanıdığını gösteren şema. Bu yorumlama, Android uygulamasında ilgili bağımsız değişkenlerle önceden tanımlanmış bir işlevi tetikler ve modelden bir onay yanıtı alır.
Ş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 dizeyi dize listesine ekleyen bir addList işlevini Gemini'da kullanıma sunmak için öncelikle işlevin ve parametresinin düz İngilizce olarak kısa bir açıklamasıyla birlikte FunctionDeclaration değişkeni oluşturun:

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"));
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 iletin:

Kotlin

val addListTool = Tool.functionDeclarations(listOf(addListFunctionDeclaration))

val model = Firebase.ai(backend = GenerativeBackend.googleAI()).liveModel(
       modelName = "gemini-live-2.5-flash-preview",
       generationConfig = liveGenerationConfig {
          responseModality = ResponseModality.AUDIO
          speechConfig = SpeechConfig(voice= Voice("FENRIR"))
       },
       systemInstruction = systemInstruction,
       tools = listOf(addListTool)
)

Java

LiveGenerativeModel model = FirebaseAI.getInstance(
    GenerativeBackend.googleAI()).liveModel(
        "gemini-live-2.5-flash-preview",
  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 için bir işleyici işlevi uygulayın ve yanıtı geri iletin. 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