Gemini Developer API

Gemini Pro ve Flash modellerine erişmek için Android geliştiricilerin Firebase AI Logic'i kullanarak Gemini Developer API'yi kullanmasını öneririz. Kredi kartı gerektirmeden kullanmaya başlamanıza olanak tanır ve cömert bir ücretsiz katman sunar. Entegrasyonunuzu küçük bir kullanıcı tabanıyla doğruladıktan sonra ücretli katmana geçerek ölçeklendirebilirsiniz.

Firebase Android SDK'sı içeren bir Android uygulamasının resmi. Bir ok, Cloud ortamında SDK'dan Firebase'e doğru işaret ediyor. Firebase'den, Cloud'da bulunan Gemini Pro ve Flash'e bağlı olan Gemini Developer API'ye başka bir ok işaret ediyor.
1. şekil. Gemini Developer API'ye erişmek için Firebase AI Logic entegrasyon mimarisi.

Başlarken

Gemini API ile doğrudan uygulamanızdan etkileşim kurmadan önce birkaç işlem yapmanız gerekir. Bunlar arasında istemlerle ilgili bilgi edinmenin yanı sıra Firebase'i ve uygulamanızı SDK'yı kullanacak şekilde ayarlamak da yer alır.

İstemlerle deneme yapma

İstemlerle denemeler yaparak Android uygulamanız için en iyi ifadeyi, içeriği ve biçimi bulabilirsiniz. Google AI Studio, uygulamanızın kullanım alanlarına yönelik istemlerin prototipini oluşturmak ve istemleri tasarlamak için kullanabileceğiniz bir IDE'dir.

Kullanım alanınız için doğru istemi oluşturmak bilimden çok sanata benzer. Bu nedenle deneme yapmak çok önemlidir. İstem oluşturma hakkında daha fazla bilgiyi Firebase dokümanlarında bulabilirsiniz.

İstediğiniz istemi oluşturduktan sonra, kodunuza ekleyebileceğiniz kod snippet'lerini almak için "<>" düğmesini tıklayın.

Firebase projesi oluşturma ve uygulamanızı Firebase'e bağlama

Uygulamanızdan API'yi çağırmaya hazır olduğunuzda, Firebase'i ve SDK'yı uygulamanızda ayarlamak için Firebase AI Logic başlangıç kılavuzunun "1. Adım" bölümündeki talimatları uygulayın.

Gradle bağımlılığını ekleyin

Uygulama modülünüze aşağıdaki Gradle bağımlılığını ekleyin:

Kotlin

dependencies {
  // ... other androidx dependencies

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

Java

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

  // Required for one-shot operations (to use `ListenableFuture` from Guava
  // Android)
  implementation("com.google.guava:guava:31.0.1-android")

  // Required for streaming operations (to use `Publisher` from Reactive
  // Streams)
  implementation("org.reactivestreams:reactive-streams:1.0.4")
}

Üretken modeli başlatma

GenerativeModel öğesini oluşturup model adını belirterek başlayın:

Kotlin

val model = Firebase.ai(backend = GenerativeBackend.googleAI())
                        .generativeModel("gemini-2.5-flash")

Java

GenerativeModel firebaseAI = FirebaseAI.getInstance(GenerativeBackend.googleAI())
        .generativeModel("gemini-2.5-flash");

GenerativeModelFutures model = GenerativeModelFutures.from(firebaseAI);

Gemini Developer API ile kullanılabilecek modeller hakkında daha fazla bilgi edinin. Ayrıca, model parametrelerini yapılandırma hakkında daha fazla bilgi edinebilirsiniz.

Uygulamanızdan Gemini Developer API ile etkileşim kurma

Firebase'i ve uygulamanızı SDK'yı kullanacak şekilde ayarladığınıza göre artık uygulamanızdan Gemini Developer API ile etkileşim kurmaya hazırsınız.

Metin oluşturma

Metin yanıtı oluşturmak için isteminizle birlikte generateContent() işlevini çağırın.

