Analizowanie plików audio za pomocą interfejsu Gemini API

Możesz poprosić model Gemini o analizę plików audio, które podasz w treści (zakodowane w standardzie 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ć lub odpowiadać na pytania dotyczące treści audio,
• transkrybować treści audio,
• analizować konkretne segmenty dźwięku za pomocą sygnatur czasowych.

Przejdź do przykładowych fragmentów kodu Przejdź do kodu obsługującego odpowiedzi przesyłane strumieniowo

Więcej opcji pracy z dźwiękiem znajdziesz w innych przewodnikach Generowanie danych wyjściowych w uporządkowanym formacie Czat wieloetapowy Dwukierunkowe przesyłanie strumieniowe

Zanim zaczniesz

Kliknij dostawcę Gemini API, aby wyświetlić na tej stronie treści i kod specyficzne dla 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 opisujemy, 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.

We wszystkich naszych dokumentach zakładamy, że używasz najnowszych wersji pakietów Firebase AI Logic SDK.

Do testowania i iterowania promptów 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 na podstawie plików audio (zakodowanych w standardzie Base64)

Zanim wypróbujesz ten przykład, wykonaj czynności opisane w sekcji Zanim zaczniesz w tym przewodniku aby skonfigurować projekt i aplikację. W tej sekcji klikniesz też przycisk dostawcy Gemini API, aby na tej stronie wyświetlały się treści specyficzne dla dostawcy. Gemini API.

Możesz poprosić model Gemini o wygenerowanie tekstu, podając tekst i dźwięk – podając pliku wejściowego mimeType i sam plik. Wymagania i zalecenia dotyczące plików wejściowych znajdziesz dalej na tej stronie.

Ważne: Łączny limit rozmiaru żądania to 20 MB. Aby wysyłać duże pliki, zapoznaj się z opcjami podawania plików w żądaniach multimodalnych.

Swift

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

import FirebaseAILogic

// 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-3.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ć generateContent() , aby wygenerować tekst na podstawie multimodalnych danych wejściowych składających się z tekstu i pojedynczego pliku audio.

^{W przypadku języka Kotlin metody w tym pakiecie SDK są funkcjami zawieszającymi i muszą być wywoływane z zakresu współprogramu.}

// 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-3.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 = model.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ć generateContent() , aby wygenerować tekst na podstawie multimodalnych danych wejściowych składających się z tekstu i pojedynczego 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-3.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ć generateContent() , aby wygenerować tekst na podstawie multimodalnych danych wejściowych składających się z tekstu i pojedynczego 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-3.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ć generateContent() aby wygenerować tekst na podstawie multimodalnych danych wejściowych składających się z tekstu i pojedynczego 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-3.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ć GenerateContentAsync() , aby wygenerować tekst na podstawie multimodalnych danych wejściowych składających się z tekstu i pojedynczego 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-3.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 odpowiednią dla Twojego przypadku użycia i aplikacji.

Przesyłanie odpowiedzi strumieniowo

Zanim wypróbujesz ten przykład, wykonaj czynności opisane w sekcji Zanim zaczniesz w tym przewodniku aby skonfigurować projekt i aplikację. W tej sekcji klikniesz też przycisk dostawcy Gemini API, aby na tej stronie wyświetlały się treści specyficzne dla dostawcy. Gemini API.

Możesz przyspieszyć interakcje, nie czekając na cały wynik wygenerowany przez model, i zamiast tego użyć przesyłania strumieniowego do obsługi częściowych wyników. Aby przesyłać odpowiedź strumieniowo, wywołaj generateContentStream.

Wyświetl przykład: przesyłanie strumieniowo wygenerowanego tekstu z plików audio

Swift

Możesz wywołać generateContentStream() , aby przesyłać strumieniowo wygenerowany tekst na podstawie multimodalnych danych wejściowych składających się z tekstu i pojedynczego pliku audio.

import FirebaseAILogic

// 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-3.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ć generateContentStream() , aby przesyłać strumieniowo wygenerowany tekst na podstawie multimodalnych danych wejściowych składających się z tekstu i pojedynczego pliku audio.

^{W przypadku języka Kotlin metody w tym pakiecie SDK są funkcjami zawieszającymi i muszą być wywoływane z zakresu współprogramu.}

// 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-3.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 = ""
        model.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ć generateContentStream() , aby przesyłać strumieniowo wygenerowany tekst na podstawie multimodalnych danych wejściowych składających się z tekstu i pojedynczego pliku audio.

^{W przypadku języka Java metody przesyłania strumieniowego 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-3.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ć generateContentStream() , aby przesyłać strumieniowo wygenerowany tekst na podstawie multimodalnych danych wejściowych składających się z tekstu i pojedynczego 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-3.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ć generateContentStream() , aby przesyłać strumieniowo wygenerowany tekst na podstawie multimodalnych danych wejściowych składających się z tekstu i pojedynczego 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-3.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ć GenerateContentStreamAsync() , aby przesyłać strumieniowo wygenerowany tekst na podstawie multimodalnych danych wejściowych składających się z tekstu i pojedynczego 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-3.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 odpowiednią dla Twojego przypadku użycia i aplikacji.

---

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

Ważne: Łączny limit rozmiaru żądania to 20 MB. Aby wysyłać duże pliki, zapoznaj się z opcjami podawania plików w żądaniach multimodalnych.

Pamiętaj, że plik podany jako dane w treści jest podczas przesyłania kodowany w standardzie Base64, co zwiększa rozmiar żądania. Jeśli żądanie jest zbyt duże, otrzymasz błąd HTTP 413.

Szczegółowe informacje o tych kwestiach znajdziesz na stronie „Obsługiwane pliki wejściowe i wymagania”:

• Różne opcje podawania pliku w żądaniu (w treści 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:

• 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

Maksymalna liczba plików na żądanie: 1 plik audio

---

Co jeszcze możesz zrobić?

• Dowiedz się, jak zliczać tokeny przed wysłaniem do modelu długich promptów.
• Skonfiguruj Cloud Storage for Firebase , aby móc dołączać duże pliki do żądań multimodalnych i mieć bardziej zarządzane rozwiązanie do podawania plików w promptach. Pliki mogą zawierać obrazy, pliki PDF, filmy i dźwięk.
• Zacznij przygotowywać się do wdrożenia (zapoznaj się z listą kontrolną wdrożenia):
  • Skonfiguruj Firebase App Check jak najszybciej, aby chronić Gemini API przed nadużyciami ze strony nieautoryzowanych klientów.
  • Zintegruj Firebase Remote Config , aby aktualizować wartości w aplikacji (np. nazwę modelu) bez publikowania nowej wersji aplikacji .

Wypróbuj inne funkcje

• Twórz rozmowy wieloetapowe (czat).
• Generuj tekst na podstawie promptów zawierających tylko tekst.
• Generuj dane wyjściowe w uporządkowanym formacie (np. JSON) na podstawie promptów tekstowych i multimodalnych.
• Generuj i edytuj obrazy na podstawie promptów tekstowych i multimodalnych.
• Przesyłaj strumieniowo dane wejściowe i wyjściowe (w tym dźwięk) za pomocą Gemini Live API.
• Używaj narzędzi (takich jak wywoływanie funkcji i powiązanie ze źródłami informacji przy użyciu wyszukiwarki Google) aby połączyć model Gemini z innymi częściami aplikacji oraz systemami i informacjami zewnętrznymi.

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 maksymalna liczba tokenów wyjściowych, prawdopodobieństwo powtórzenia tokenów wyjściowych itp.
• 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 oraz o ich limitach i cenach.

Prześlij opinię o korzystaniu z Firebase AI Logic