API Gemini per gli sviluppatori

Per accedere ai modelli Gemini Pro e Flash, consigliamo agli sviluppatori Android di utilizzare l'API Gemini Developer con Firebase AI Logic. Ti consente di iniziare senza richiedere una carta di credito e offre un generoso livello senza costi. Una volta convalidata l'integrazione con una piccola base utenti, puoi scalare passando al livello a pagamento.

Illustrazione di un'app per Android che contiene un SDK Firebase per Android. Una freccia punta dall'SDK a Firebase all'interno di un ambiente cloud. Da Firebase, un'altra freccia punta all'API Gemini Developer, che è collegata a Gemini Pro e Flash, anch'essi all'interno del cloud.
Figura 1. Architettura di integrazione di Firebase AI Logic per accedere all'API Gemini Developer.

Per iniziare

Prima di interagire con l'API Gemini direttamente dalla tua app, devi fare alcune cose, tra cui familiarizzare con i prompt e configurare Firebase e la tua app per utilizzare l'SDK.

Sperimentare con i prompt

Sperimentare con i prompt può aiutarti a trovare la formulazione, i contenuti e il formato migliori per la tua app per Android. Google AI Studio è un IDE che puoi utilizzare per prototipare e progettare prompt per i casi d'uso della tua app.

Creare il prompt giusto per il tuo caso d'uso è più arte che scienza, il che rende la sperimentazione fondamentale. Puoi scoprire di più sui prompt nella documentazione di Firebase.

Quando il prompt ti soddisfa, fai clic sul pulsante "<>" per ottenere gli snippet di codice che puoi aggiungere al tuo codice.

Configura un progetto Firebase e connetti la tua app a Firebase

Quando sei pronto per chiamare l'API dalla tua app, segui le istruzioni del "Passaggio 1" della Guida introduttiva a Firebase AI Logic per configurare Firebase e l'SDK nella tua app.

Aggiungi la dipendenza Gradle

Aggiungi la seguente dipendenza Gradle al modulo dell'app:

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

Inizializza il modello generativo

Inizia creando un'istanza di GenerativeModel e specificando il nome del modello:

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

Scopri di più sui modelli disponibili per l'utilizzo con l'API Gemini Developer. Puoi anche scoprire di più sulla configurazione dei parametri del modello.

Interagire con l'API Gemini Developer dalla tua app

Ora che hai configurato Firebase e la tua app per utilizzare l'SDK, puoi interagire con l'API Gemini Developer dalla tua app.

Genera testo

Per generare una risposta di testo, chiama il numero generateContent() con il tuo prompt.

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

Generare testo da immagini e altri contenuti multimediali

Puoi anche generare testo da un prompt che include testo più immagini o altri contenuti multimediali. Quando chiami generateContent(), puoi passare i contenuti multimediali come dati incorporati.

Ad esempio, per utilizzare una bitmap, utilizza il tipo di contenuti 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);

Per trasmettere un file audio, utilizza il tipo di contenuti 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);
}

Per fornire un file video, continua a utilizzare il tipo di contenuti 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();
}

Allo stesso modo, puoi anche trasmettere documenti PDF (application/pdf) e di testo normale (text/plain) passando il rispettivo tipo MIME come parametro.

Chat multi-turno

Puoi anche supportare conversazioni a più turni. Inizializza una chat con la funzione startChat(). Se vuoi, puoi fornire al modello una cronologia dei messaggi. Poi chiama la funzione sendMessage() per inviare messaggi di 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 = 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);

Genera immagini

Il modello Gemini 2.5 Flash Image (alias Nano Banana) può generare e modificare immagini sfruttando la conoscenza del mondo e il ragionamento. Genera immagini pertinenti al contesto, mescolando o alternando in modo fluido testo e immagini. Può anche generare immagini accurate con sequenze di testo lunghe e supporta la modifica delle immagini conversazionale mantenendo il contesto.

In alternativa a Gemini, puoi utilizzare i modelli Imagen, in particolare per la generazione di immagini di alta qualità che richiedono fotorealismo, dettagli artistici o stili specifici. Tuttavia, per la maggior parte dei casi d'uso lato client per le app per Android, Gemini sarà più che sufficiente.

Questa guida descrive come utilizzare il modello Gemini 2.5 Flash Image utilizzando l'SDK Firebase AI Logic per Android. Per ulteriori dettagli sulla generazione di immagini con Gemini, consulta la documentazione Generare immagini con Gemini su Firebase. Se ti interessa utilizzare i modelli Imagen, consulta la documentazione.

Google AI Studio che mostra le funzionalità di generazione di immagini.
Figura 1. Utilizza Google AI Studio per perfezionare i prompt di generazione delle immagini

Inizializza il modello generativo

Crea un'istanza di GenerativeModel e specifica il nome del modello gemini-2.5-flash-image-preview. Verifica di aver configurato responseModalities in modo da includere sia TEXT che 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);

Generare immagini (input solo di testo)

Puoi chiedere a un modello Gemini di generare immagini fornendo un prompt solo di testo:

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

Modificare le immagini (input di testo e immagini)

Puoi chiedere a un modello Gemini di modificare le immagini esistenti fornendo sia testo che una o più immagini nel prompt:

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

Iterare e modificare le immagini tramite la chat in più turni

Per un approccio conversazionale all'editing delle immagini, puoi utilizzare la chat multi-turno. Ciò consente di inviare richieste di follow-up per perfezionare le modifiche senza dover inviare nuovamente l'immagine originale.

Innanzitutto, inizializza una chat con startChat(), fornendo facoltativamente una cronologia dei messaggi. Poi, utilizza sendMessage() per i messaggi successivi:

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 practice e limitazioni

  • Formato di output: le immagini vengono generate come PNG con una dimensione massima di 1024 px.
  • Tipi di input: il modello non supporta input audio o video per la generazione di immagini.
  • Supporto delle lingue: per prestazioni ottimali, utilizza le seguenti lingue: inglese (en), spagnolo messicano (es-mx), giapponese (ja-jp), cinese semplificato (zh-cn) e hindi (hi-in).
  • Problemi di generazione:
    • La generazione di immagini potrebbe non essere sempre attivata, a volte con un output solo di testo. Prova a chiedere esplicitamente output di immagini (ad es. "genera un'immagine", "fornisci immagini man mano", "aggiorna l'immagine").
    • Il modello potrebbe interrompere la generazione a metà. Riprova o prova un prompt diverso.
    • Il modello potrebbe generare testo come immagine. Prova a chiedere esplicitamente output di testo (ad es. genera un testo narrativo insieme alle illustrazioni.

Per ulteriori dettagli, consulta la documentazione di Firebase.

Passaggi successivi