L'API Gemini Developer vous donne accès aux modèles Gemini de Google, ce qui vous permet d'intégrer des fonctionnalités d'IA générative de pointe dans vos applications Android, y compris le chat conversationnel, la génération d'images (avec Nano Banana) et la génération de texte basée sur des entrées de texte, d'image, audio et vidéo.
Pour accéder aux modèles Gemini Pro et Flash, vous pouvez utiliser l'API Gemini Developer avec Firebase AI Logic. Vous pouvez ainsi commencer sans carte de crédit et bénéficier d'un niveau sans frais avantageux. Une fois que vous avez validé votre intégration auprès d'un petit nombre d'utilisateurs, vous pouvez passer au niveau payant.
Premiers pas
Avant d'interagir avec l'API Gemini directement depuis votre application, vous devez effectuer quelques opérations, y compris vous familiariser avec les requêtes, ainsi que configurer Firebase et votre application pour utiliser le SDK.
Tester des requêtes
La création de requêtes efficaces pour votre cas d'utilisation implique de nombreux tests, ce qui est une partie essentielle du processus. Pour en savoir plus sur les requêtes, consultez la documentation Firebase.
Une fois que vous êtes satisfait de votre requête, cliquez sur le bouton <> pour obtenir des extraits de code que vous pouvez ajouter à votre code.
Configurer un projet Firebase et associer votre application à Firebase
Lorsque vous êtes prêt à appeler l'API depuis votre application, suivez les instructions de l'étape 1 du guide de démarrage de Firebase AI Logic pour configurer Firebase et le SDK dans votre application.
Ajouter la dépendance Gradle
Ajoutez la dépendance Gradle suivante à votre module d'application :
Kotlin
dependencies { // ... other androidx dependencies // Import the BoM for the Firebase platform implementation(platform("com.google.firebase:firebase-bom:34.11.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.11.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") }
Initialiser le modèle génératif
Commencez par instancier un GenerativeModel et spécifiez le nom du modèle :
Kotlin
// Start by instantiating a GenerativeModel and specifying the model name: 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);
En savoir plus sur les modèles disponibles pour une utilisation avec l'API Gemini Developer Vous pouvez également en savoir plus sur la configuration des paramètres du modèle.
Interagir avec l'API Gemini Developer depuis votre application
Maintenant que vous avez configuré Firebase et votre application pour utiliser le SDK, vous êtes prêt à interagir avec l'API Gemini Developer depuis votre application.
Générer du texte
Pour générer une réponse textuelle, appelez generateContent() avec votre requête.
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);
Générer du texte à partir d'images et d'autres contenus multimédias
Vous pouvez également générer du texte à partir d'une requête qui inclut du texte, ainsi que des images ou d'autres contenus multimédias. Lorsque vous appelez generateContent(), vous pouvez transmettre le contenu multimédia en tant que données intégrées.
Par exemple, pour utiliser un bitmap, utilisez le type de contenu 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);
Pour transmettre un fichier audio, utilisez le type de contenu 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); }
Pour fournir un fichier vidéo, continuez à utiliser le type de contenu 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(); }
De même, vous pouvez également transmettre des documents PDF (application/pdf) et en texte brut (text/plain) en transmettant leur type MIME respectif en tant que paramètre.
Chat multitour
Vous pouvez également prendre en charge les conversations multitours. Initialisez un chat avec la fonction startChat(). Vous pouvez éventuellement fournir à votre modèle un historique des messages. Appelez ensuite la fonction sendMessage() pour envoyer des messages de chat.
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);
Générer des images sur Android avec Nano Banana
Le modèle Gemini 2.5 Flash Image (alias Nano Banana) peut générer et modifier des images en s'appuyant sur des connaissances et un raisonnement mondiaux. Il génère des images contextuellement pertinentes, en mélangeant ou en entrelaçant de manière transparente les sorties de texte et d'image. Il peut également générer des visuels précis avec de longues séquences de texte et prendre en charge la modification d'images conversationnelles tout en conservant le contexte.
Au lieu de Gemini, vous pouvez utiliser des modèles Imagen, en particulier pour la génération d'images de haute qualité nécessitant un photoréalisme, des détails artistiques ou des styles spécifiques. Toutefois, pour la majorité des cas d'utilisation côté client pour les applications Android, Gemini sera plus que suffisant.
Ce guide explique comment utiliser le modèle Gemini 2.5 Flash Image (Nano Banana) à l'aide du SDK Firebase AI Logic pour Android. Pour en savoir plus sur la génération d'images avec Gemini, consultez la documentation Générer des images avec Gemini sur Firebase. Si vous souhaitez utiliser des modèles Imagen, consultez la documentation.
Initialiser le modèle génératif
Instanciez un GenerativeModel et spécifiez le nom du modèle gemini-2.5-flash-image-preview. Vérifiez que vous configurez responseModalities pour inclure à la fois TEXT et IMAGE.
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);
Générer des images (entrée de texte uniquement)
Vous pouvez demander à un modèle Gemini de générer des images en fournissant une requête de texte uniquement :
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);
Modifier des images (entrée de texte et d'image)
Vous pouvez demander à un modèle Gemini de modifier des images existantes en fournissant à la fois du texte et une ou plusieurs images dans votre requête :
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);
Itérer et modifier des images via un chat multitour
Pour une approche conversationnelle de la retouche d'images, vous pouvez utiliser un chat multitour. Cela permet d'affiner les modifications sans avoir à renvoyer l'image d'origine.
Commencez par initialiser un chat avec startChat(), en fournissant éventuellement un historique des messages. Utilisez ensuite sendMessage() pour les messages suivants :
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);
Remarques et limites
Prenez note des remarques et limites suivantes :
- Format de sortie : les images sont générées au format PNG avec une dimension maximale de 1 024 px.
- Types d'entrée : le modèle n'est pas compatible avec les entrées audio ou vidéo pour la génération d'images.
- Langues compatibles : pour des performances optimales, utilisez les langues suivantes :
anglais (
en), espagnol mexicain (es-mx), japonais (ja-jp), chinois simplifié (zh-cn) et hindi (hi-in). - Problèmes de génération:
- La génération d'images ne se déclenche pas toujours, ce qui entraîne parfois une sortie de texte uniquement. Essayez de demander explicitement des sorties d'image (par exemple, "générer une image", "fournir des images au fur et à mesure", "mettre à jour l'image").
- Le modèle peut arrêter la génération en cours de route. Réessayez ou essayez une autre requête.
- Le modèle peut générer du texte sous forme d'image. Essayez de demander explicitement des sorties de texte (par exemple, "générer un texte narratif avec des illustrations").
Pour en savoir plus, consultez la documentation Firebase.
Étapes suivantes
Après avoir configuré votre application, envisagez les étapes suivantes :
- Consultez l'exemple d'application Firebase de démarrage rapide pour Android et le catalogue d'exemples d'IA pour Android sur GitHub.
- Préparez votre application pour la production, y compris en configurant Firebase App Check pour protéger l'API Gemini contre les utilisations abusives par des clients non autorisés.
- Pour en savoir plus sur Firebase AI Logic, consultez la documentation Firebase.