Die Gemini Developer API bietet Zugriff auf die Gemini-Modelle von Google. So können Sie in Ihre Android-Apps innovative generative KI-Funktionen einbauen, darunter Konversations-Chat, Bildgenerierung (mit Nano Banana) und Textgenerierung auf Grundlage von Text-, Bild-, Audio- und Videoeingaben.
Für den Zugriff auf die Modelle Gemini Pro und Flash können Sie die Gemini Developer API mit Firebase AI Logic verwenden. Sie können ohne Zahlungsmethode (z. B. Kreditkarte) starten und erhalten eine großzügige kostenlose Stufe. Nachdem Sie Ihre Integration mit einer kleinen Nutzerbasis validiert haben, können Sie sie durch ein Upgrade auf die kostenpflichtige Stufe skalieren.
Erste Schritte
Bevor Sie direkt über Ihre App mit der Gemini API interagieren können, müssen Sie einige Schritte ausführen. 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 Ausprobieren 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 integrierte Entwicklungsumgebung (IDE), mit der Sie Prompts für die Anwendungsfälle Ihrer App prototypisieren und entwerfen können.
Um effektive Prompts für Ihren Anwendungsfall zu erstellen, sind umfangreiche Tests erforderlich, die ein wichtiger Teil des Prozesses sind. Weitere Informationen zum Prompting
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 der Kurzanleitung für Firebase AI Logic, um Firebase einzurichten und die erforderlichen APIs und Dienste zu aktivieren.
Gradle-Abhängigkeiten hinzufügen
Fügen Sie Ihrem App-Modul die folgenden Gradle-Abhängigkeiten hinzu:
Kotlin
dependencies {
// ... other androidx dependencies
// Import the BoM for the Firebase platform
implementation(platform("com.google.firebase:firebase-bom:34.19.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")
}
Java
dependencies {
// Import the BoM for the Firebase platform
implementation(platform("com.google.firebase:34.19.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")
// 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")
}
App Check-Debug-Anbieter für die lokale Entwicklung konfigurieren
Ab Anfang Juli 2026 wird Firebase App Check im Rahmen des geführten Einrichtungsprozesses für AI Logic in der Firebase-Konsole automatisch erzwungen, um die Gemini API zu schützen. Für die lokale Entwicklung müssen Sie den App Check-Debug-Anbieter konfigurieren, um die Attestierung zu umgehen und gleichzeitig die Durchsetzung von App Check beizubehalten.
Konfigurieren Sie App Check in Ihrem Debug-Build so, dass die Debug-Anbieter-Factory verwendet wird:
Kotlin
Firebase.initialize(context = this) Firebase.appCheck.installAppCheckProviderFactory( DebugAppCheckProviderFactory.getInstance(), )Java
FirebaseApp.initializeApp(/*context=*/ this); FirebaseAppCheck firebaseAppCheck = FirebaseAppCheck.getInstance(); firebaseAppCheck.installAppCheckProviderFactory( DebugAppCheckProviderFactory.getInstance());Debug-Token abrufen:
Führen Sie Ihre App im Emulator oder auf Ihrem Testgerät aus.
Suchen Sie in Ihren Logs nach dem App Check-Debug-Token. Beispiel:
D DebugAppCheckProvider: Enter this debug secret into the allow list in the Firebase Console for your project: 123a4567-b89c-12d3-e456-789012345678Kopieren Sie das Token (z. B.
123a4567-b89c-12d3-e456-789012345678).
Registrieren Sie Ihr Debug-Token bei App Check:
Rufen Sie in der Firebase Console Sicherheit > App Check > Tab Apps auf.
Suchen Sie Ihre App, klicken Sie auf das Dreipunkt-Menü () und wählen Sie dann Debug-Tokens verwalten aus.
Folgen Sie der Anleitung auf dem Bildschirm, um Ihr Debug-Token zu registrieren.
Weitere Informationen zum Debugging-Anbieter (einschließlich der Vorgehensweise zum Abrufen eines neuen Debugging-Tokens) finden Sie in der offiziellen App Check-Dokumentation.
Generatives Modell initialisieren
Instanziieren Sie zuerst ein GenerativeModel und geben Sie den Modellnamen an:
Kotlin
// Start by instantiating a GenerativeModel and specifying the model name: val model = Firebase.ai(backend = GenerativeBackend.googleAI()) .generativeModel("gemini-3.5-flash")
Java
GenerativeModel firebaseAI = FirebaseAI.getInstance(GenerativeBackend.googleAI()) .generativeModel("gemini-3.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 lassen, 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
scope.launch { val contentResolver = applicationContext.contentResolver contentResolver.openInputStream(audioUri).use { stream -> stream?.let { val bytes = it.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 = applicationContext.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
scope.launch { val contentResolver = applicationContext.contentResolver contentResolver.openInputStream(videoUri).use { stream -> stream?.let { val bytes = it.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 = applicationContext.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 Mehrfachdialoge 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 = modelContentBuilder.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 mit Nano Banana auf Android-Geräten generieren
Die Gemini Image-Modelle (auch bekannt als Nano Banana-Modelle) können Bilder generieren und bearbeiten, indem sie Allgemeinwissen und Reasoning nutzen. Sie generieren kontextbezogene Bilder und fügen Text- und Bildausgaben nahtlos zusammen oder verschachteln sie. Sie können auch präzise Bilder mit langen Textsequenzen generieren und unterstützen die Bildbearbeitung per Prompt, wobei der Kontext beibehalten wird.
In dieser Anleitung wird beschrieben, wie Sie die Gemini-Bildmodelle (die Nano Banana-Modelle) mit dem Firebase AI Logic SDK für Android verwenden. Weitere Informationen zum Generieren von Bildern mit Gemini finden Sie in der Firebase-Dokumentation.
Generatives Modell initialisieren
Instanziieren Sie ein GenerativeModel und geben Sie einen Namen für das Gemini-Bildmodell an, z. B. gemini-3.1-flash-image. Konfigurieren Sie dann responseModalities so, dass sowohl TEXT als auch IMAGE enthalten sind, um verschachtelten Text und Bilder zu generieren. Wenn Sie TEXT ausschließen, gibt das Modell nur Bilder zurück.
Kotlin
val model = Firebase.ai(backend = GenerativeBackend.googleAI()).generativeModel( modelName = "gemini-3.1-flash-image", // Configure the model to respond with images (required) and text (optional) generationConfig = generationConfig { responseModalities = listOf( ResponseModality.TEXT, ResponseModality.IMAGE ) } )
Java
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI()).generativeModel( "gemini-3.1-flash-image", // 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
scope.launch { // 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: Bitmap? = 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
scope.launch { // 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: Bitmap? = 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 einen Multi-Turn-Chat iterieren und bearbeiten
Für einen dialogbasierten Ansatz bei der Bildbearbeitung können Sie Multi-Turn-Chats verwenden. So können Sie Folgeanfragen stellen, um Änderungen zu verfeinern, ohne das Originalbild noch einmal senden zu müssen.
Zuerst müssen Sie einen Chat mit startChat() initialisieren und optional einen Nachrichtenverlauf angeben. Verwenden Sie dann sendMessage() für nachfolgende Nachrichten:
Kotlin
scope.launch { // 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: Bitmap? = 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<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);
Überlegungen und Einschränkungen
Beachten Sie die folgenden Hinweise 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. „Bild generieren“, „Stellen Sie Bilder zur Verfügung“ oder „Aktualisieren Sie das Bild“.
- Das Modell kann die Generierung 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. „Erstelle einen narrativen Text mit Illustrationen“).
Weitere Informationen finden Sie in der Firebase-Dokumentation.
Nächste Schritte
Nachdem Sie Ihre App eingerichtet haben, sollten Sie die folgenden Schritte in Betracht ziehen:
- Sehen Sie sich die Firebase-Beispiel-App für Android-Schnellstart und den Android AI Sample Catalog auf GitHub an.
- Bereiten Sie Ihre App für die Produktion vor, einschließlich der Einrichtung von Firebase App Check, um die Gemini API vor Missbrauch durch nicht autorisierte Clients zu schützen.
- Weitere Informationen zu Firebase AI Logic