API Gemini per gli sviluppatori

Per accedere ai modelli Gemini Pro e Flash, consigliamo agli sviluppatori Android di utilizzare l'API Gemini Developer con la logica AI di Firebase. Ti consente di iniziare senza richiedere una carta di credito e offre un generoso livello senza costi. Dopo aver confermato l'integrazione con una base utenti ridotta, puoi eseguire il ridimensionamento passando al livello a pagamento.

Illustrazione di un'app per Android contenente un SDK Firebase per Android. Una freccia indica il percorso dall'SDK a Firebase all'interno di un ambiente Cloud. Da Firebase, un'altra freccia indica l'API Gemini Developer, collegata a Gemini Pro e Flash, sempre all'interno di 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 svolgere alcune operazioni preliminari, ad esempio familiarizzare con i prompt e configurare Firebase e la tua app per utilizzare l'SDK.

Sperimenta con i prompt

Fare esperimenti 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 realizzare prototipi e progettare prompt per i casi d'uso della tua app.

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

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

Configura un progetto Firebase e connetti la tua app a Firebase

Quando è tutto pronto per chiamare l'API dalla tua app, segui le istruzioni riportate in "Passaggio 1" della guida introduttiva alla logica AI di Firebase 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:33.13.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:firebase-bom:33.13.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.0-flash")

Java

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

GenerativeModelFutures model = GenerativeModelFutures.from(firebaseAI);

Scopri di più sui modelli disponibili da utilizzare 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 per gli sviluppatori dalla tua app.

Genera testo

Per generare una risposta di testo, chiama 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);

Genera testo da immagini e altri contenuti multimediali

Puoi anche generare testo da un prompt che include testo, 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?")
    }
  )
}

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

Analogamente, puoi anche passare 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. 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?")
}

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

Per ulteriori dettagli, consulta la documentazione di Firebase.

Passaggi successivi