Kotlin

scope.launch {
  val response = model.generateContent("Write a story about a magic backpack.")
}

Java

Content prompt = new Content.Builder()
    .addText("Write a story about a magic backpack.")
    .build();

ListenableFuture<GenerateContentResponse> response = model.generateContent(prompt);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        String resultText = result.getText();
        [...]
    }

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

Resimlerden ve diğer medyadan metin oluşturma

Ayrıca, metin ve resimler veya diğer medya türlerini içeren bir istemden metin de oluşturabilirsiniz. generateContent() çağırırken medyayı satır içi veri olarak iletebilirsiniz.

Örneğin, bit eşlem kullanmak için image içerik türünü kullanın:

Kotlin

scope.launch {
  val response = model.generateContent(
    content {
      image(bitmap)
      text("what is the object in the picture?")
    }
  )
}

Java

Content content = new Content.Builder()
        .addImage(bitmap)
        .addText("what is the object in the picture?")
        .build();

ListenableFuture<GenerateContentResponse> response = model.generateContent(content);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        String resultText = result.getText();
        [...]
    }

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

Ses dosyası iletmek için inlineData içerik türünü kullanın:

Kotlin

val contentResolver = applicationContext.contentResolver
val inputStream = contentResolver.openInputStream(audioUri).use { stream ->
    stream?.let {
        val bytes = stream.readBytes()

        val prompt = content {
            inlineData(bytes, "audio/mpeg")  // Specify the appropriate audio MIME type
            text("Transcribe this audio recording.")
        }

        val response = model.generateContent(prompt)
    }
}

Java

ContentResolver resolver = getApplicationContext().getContentResolver();

try (InputStream stream = resolver.openInputStream(audioUri)) {
    File audioFile = new File(new URI(audioUri.toString()));
    int audioSize = (int) audioFile.length();
    byte audioBytes = new byte[audioSize];
    if (stream != null) {
        stream.read(audioBytes, 0, audioBytes.length);
        stream.close();

        // Provide a prompt that includes audio specified earlier and text
        Content prompt = new Content.Builder()
              .addInlineData(audioBytes, "audio/mpeg")  // Specify the appropriate audio MIME type
              .addText("Transcribe what's said in this audio recording.")
              .build();

        // To generate text output, call `generateContent` with the prompt
        ListenableFuture<GenerateContentResponse> response = model.generateContent(prompt);
        Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
            @Override
            public void onSuccess(GenerateContentResponse result) {
                String text = result.getText();
                Log.d(TAG, (text == null) ? "" : text);
            }
            @Override
            public void onFailure(Throwable t) {
                Log.e(TAG, "Failed to generate a response", t);
            }
        }, executor);
    } else {
        Log.e(TAG, "Error getting input stream for file.");
        // Handle the error appropriately
    }
} catch (IOException e) {
    Log.e(TAG, "Failed to read the audio file", e);
} catch (URISyntaxException e) {
    Log.e(TAG, "Invalid audio file", e);
}

Video dosyası sağlamak için inlineData içerik türünü kullanmaya devam edin:

Kotlin

val contentResolver = applicationContext.contentResolver
contentResolver.openInputStream(videoUri).use { stream ->
  stream?.let {
    val bytes = stream.readBytes()

    val prompt = content {
        inlineData(bytes, "video/mp4")  // Specify the appropriate video MIME type
        text("Describe the content of this video")
    }

    val response = model.generateContent(prompt)
  }
}

Java

ContentResolver resolver = getApplicationContext().getContentResolver();

