Gemini Developer API

Für den Zugriff auf die Modelle Gemini Pro und Flash empfehlen wir Android-Entwicklern, die Gemini Developer API mit Firebase AI Logic zu verwenden. Sie können ohne Kreditkarte loslegen und profitieren von einer großzügigen kostenlosen Stufe. Nachdem Sie Ihre Integration mit einer kleinen Nutzerbasis getestet haben, können Sie sie skalieren, indem Sie auf die kostenpflichtige Stufe umstellen.

Abbildung einer Android-App, die ein Firebase Android SDK enthält. Ein Pfeil zeigt vom SDK zu Firebase in einer Cloud-Umgebung. Von Firebase aus zeigt ein weiterer Pfeil auf die Gemini Developer API, die mit Gemini Pro und Flash verbunden ist, ebenfalls in der Cloud.
Abbildung 1: Architektur der Firebase AI Logic-Integration für den Zugriff auf die Gemini Developer API.

Erste Schritte

Bevor Sie direkt über Ihre App mit der Gemini API interagieren können, müssen Sie einige Dinge erledigen. Dazu gehört, sich mit Prompts vertraut zu machen und Firebase und Ihre App für die Verwendung des SDK einzurichten.

Prompts ausprobieren

Durch das Testen von Prompts können Sie die beste Formulierung, den besten Inhalt und das beste Format für Ihre Android-App finden. Google AI Studio ist eine IDE, mit der Sie Prompts für die Anwendungsfälle Ihrer App prototypisieren und entwerfen können.

Den richtigen Prompt für Ihren Anwendungsfall zu erstellen, ist eher eine Kunst als eine Wissenschaft. Daher ist es wichtig, verschiedene Prompts auszuprobieren. Weitere Informationen zu Aufforderungen finden Sie in der Firebase-Dokumentation.

Wenn Sie mit Ihrem Prompt zufrieden sind, klicken Sie auf die Schaltfläche „<>“, um Code-Snippets zu erhalten, die Sie Ihrem Code hinzufügen können.

Firebase-Projekt einrichten und App mit Firebase verbinden

Wenn Sie bereit sind, die API aus Ihrer App aufzurufen, folgen Sie der Anleitung in Schritt 1 des Firebase AI Logic-Startleitfadens, um Firebase und das SDK in Ihrer App einzurichten.

Gradle-Abhängigkeit hinzufügen

Fügen Sie Ihrem App-Modul die folgende Gradle-Abhängigkeit hinzu:

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

Generatives Modell initialisieren

Instanziieren Sie zuerst ein GenerativeModel und geben Sie den Modellnamen an:

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

Weitere Informationen zu den verfügbaren Modellen für die Verwendung mit der Gemini Developer API Weitere Informationen zum Konfigurieren von Modellparametern

Mit der Gemini Developer API über Ihre App interagieren

Nachdem Sie Firebase und Ihre App für die Verwendung des SDK eingerichtet haben, können Sie über Ihre App mit der Gemini Developer API interagieren.

Text generieren

Rufen Sie generateContent() mit Ihrem Prompt auf, um eine Textantwort zu generieren.

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

Text aus Bildern und anderen Medien generieren

Sie können auch Text aus einem Prompt generieren, der Text sowie Bilder oder andere Medien enthält. Wenn Sie generateContent() aufrufen, können Sie die Media als Inline-Daten übergeben.

Wenn Sie beispielsweise eine Bitmap verwenden möchten, verwenden Sie den Inhaltstyp image:

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

Wenn Sie eine Audiodatei übergeben möchten, verwenden Sie den Inhaltstyp inlineData:

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

Wenn Sie eine Videodatei bereitstellen möchten, verwenden Sie weiterhin den Inhaltstyp inlineData:

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

Sie können auch PDF- (application/pdf) und Nur-Text-Dokumente (text/plain) übergeben, indem Sie den entsprechenden MIME-Typ als Parameter übergeben.

Wechselseitiger Chat

Sie können auch Unterhaltungen über mehrere Themen unterstützen. Initialisieren Sie einen Chat mit der Funktion startChat(). Optional können Sie dem Modell einen Nachrichtenverlauf zur Verfügung stellen. Rufen Sie dann die Funktion sendMessage() auf, um Chatnachrichten zu senden.

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

