API Gemini per gli sviluppatori

L'API Gemini Developer ti dà accesso ai modelli Gemini di Google, consentendoti di integrare funzionalità di AI generativa all'avanguardia nelle tue app Android, tra cui chat conversazionale, generazione di immagini (con Nano Banana) e generazione di testo basata su input di testo, immagini, audio e video.

Per accedere ai modelli Gemini Pro e Flash, puoi utilizzare l'API Gemini Developer con Firebase AI Logic. Ti consente di iniziare senza richiedere una carta di credito e fornisce un livello senza costi con molti vantaggi. Una volta convalidata l'integrazione con una piccola base di 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, dovrai eseguire alcune operazioni, tra cui familiarizzare con i prompt e configurare Firebase e la tua app per utilizzare l'SDK.

Sperimenta 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 ambiente di sviluppo integrato (IDE) che puoi utilizzare per prototipare e progettare prompt per i casi d'uso della tua app.

La creazione di prompt efficaci per il tuo caso d'uso comporta una sperimentazione approfondita, che è una parte fondamentale del processo. Puoi scoprire di più sui prompt in la documentazione di Firebase.

Una volta che il prompt ti soddisfa, fai clic sul pulsante <> per ottenere 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 riportate nel "Passaggio 1" della guida introduttiva di 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.12.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.12.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

// Start by instantiating a GenerativeModel and specifying the model name:
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
    .generativeModel("gemini-2.5-flash")
GeminiDeveloperApiSnippets.kt

Java

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

GenerativeModelFutures model = GenerativeModelFutures.from(firebaseAI);
GeminiDeveloperApiSnippetsJava.java

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.

Interagisci 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 generateContent() con il prompt.

Kotlin

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

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);
GeminiDeveloperApiSnippetsJava.java

Genera 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 in linea.

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?")
        }
    )
}
GeminiDeveloperApiSnippets.kt

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);
GeminiDeveloperApiSnippetsJava.java

Per passare un file audio, utilizza il tipo di contenuti 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)
        }
    }
}
GeminiDeveloperApiSnippets.kt

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);
}
GeminiDeveloperApiSnippetsJava.java

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

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

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

Chat a più turni

Puoi anche supportare le conversazioni multi-turno. Inizializza una chat con la funzione startChat(). Facoltativamente, puoi fornire al modello una cronologia dei messaggi. Quindi 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?")
}
GeminiDeveloperApiSnippets.kt

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);
GeminiDeveloperApiSnippetsJava.java

Genera immagini su Android con Nano Banana

Il modello Gemini 2.5 Flash Image (noto anche come Nano Banana) può generare e modificare immagini sfruttando la conoscenza e il ragionamento del mondo. Genera immagini contestualmente pertinenti, combinando o alternando senza problemi testo e output di immagini. Può anche generare immagini accurate con sequenze di testo lunghe e supporta la modifica conversazionale delle immagini 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 Android, Gemini sarà più che sufficiente.

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

Interfaccia di Google AI Studio che mostra un campo di immissione di testo con il prompt &quot;Un&#39;immagine iperrealistica di un T-rex con uno zaino blu che si aggira in una foresta preistorica&quot; e un&#39;immagine generata di un T-rex in una foresta con uno zaino blu.
Figura 2. Utilizza Google AI Studio per perfezionare i prompt di generazione di immagini di Nano Banana per Android

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 sia 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
        )
    }
)
GeminiDeveloperApiSnippets.kt

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);
GeminiDeveloperApiSnippetsJava.java

Genera immagini (input solo testo)

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

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
}
GeminiDeveloperApiSnippets.kt

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);
GeminiDeveloperApiSnippetsJava.java

Modifica le immagini (input di testo e immagini)

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

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
}
GeminiDeveloperApiSnippets.kt

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);
GeminiDeveloperApiSnippetsJava.java

Itera e modifica le immagini tramite la chat a più turni

Per un approccio conversazionale alla modifica delle immagini, puoi utilizzare la chat a più turni. In questo modo, puoi inviare richieste di follow-up per perfezionare le modifiche senza dover inviare di nuovo l'immagine originale.

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

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
}
GeminiDeveloperApiSnippets.kt

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);
GeminiDeveloperApiSnippetsJava.java

Considerazioni e limitazioni

Tieni presenti le seguenti considerazioni 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 linguistico: 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 di solo testo. Prova a chiedere esplicitamente gli output di immagini (ad esempio, "genera un'immagine", "fornisci immagini man mano", "aggiorna l'immagine").
    • Il modello potrebbe interrompere la generazione a metà. Riprova o prova un altro prompt.
    • Il modello potrebbe generare testo come immagine. Prova a chiedere esplicitamente gli output di testo (ad esempio, "genera testo narrativo insieme alle illustrazioni").

Per maggiori dettagli, consulta la documentazione di Firebase.

Passaggi successivi

Dopo aver configurato l'app, valuta i seguenti passaggi successivi: