Analizowanie plików audio za pomocą interfejsu Gemini API

Możesz poprosić model Gemini o przeanalizowanie plików audio, które podasz w treści (zakodowane w formacie base64) lub za pomocą adresu URL. Gdy używasz Firebase AI Logic, możesz wysłać to żądanie bezpośrednio z aplikacji.

Dzięki tej funkcji możesz m.in.:

• opisywać, podsumowywać treści audio lub odpowiadać na pytania dotyczące tych treści;
• Transkrypcja treści audio
• Analizowanie konkretnych segmentów dźwięku za pomocą sygnatur czasowych

Przejdź do przykładowych fragmentów kodu Przejdź do kodu dla odpowiedzi przesyłanych strumieniowo

Inne przewodniki z dodatkowymi opcjami pracy z dźwiękiem Generowanie uporządkowanych danych wyjściowych Wielokrotne rozmowy Streaming dwukierunkowy

Zanim zaczniesz

Kliknij dostawcę Gemini API, aby wyświetlić na tej stronie treści i kod dostawcy. Gemini Developer API Vertex AI Gemini API

Jeśli jeszcze tego nie zrobisz, zapoznaj się z przewodnikiem dla początkujących, w którym znajdziesz informacje o tym, jak skonfigurować projekt Firebase, połączyć aplikację z Firebase, dodać pakiet SDK, zainicjować usługę backendu dla wybranego dostawcy Gemini API i utworzyć instancję GenerativeModel.

W tym przewodniku przyjęto założenie, że używasz najnowszych pakietów SDK.Firebase AI Logic Jeśli nadal korzystasz z pakietów SDK „Vertex AI in Firebase”, zapoznaj się z przewodnikiem po migracji.

Do testowania i ulepszania promptów, a nawet uzyskiwania wygenerowanego fragmentu kodu zalecamy używanie Google AI Studio.

Potrzebujesz przykładowego pliku audio?

Możesz użyć tego publicznie dostępnego pliku o typie MIME audio/mp3 (wyświetl lub pobierz plik).https://storage.googleapis.com/cloud-samples-data/generative-ai/audio/pixel.mp3

Generowanie tekstu z plików audio (zakodowanych w standardzie base64)

Zanim wypróbujesz ten przykład, zapoznaj się z sekcją Zanim zaczniesz w tym przewodniku, aby skonfigurować projekt i aplikację. W tej sekcji klikniesz też przycisk wybranego dostawcyGemini API, aby na tej stronie wyświetlały się treści dotyczące tego dostawcy.

Możesz poprosić model Gemini o wygenerowanie tekstu, podając tekst i dźwięk, czyli mimeType pliku wejściowego i sam plik. Wymagania i rekomendacje dotyczące plików wejściowych znajdziesz w dalszej części tej strony.

Ważne: łączny rozmiar żądania nie może przekraczać 20 MB. Aby wysyłać duże pliki, zapoznaj się z opcjami przesyłania plików w żądaniach multimodalnych.

Swift

Możesz wywołać funkcję generateContent() w celu wygenerowania tekstu na podstawie multimodalnych danych wejściowych składających się z tekstu i jednego pliku audio.

import FirebaseAI

// Initialize the Gemini Developer API backend service
let ai = FirebaseAI.firebaseAI(backend: .googleAI())

// Create a `GenerativeModel` instance with a model that supports your use case
let model = ai.generativeModel(modelName: "gemini-2.5-flash")


// Provide the audio as `Data`
guard let audioData = try? Data(contentsOf: audioURL) else {
    print("Error loading audio data.")
    return // Or handle the error appropriately
}

// Specify the appropriate audio MIME type
let audio = InlineDataPart(data: audioData, mimeType: "audio/mpeg")


// Provide a text prompt to include with the audio
let prompt = "Transcribe what's said in this audio recording."

// To generate text output, call `generateContent` with the audio and text prompt
let response = try await model.generateContent(audio, prompt)

// Print the generated text, handling the case where it might be nil
print(response.text ?? "No text in response.")

Kotlin

Możesz wywołać funkcję generateContent() w celu wygenerowania tekstu na podstawie multimodalnych danych wejściowych składających się z tekstu i jednego pliku audio.

^{W przypadku Kotlina metody w tym pakiecie SDK są funkcjami zawieszającymi i muszą być wywoływane w zakresie Coroutine.}

// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
                        .generativeModel("gemini-2.5-flash")


val contentResolver = applicationContext.contentResolver

val inputStream = contentResolver.openInputStream(audioUri)

if (inputStream != null) {  // Check if the audio loaded successfully
    inputStream.use { stream ->
        val bytes = stream.readBytes()

        // Provide a prompt that includes the audio specified above and text
        val prompt = content {
            inlineData(bytes, "audio/mpeg")  // Specify the appropriate audio MIME type
            text("Transcribe what's said in this audio recording.")
        }

        // To generate text output, call `generateContent` with the prompt
        val response = generativeModel.generateContent(prompt)

        // Log the generated text, handling the case where it might be null
        Log.d(TAG, response.text?: "")
    }
} else {
    Log.e(TAG, "Error getting input stream for audio.")
    // Handle the error appropriately
}

Java

Możesz wywołać funkcję generateContent() w celu wygenerowania tekstu na podstawie multimodalnych danych wejściowych składających się z tekstu i jednego pliku audio.

^{W przypadku języka Java metody w tym pakiecie SDK zwracają wartość ListenableFuture.}

// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())
        .generativeModel("gemini-2.5-flash");

// Use the GenerativeModelFutures Java compatibility layer which offers
// support for ListenableFuture and Publisher APIs
GenerativeModelFutures model = GenerativeModelFutures.from(ai);


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 the audio specified above 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);
}

Web

Możesz wywołać funkcję generateContent() w celu wygenerowania tekstu na podstawie multimodalnych danych wejściowych składających się z tekstu i jednego pliku audio.

import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend } from "firebase/ai";

// TODO(developer) Replace the following with your app's Firebase configuration
// See: https://firebase.google.com/docs/web/learn-more#config-object
const firebaseConfig = {
  // ...
};

// Initialize FirebaseApp
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Create a `GenerativeModel` instance with a model that supports your use case
const model = getGenerativeModel(ai, { model: "gemini-2.5-flash" });


// Converts a File object to a Part object.
async function fileToGenerativePart(file) {
  const base64EncodedDataPromise = new Promise((resolve) => {
    const reader = new FileReader();
    reader.onloadend = () => resolve(reader.result.split(','));
    reader.readAsDataURL(file);
  });
  return {
    inlineData: { data: await base64EncodedDataPromise, mimeType: file.type },
  };
}

async function run() {
  // Provide a text prompt to include with the audio
  const prompt = "Transcribe what's said in this audio recording.";

  // Prepare audio for input
  const fileInputEl = document.querySelector("input[type=file]");
  const audioPart = await fileToGenerativePart(fileInputEl.files);

  // To generate text output, call `generateContent` with the text and audio
  const result = await model.generateContent([prompt, audioPart]);

  // Log the generated text, handling the case where it might be undefined
  console.log(result.response.text() ?? "No text in response.");
}

run();

Dart

Możesz wywołać funkcję generateContent(), aby wygenerować tekst na podstawie multimodalnych danych wejściowych składających się z tekstu i jednego pliku audio.

import 'package:firebase_ai/firebase_ai.dart';
import 'package:firebase_core/firebase_core.dart';
import 'firebase_options.dart';

// Initialize FirebaseApp
await Firebase.initializeApp(
  options: DefaultFirebaseOptions.currentPlatform,
);

// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
final model =
      FirebaseAI.googleAI().generativeModel(model: 'gemini-2.5-flash');


// Provide a text prompt to include with the audio
final prompt = TextPart("Transcribe what's said in this audio recording.");

// Prepare audio for input
final audio = await File('audio0.mp3').readAsBytes();

// Provide the audio as `Data` with the appropriate audio MIME type
final audioPart = InlineDataPart('audio/mpeg', audio);

// To generate text output, call `generateContent` with the text and audio
final response = await model.generateContent([
  Content.multi([prompt,audioPart])
]);

// Print the generated text
print(response.text);

Unity

Możesz wywołać funkcję GenerateContentAsync() w celu wygenerowania tekstu na podstawie multimodalnych danych wejściowych składających się z tekstu i jednego pliku audio.

using Firebase;
using Firebase.AI;

// Initialize the Gemini Developer API backend service
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Create a `GenerativeModel` instance with a model that supports your use case
var model = ai.GetGenerativeModel(modelName: "gemini-2.5-flash");


// Provide a text prompt to include with the audio
var prompt = ModelContent.Text("Transcribe what's said in this audio recording.");

// Provide the audio as `data` with the appropriate audio MIME type
var audio = ModelContent.InlineData("audio/mpeg",
      System.IO.File.ReadAllBytes(System.IO.Path.Combine(
        UnityEngine.Application.streamingAssetsPath, "audio0.mp3")));

// To generate text output, call `GenerateContentAsync` with the text and audio
var response = await model.GenerateContentAsync(new [] { prompt, audio });

// Print the generated text
UnityEngine.Debug.Log(response.Text ?? "No text in response.");

Dowiedz się, jak wybrać model odpowiednie do Twojego przypadku użycia i aplikacji.

Wyświetlanie odpowiedzi stopniowo

Zanim wypróbujesz ten przykład, zapoznaj się z sekcją Zanim zaczniesz w tym przewodniku, aby skonfigurować projekt i aplikację. W tej sekcji klikniesz też przycisk wybranego dostawcyGemini API, aby na tej stronie wyświetlały się treści dotyczące tego dostawcy.

Możesz uzyskać szybsze interakcje, nie czekając na pełny wynik generowania modelu, i zamiast tego używać przesyłania strumieniowego do obsługi częściowych wyników. Aby przesyłać strumieniowo odpowiedź, wywołaj funkcję generateContentStream.

Przykład: przesyłanie strumieniowe wygenerowanego tekstu z plików audio

Swift

Możesz wywołać funkcję generateContentStream() do przesyłania strumieniowego wygenerowanego tekstu z danych wejściowych multimodalnych, które obejmują tekst i jeden plik audio.

import FirebaseAI

// Initialize the Gemini Developer API backend service
let ai = FirebaseAI.firebaseAI(backend: .googleAI())

// Create a `GenerativeModel` instance with a model that supports your use case
let model = ai.generativeModel(modelName: "gemini-2.5-flash")


// Provide the audio as `Data`
guard let audioData = try? Data(contentsOf: audioURL) else {
    print("Error loading audio data.")
    return // Or handle the error appropriately
}

// Specify the appropriate audio MIME type
let audio = InlineDataPart(data: audioData, mimeType: "audio/mpeg")


// Provide a text prompt to include with the audio
let prompt = "Transcribe what's said in this audio recording."

// To stream generated text output, call `generateContentStream` with the audio and text prompt
let contentStream = try model.generateContentStream(audio, prompt)

// Print the generated text, handling the case where it might be nil
for try await chunk in contentStream {
    if let text = chunk.text {
        print(text)
    }
}

Kotlin

Możesz wywołać funkcję generateContentStream() do przesyłania strumieniowego wygenerowanego tekstu z danych wejściowych multimodalnych, które obejmują tekst i jeden plik audio.

^{W przypadku Kotlina metody w tym pakiecie SDK są funkcjami zawieszającymi i muszą być wywoływane w zakresie Coroutine.}

// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
                        .generativeModel("gemini-2.5-flash")


val contentResolver = applicationContext.contentResolver

val inputStream = contentResolver.openInputStream(audioUri)

if (inputStream != null) {  // Check if the audio loaded successfully
    inputStream.use { stream ->
        val bytes = stream.readBytes()

        // Provide a prompt that includes the audio specified above and text
        val prompt = content {
            inlineData(bytes, "audio/mpeg")  // Specify the appropriate audio MIME type
            text("Transcribe what's said in this audio recording.")
        }

        // To stream generated text output, call `generateContentStream` with the prompt
        var fullResponse = ""
        generativeModel.generateContentStream(prompt).collect { chunk ->
            // Log the generated text, handling the case where it might be null
            Log.d(TAG, chunk.text?: "")
            fullResponse += chunk.text?: ""
        }
    }
} else {
    Log.e(TAG, "Error getting input stream for audio.")
    // Handle the error appropriately
}

Java

Możesz wywołać funkcję generateContentStream() do przesyłania strumieniowego wygenerowanego tekstu z danych wejściowych multimodalnych, które obejmują tekst i jeden plik audio.

^{W przypadku Javy metody strumieniowania w tym pakiecie SDK zwracają typ Publisher z biblioteki Reactive Streams.}

// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())
        .generativeModel("gemini-2.5-flash");