try (InputStream stream = resolver.openInputStream(videoUri)) {
    File videoFile = new File(new URI(videoUri.toString()));
    int videoSize = (int) videoFile.length();
    byte[] videoBytes = new byte[videoSize];
    if (stream != null) {
        stream.read(videoBytes, 0, videoBytes.length);
        stream.close();

        // Provide a prompt that includes video specified earlier and text
        Content prompt = new Content.Builder()
                .addInlineData(videoBytes, "video/mp4")
                .addText("Describe the content of this video")
                .build();

        // To generate text output, call generateContent with the prompt
        ListenableFuture<GenerateContentResponse> response = model.generateContent(prompt);
        Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
            @Override
            public void onSuccess(GenerateContentResponse result) {
                String resultText = result.getText();
                System.out.println(resultText);
            }

            @Override
            public void onFailure(Throwable t) {
                t.printStackTrace();
            }
        }, executor);
    }
} catch (IOException e) {
    e.printStackTrace();
} catch (URISyntaxException e) {
    e.printStackTrace();
}

Benzer şekilde, PDF (application/pdf) ve düz metin (text/plain) dokümanlarını da ilgili MIME türlerini parametre olarak ileterek aktarabilirsiniz.

Çok adımlı sohbet

Çok adımlı sohbetleri de destekleyebilirsiniz. startChat() işleviyle sohbet başlatın. İsteğe bağlı olarak modele mesaj geçmişi sağlayabilirsiniz. Ardından, sohbet mesajları göndermek için sendMessage() işlevini çağırın.

Kotlin

val chat = model.startChat(
    history = listOf(
        content(role = "user") { text("Hello, I have 2 dogs in my house.") },
        content(role = "model") { text("Great to meet you. What would you like to know?")   }
    )
)

scope.launch {
   val response = chat.sendMessage("How many paws are in my house?")
}

Java

Content.Builder userContentBuilder = new Content.Builder();
userContentBuilder.setRole("user");
userContentBuilder.addText("Hello, I have 2 dogs in my house.");
Content userContent = userContentBuilder.build();

Content.Builder modelContentBuilder = new Content.Builder();
modelContentBuilder.setRole("model");
modelContentBuilder.addText("Great to meet you. What would you like to know?");
Content modelContent = userContentBuilder.build();

List<Content> history = Arrays.asList(userContent, modelContent);

// Initialize the chat
ChatFutures chat = model.startChat(history);

// Create a new user message
Content.Builder messageBuilder = new Content.Builder();
messageBuilder.setRole("user");
messageBuilder.addText("How many paws are in my house?");

Content message = messageBuilder.build();

// Send the message
ListenableFuture<GenerateContentResponse> response = chat.sendMessage(message);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        String resultText = result.getText();
        System.out.println(resultText);
    }

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

Resim oluşturma

Gemini 2.5 Flash Image modeli (diğer adıyla Nano Banana), dünya bilgisi ve akıl yürütme özelliklerinden yararlanarak görüntü oluşturup düzenleyebilir. Bağlamla alakalı görseller üretir, metin ve görsel çıkışlarını sorunsuz bir şekilde harmanlar veya araya ekler. Ayrıca, uzun metin dizileri içeren doğru görseller oluşturabilir ve bağlamı koruyarak etkileşimli resim düzenlemeyi destekler.

Gemini'a alternatif olarak, özellikle fotoğraf gerçekçiliği, sanatsal ayrıntı veya belirli stiller gerektiren yüksek kaliteli görüntü üretimi için Imagen modellerini kullanabilirsiniz. Ancak Android uygulamaları için istemci tarafındaki kullanım alanlarının çoğunda Gemini fazlasıyla yeterli olacaktır.

Bu kılavuzda, Android için Firebase AI Logic SDK'sını kullanarak Gemini 2.5 Flash Image modelinin nasıl kullanılacağı açıklanmaktadır. Gemini ile görsel oluşturma hakkında daha fazla bilgi için Firebase'de Gemini ile görsel oluşturma dokümanlarına bakın. Imagen modellerini kullanmak istiyorsanız dokümanlara göz atın.

Google AI Studio&#39;da görüntü üretme özellikleri gösteriliyor.
1. şekil. Görüntü oluşturma istemlerinizi iyileştirmek için Google AI Studio'yu kullanma

Üretken modeli başlatma