Bilder erstellen

Das Modell „Gemini 2.5 Flash Image“ (auch bekannt als „Nano Banana“) kann Bilder generieren und bearbeiten, indem es Weltwissen und Reasoning nutzt. Sie generiert kontextbezogene Bilder und mischt oder verschachtelt Text- und Bildausgaben nahtlos. Außerdem können damit präzise Bilder mit langen Textsequenzen generiert werden. Die konversationelle Bildbearbeitung wird unterstützt, wobei der Kontext beibehalten wird.

Als Alternative zu Gemini können Sie Imagen-Modelle verwenden, insbesondere für die hochwertige Bildgenerierung, die Fotorealismus, künstlerische Details oder bestimmte Stile erfordert. Für die meisten clientseitigen Anwendungsfälle für Android-Apps ist Gemini jedoch mehr als ausreichend.

In diesem Leitfaden wird beschrieben, wie Sie das Gemini 2.5 Flash Image-Modell mit dem Firebase AI Logic SDK für Android verwenden. Weitere Informationen zum Generieren von Bildern mit Gemini finden Sie in der Dokumentation Bilder mit Gemini in Firebase generieren. Wenn Sie Imagen-Modelle verwenden möchten, lesen Sie die Dokumentation.

Google AI Studio mit Funktionen zur Bildgenerierung.
Abbildung 1: Prompts für die Bildgenerierung mit Google AI Studio optimieren

Generatives Modell initialisieren

Instanziieren Sie ein GenerativeModel und geben Sie den Modellnamen gemini-2.5-flash-image-preview an. Prüfen Sie, ob responseModalities so konfiguriert ist, dass sowohl TEXT als auch IMAGE enthalten sind.

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

Bilder generieren (nur Texteingabe)

Sie können ein Gemini-Modell anweisen, Bilder zu generieren, indem Sie einen reinen Text-Prompt angeben:

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

Bilder bearbeiten (Text- und Bildeingabe)

Sie können ein Gemini-Modell bitten, vorhandene Bilder zu bearbeiten, indem Sie in Ihrem Prompt sowohl Text als auch ein oder mehrere Bilder angeben:

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

Bilder über Multi-Turn-Chat iterieren und bearbeiten

Wenn Sie Bilder lieber im Chat bearbeiten möchten, können Sie den Multi-Turn-Chat verwenden. So können Sie Folgeanfragen stellen, um Änderungen zu verfeinern, ohne das Originalbild noch einmal senden zu müssen.

Initialisieren Sie zuerst einen Chat mit startChat() und geben Sie optional einen Nachrichtenverlauf an. Verwenden Sie dann sendMessage() für nachfolgende Nachrichten:

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

Best Practices und Einschränkungen

  • Ausgabeformat: Bilder werden als PNGs mit einer maximalen Abmessung von 1.024 Pixeln generiert.
  • Eingabetypen: Das Modell unterstützt keine Audio- oder Videoeingaben für die Bildgenerierung.
  • Sprachunterstützung: Für eine optimale Leistung sollten Sie die folgenden Sprachen verwenden: Englisch (en), Mexikanisches Spanisch (es-mx), Japanisch (ja-jp), Vereinfachtes Chinesisch (zh-cn) und Hindi (hi-in).
  • Probleme bei der Generierung:
    • Die Bildgenerierung wird möglicherweise nicht immer ausgelöst, was manchmal zu einer reinen Textausgabe führt. Bitten Sie explizit um Bildausgaben (z.B. „generiere ein Bild“, „stelle Bilder zur Verfügung“, „aktualisiere das Bild“).
    • Das Modell kann die Generierung von Inhalten mittendrin beenden. Versuchen Sie es noch einmal oder verwenden Sie einen anderen Prompt.
    • Das Modell kann Text als Bild generieren. Fordern Sie Textausgaben explizit an (z.B. „generiere narrativen Text zusammen mit Illustrationen“).

Weitere Informationen finden Sie in der Firebase-Dokumentation.

Nächste Schritte