// Use the GenerativeModelFutures Java compatibility layer which offers
// support for ListenableFuture and Publisher APIs
GenerativeModelFutures model = GenerativeModelFutures.from(ai);


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 the audio specified above 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 stream generated text output, call `generateContentStream` with the prompt
        Publisher<GenerateContentResponse> streamingResponse =
                model.generateContentStream(prompt);

        StringBuilder fullResponse = new StringBuilder();
        streamingResponse.subscribe(new Subscriber<GenerateContentResponse>() {
            @Override
            public void onNext(GenerateContentResponse generateContentResponse) {
                String chunk = generateContentResponse.getText();
                String text = (chunk == null) ? "" : chunk;
                Log.d(TAG, text);
                fullResponse.append(text);
            }
            @Override
            public void onComplete() {
                Log.d(TAG, fullResponse.toString());
            }
            @Override
            public void onError(Throwable t) {
                Log.e(TAG, "Failed to generate a response", t);
            }
            @Override
            public void onSubscribe(Subscription s) {
            }
         });
    } 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);
}

Web

Możesz wywołać funkcję generateContentStream() do przesyłania strumieniowego wygenerowanego tekstu z danych wejściowych multimodalnych, które obejmują tekst i jeden plik audio.

import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend } from "firebase/ai";

// TODO(developer) Replace the following with your app's Firebase configuration
// See: https://firebase.google.com/docs/web/learn-more#config-object
const firebaseConfig = {
  // ...
};

// Initialize FirebaseApp
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Create a `GenerativeModel` instance with a model that supports your use case
const model = getGenerativeModel(ai, { model: "gemini-2.5-flash" });


// Converts a File object to a Part object.
async function fileToGenerativePart(file) {
  const base64EncodedDataPromise = new Promise((resolve) => {
    const reader = new FileReader();
    reader.onloadend = () => resolve(reader.result.split(','));
    reader.readAsDataURL(file);
  });
  return {
    inlineData: { data: await base64EncodedDataPromise, mimeType: file.type },
  };
}

async function run() {
  // Provide a text prompt to include with the audio
  const prompt = "Transcribe what's said in this audio recording.";

  // Prepare audio for input
  const fileInputEl = document.querySelector("input[type=file]");
  const audioPart = await fileToGenerativePart(fileInputEl.files);

  // To stream generated text output, call `generateContentStream` with the text and audio
  const result = await model.generateContentStream([prompt, audioPart]);

  // Log the generated text
  for await (const chunk of result.stream) {
    const chunkText = chunk.text();
    console.log(chunkText);
  }
}

run();

Dart

Możesz wywołać funkcję generateContentStream(), aby przesyłać strumieniowo wygenerowany tekst z wielomodalnego wejścia tekstowego i jednego pliku audio.

import 'package:firebase_ai/firebase_ai.dart';
import 'package:firebase_core/firebase_core.dart';
import 'firebase_options.dart';

// Initialize FirebaseApp
await Firebase.initializeApp(
  options: DefaultFirebaseOptions.currentPlatform,
);

// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
final model =
      FirebaseAI.googleAI().generativeModel(model: 'gemini-2.5-flash');


// Provide a text prompt to include with the audio
final prompt = TextPart("Transcribe what's said in this audio recording.");

// Prepare audio for input
final audio = await File('audio0.mp3').readAsBytes();

// Provide the audio as `Data` with the appropriate audio MIME type
final audioPart = InlineDataPart('audio/mpeg', audio);

// To stream generated text output, call `generateContentStream` with the text and audio
final response = await model.generateContentStream([
  Content.multi([prompt, audioPart])
]);

// Print the generated text
await for (final chunk in response) {
  print(chunk.text);
}

Unity

Możesz wywołać funkcję GenerateContentStreamAsync() do przesyłania strumieniowego wygenerowanego tekstu z danych wejściowych multimodalnych, które obejmują tekst i jeden plik audio.

using Firebase;
using Firebase.AI;

// Initialize the Gemini Developer API backend service
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Create a `GenerativeModel` instance with a model that supports your use case
var model = ai.GetGenerativeModel(modelName: "gemini-2.5-flash");


// Provide a text prompt to include with the audio
var prompt = ModelContent.Text("Transcribe what's said in this audio recording.");

