Gemini Developer API

Aby uzyskać dostęp do modeli Gemini Pro i Flash, deweloperzy aplikacji na Androida powinni użyć interfejsu Gemini Developer API za pomocą logiki AI w Firebase. Pozwala ona rozpocząć korzystanie z usługi bez konieczności podawania danych karty kredytowej i zawiera obszerny bezpłatny poziom. Po zweryfikowaniu integracji z niewielką grupą użytkowników możesz ją rozszerzyć, przechodząc na wersję płatną.

Ilustracja aplikacji na Androida zawierającej pakiet SDK Firebase na Androida. Strzałka wskazuje z pakietu SDK na Firebase w środowisku Cloud. Z Firebase prowadzi kolejna strzałka do interfejsu Gemini Developer API, który jest połączony z Gemini Pro & Flash, również w Google Cloud.
Rysunek 1. Architektura integracji Firebase AI Logic umożliwiająca dostęp do interfejsu Gemini Developer API.

Pierwsze kroki

Zanim zaczniesz korzystać z interfejsu Gemini API bezpośrednio z aplikacji, musisz wykonać kilka czynności, m.in. zapoznać się z wyświetlaniem promptów i skonfigurować Firebase oraz aplikację, aby używać pakietu SDK.

Eksperymentowanie z promptami

Eksperymentowanie z promptami może pomóc Ci znaleźć najlepsze sformułowanie, treść i format dla aplikacji na Androida. Google AI Studio to środowisko IDE, którego możesz używać do tworzenia prototypów i projektowania promptów do swoich aplikacji.

Stworzenie odpowiedniego promptu do danego zastosowania to bardziej sztuka niż nauka, dlatego eksperymentowanie jest kluczowe. Więcej informacji o promptach znajdziesz w dokumentacji Firebase.

Gdy będziesz zadowolony/zadowolona z promptu, kliknij przycisk „<>", aby uzyskać fragmenty kodu, które możesz dodać do swojego kodu.

Konfigurowanie projektu Firebase i łączenie z nim aplikacji

Gdy będziesz gotowy do wywołania interfejsu API z aplikacji, postępuj zgodnie z instrukcjami w sekcji „Krok 1” w przewodniku korzystania z logiki AI w Firebase, aby skonfigurować Firebase i pakiet SDK w swojej aplikacji.

Dodawanie zależności Gradle

Dodaj do modułu aplikacji tę zależność Gradle:

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

Inicjalizacja modelu generatywnego

Zacznij od utworzenia instancji GenerativeModel i podania nazwy modelu:

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

Dowiedz się więcej o dostępnych modelach do użycia z interfejsem Developer API Gemini. Możesz też dowiedzieć się więcej o konfigurowaniu parametrów modelu.

Interakcja z interfejsem Gemini Developer API z aplikacji

Po skonfigurowaniu Firebase i aplikacji pod kątem użycia pakietu SDK możesz już z niej korzystać z interfejsu API dla deweloperów Gemini.

Generowanie tekstu

Aby wygenerować odpowiedź tekstową, wywołaj generateContent() z promptem.

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

generować tekst na podstawie obrazów i innych multimediów;

Możesz też wygenerować tekst na podstawie prompta zawierającego tekst oraz obrazy lub inne multimedia. Gdy wywołujesz funkcję generateContent(), możesz przekazywać dane multimedialne jako dane wbudowane.

Aby na przykład użyć bitmapy, użyj typu treści 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);

Aby przesłać plik audio, użyj typu treści 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);
}

Aby przesłać plik wideo, nadal używaj typu treści 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();
}

Podobnie możesz też przekazywać dokumenty PDF (application/pdf) i zwykłe teksty (text/plain), podając ich odpowiedni typ MIME jako parametr.

Czat wieloetapowy

Możesz też obsługiwać rozmowy wieloetapowe. Inicjowanie czatu za pomocą funkcji startChat(). Opcjonalnie możesz udostępnić modelowi historię wiadomości. Następnie wywołaj funkcję sendMessage(), aby wysłać wiadomości na czacie.

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

Aby dowiedzieć się więcej, zapoznaj się z dokumentacją Firebase.

Dalsze kroki