GenerativeModel oluşturun ve model adını gemini-2.5-flash-image-preview olarak belirtin. responseModalities değerini hem TEXT hem de IMAGE içerecek şekilde yapılandırdığınızı doğrulayın.

Kotlin

val model = Firebase.ai(backend = GenerativeBackend.googleAI()).generativeModel(
    modelName = "gemini-2.5-flash-image-preview",
    // Configure the model to respond with text and images (required)
    generationConfig = generationConfig {
        responseModalities = listOf(ResponseModality.TEXT,
        ResponseModality.IMAGE)
    }
)

Java

GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI()).generativeModel(
    "gemini-2.5-flash-image-preview",
    // Configure the model to respond with text and images (required)
    new GenerationConfig.Builder()
        .setResponseModalities(Arrays.asList(ResponseModality.TEXT, ResponseModality.IMAGE))
        .build()
);
GenerativeModelFutures model = GenerativeModelFutures.from(ai);

Resim oluşturma (yalnızca metin girişi)

Yalnızca metin içeren bir istem sağlayarak Gemini modelinden resim oluşturmasını isteyebilirsiniz:

Kotlin

// Provide a text prompt instructing the model to generate an image
val prompt = "A hyper realistic picture of a t-rex with a blue bag pack roaming a pre-historic forest."
// To generate image output, call `generateContent` with the text input
val generatedImageAsBitmap = model.generateContent(prompt)
.candidates.first().content.parts.filterIsInstance<ImagePart>()
.firstOrNull()?.image

Java

// Provide a text prompt instructing the model to generate an image
Content prompt = new Content.Builder()
    .addText("Generate an image of the Eiffel Tower with fireworks in the background.")
    .build();
// To generate an image, call `generateContent` with the text input
ListenableFuture<GenerateContentResponse> response = model.generateContent(prompt);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        // iterate over all the parts in the first candidate in the result object
        for (Part part : result.getCandidates().get(0).getContent().getParts()) {
            if (part instanceof ImagePart) {
                ImagePart imagePart = (ImagePart) part;
                // The returned image as a bitmap
                Bitmap generatedImageAsBitmap = imagePart.getImage();
                break;
            }
        }
    }
    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

Resimleri düzenleme (metin ve resim girişi)

İsteminizde hem metin hem de bir veya daha fazla resim sağlayarak Gemini modelinden mevcut resimleri düzenlemesini isteyebilirsiniz:

Kotlin

// Provide an image for the model to edit
val bitmap = BitmapFactory.decodeResource(context.resources, R.drawable.scones)
// Provide a text prompt instructing the model to edit the image
val prompt = content {
    image(bitmap)
    text("Edit this image to make it look like a cartoon")
}
// To edit the image, call `generateContent` with the prompt (image and text input)
val generatedImageAsBitmap = model.generateContent(prompt)
    .candidates.first().content.parts.filterIsInstance<ImagePart>().firstOrNull()?.image
// Handle the generated text and image

Java

// Provide an image for the model to edit
Bitmap bitmap = BitmapFactory.decodeResource(resources, R.drawable.scones);
// Provide a text prompt instructing the model to edit the image
Content promptcontent = new Content.Builder()
    .addImage(bitmap)
    .addText("Edit this image to make it look like a cartoon")
    .build();
// To edit the image, call `generateContent` with the prompt (image and text input)
ListenableFuture<GenerateContentResponse> response = model.generateContent(promptcontent);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        // iterate over all the parts in the first candidate in the result object
        for (Part part : result.getCandidates().get(0).getContent().getParts()) {
            if (part instanceof ImagePart) {
                ImagePart imagePart = (ImagePart) part;
                Bitmap generatedImageAsBitmap = imagePart.getImage();
                break;
            }
        }
    }
    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

Çok adımlı sohbetle resimleri yineleme ve düzenleme

Görüntü düzenlemeye yönelik sohbet tarzı bir yaklaşım için çok adımlı sohbeti kullanabilirsiniz. Bu sayede, orijinal resmi yeniden göndermeye gerek kalmadan düzenlemeleri iyileştirmek için takip istekleri gönderilebilir.