// Provide the audio as `data` with the appropriate audio MIME type
var audio = ModelContent.InlineData("audio/mpeg",
      System.IO.File.ReadAllBytes(System.IO.Path.Combine(
        UnityEngine.Application.streamingAssetsPath, "audio0.mp3")));

// To stream generated text output, call `GenerateContentStreamAsync` with the text and audio
var responseStream = model.GenerateContentStreamAsync(new [] { prompt, audio });

// Print the generated text
await foreach (var response in responseStream) {
  if (!string.IsNullOrWhiteSpace(response.Text)) {
    UnityEngine.Debug.Log(response.Text);
  }
}

Dowiedz się, jak wybrać model odpowiednie do Twojego przypadku użycia i aplikacji.

---

Wymagania i zalecenia dotyczące wejściowych plików audio

Ważne: łączny rozmiar żądania nie może przekraczać 20 MB. Aby wysyłać duże pliki, zapoznaj się z opcjami przesyłania plików w żądaniach multimodalnych.

Pamiętaj, że plik podany jako dane wbudowane jest kodowany do formatu base64 podczas przesyłania, co zwiększa rozmiar żądania. Jeśli żądanie jest zbyt duże, otrzymasz błąd HTTP 413.

Więcej informacji o tych kwestiach znajdziesz w artykule „Obsługiwane pliki wejściowe i wymagania dotyczące Vertex AI Gemini API”:

• Różne opcje przesyłania pliku w żądaniu (wbudowanego lub za pomocą adresu URL lub URI pliku)
• Wymagania i sprawdzone metody dotyczące plików audio

Obsługiwane typy MIME audio

Gemini Modele multimodalne obsługują te typy MIME audio:

Typ MIME audio	Gemini 2.0 Flash	Gemini 2.0 Flash‑Lite
AAC - audio/aac
FLAC – audio/flac
MP3 – audio/mp3
MPA - audio/m4a
MPEG - audio/mpeg
MPGA - audio/mpga
MP4 – audio/mp4
OPUS - audio/opus
PCM - audio/pcm
WAV - audio/wav
WEBM – audio/webm

Limity na żądanie

W żądaniu promptu możesz uwzględnić maksymalnie 1 plik audio.

---

Co jeszcze możesz zrobić?

• Dowiedz się, jak liczyć tokeny przed wysłaniem do modelu długich promptów.
• Skonfiguruj Cloud Storage for Firebase, aby móc uwzględniać duże pliki w żądaniach multimodalnych i korzystać z bardziej zarządzanego rozwiązania do udostępniania plików w promptach. Mogą to być obrazy, pliki PDF, wideo i audio.
• Zacznij myśleć o przygotowaniu do udostępnienia wersji produkcyjnej (patrz lista kontrolna produkcji), w tym:
  • Skonfiguruj Firebase App Check, aby chronić Gemini API przed nadużyciami ze strony nieautoryzowanych klientów.
  • Integrowanie Firebase Remote Config w celu aktualizowania wartości w aplikacji (np. nazwy modelu) bez publikowania nowej wersji aplikacji.

Wypróbuj inne funkcje

• Twórz rozmowy wieloetapowe (czat).
• generować tekst na podstawie promptów tekstowych,
• Generowanie danych wyjściowych o strukturze (np. JSON) na podstawie promptów tekstowych i multimodalnych.
• Generuj obrazy na podstawie promptów tekstowych (Gemini lub Imagen).
• Używaj wywoływania funkcji, aby łączyć modele generatywne z systemami zewnętrznymi i informacjami.

Dowiedz się, jak kontrolować generowanie treści

• Poznaj projektowanie promptów, w tym sprawdzone metody, strategie i przykładowe prompty.
• Skonfiguruj parametry modelu, takie jak temperatura i maksymalna liczba tokenów wyjściowych (w przypadku Gemini) lub format obrazu i generowanie osób (w przypadku Imagen).
• Użyj ustawień bezpieczeństwa, aby dostosować prawdopodobieństwo otrzymania odpowiedzi, które mogą być uznane za szkodliwe.

Możesz też eksperymentować z promptami i konfiguracjami modeli, a nawet uzyskać wygenerowany fragment kodu za pomocą Google AI Studio.

Więcej informacji o obsługiwanych modelach

Dowiedz się więcej o modelach dostępnych w różnych przypadkach użycia, ich limitach i cenach.

Prześlij opinię o korzystaniu z usługi Firebase AI Logic