Öncelikle startChat() ile sohbet başlatın. İsterseniz mesaj geçmişi de sağlayabilirsiniz. Ardından, sonraki mesajlar için sendMessage() simgesini kullanın:

Kotlin

// Provide an image for the model to edit
val bitmap = BitmapFactory.decodeResource(context.resources, R.drawable.scones)
// Create the initial prompt instructing the model to edit the image
val prompt = content {
    image(bitmap)
    text("Edit this image to make it look like a cartoon")
}
// Initialize the chat
val chat = model.startChat()
// To generate an initial response, send a user message with the image and text prompt
var response = chat.sendMessage(prompt)
// Inspect the returned image
var generatedImageAsBitmap = response
    .candidates.first().content.parts.filterIsInstance<ImagePart>().firstOrNull()?.image
// Follow up requests do not need to specify the image again
response = chat.sendMessage("But make it old-school line drawing style")
generatedImageAsBitmap = response
    .candidates.first().content.parts.filterIsInstance<ImagePart>().firstOrNull()?.image

Java

// Provide an image for the model to edit
Bitmap bitmap = BitmapFactory.decodeResource(resources, R.drawable.scones);
// Initialize the chat
ChatFutures chat = model.startChat();
// Create the initial prompt instructing the model to edit the image
Content prompt = new Content.Builder()
    .setRole("user")
    .addImage(bitmap)
    .addText("Edit this image to make it look like a cartoon")
    .build();
// To generate an initial response, send a user message with the image and text prompt
ListenableFuture<GenerateContentResponse> response = chat.sendMessage(prompt);
// Extract the image from the initial response
ListenableFuture<@Nullable Bitmap> initialRequest = Futures.transform(response,
    result -> {
        for (Part part : result.getCandidates().get(0).getContent().getParts()) {
            if (part instanceof ImagePart) {
                ImagePart imagePart = (ImagePart) part;
                return imagePart.getImage();
            }
        }
        return null;
    }, executor);
// Follow up requests do not need to specify the image again
ListenableFuture<GenerateContentResponse> modelResponseFuture = Futures.transformAsync(
    initialRequest,
    generatedImage -> {
        Content followUpPrompt = new Content.Builder()
            .addText("But make it old-school line drawing style")
            .build();
        return chat.sendMessage(followUpPrompt);
    }, executor);
// Add a final callback to check the reworked image
Futures.addCallback(modelResponseFuture, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        for (Part part : result.getCandidates().get(0).getContent().getParts()) {
            if (part instanceof ImagePart) {
                ImagePart imagePart = (ImagePart) part;
                Bitmap generatedImageAsBitmap = imagePart.getImage();
                break;
            }
        }
    }
    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

En iyi uygulamalar ve sınırlamalar

  • Çıkış Biçimi: Resimler, maksimum boyutu 1024 piksel olan PNG'ler olarak oluşturulur.
  • Giriş Türleri: Model, görüntü oluşturma için ses veya video girişlerini desteklemez.
  • Dil Desteği: En iyi performans için aşağıdaki dilleri kullanın: İngilizce (en), Meksika İspanyolcası (es-mx), Japonca (ja-jp), Basitleştirilmiş Çince (zh-cn) ve Hintçe (hi-in).
  • Üretim Sorunları:
    • Resim üretimi her zaman tetiklenmeyebilir ve bazen yalnızca metin içeren bir çıktı elde edilebilir. Resim çıkışlarını açıkça istemeyi deneyin (ör. "generate an image", "provide images as you go along", "update the image").
    • Model, üretimi yarıda durdurabilir. Tekrar deneyin veya farklı bir istem kullanın.
    • Model, metni resim olarak oluşturabilir. Metin çıkışlarını açıkça istemeyi deneyin (ör. "generate narrative text along with illustrations").

Daha fazla ayrıntı için Firebase belgelerini inceleyin.

Sonraki adımlar