Gemini Live API

ליישומים שדורשים תמיכה קולית בזמן אמת עם זמן טעינה נמוך, כמו צ'אטבוטים או אינטראקציות עם סוכנים, Gemini Live API מספק דרך אופטימלית להזרמת קלט ופלט עבור מודל Gemini. באמצעות Firebase AI Logic, אפשר לקרוא ל-Gemini Live API ישירות מאפליקציית Android בלי לשלב את ה-API עם קצה העורף. במדריך הזה נסביר איך להשתמש ב-Gemini Live API באפליקציית Android עם Firebase AI Logic.

הערה: השימוש ב-Gemini Live API עם Firebase AI Logic הוא בגרסת טרום-השקה למפתחים. יכול להיות שיהיו שינויים שלא תואמים לאחור, ויש להם את המגבלות הבאות

.

שנתחיל?

לפני שמתחילים, חשוב לוודא שהאפליקציה מטרגטת רמת API 23 ומעלה.

אם עדיין לא עשיתם זאת, אתם צריכים להגדיר פרויקט Firebase ולקשר את האפליקציה ל-Firebase. פרטים נוספים זמינים במסמכי התיעוד בנושא Firebase AI Logic.

הגדרת פרויקט Android

מוסיפים את ספריית Firebase AI Logic ואת יחסי התלות של App Check לקובץ build.gradle.kts או build.gradle ברמת האפליקציה. משתמשים ב-Firebase Android BoM כדי לנהל את גרסאות הספרייה.

dependencies {
  // Import the Firebase BoM
  implementation(platform("com.google.firebase:firebase-bom:34.15.0"))

  // Add the dependencies for the Firebase AI Logic and App Check libraries
  // When using the BoM, you don't specify versions in Firebase library dependencies
  implementation("com.google.firebase:firebase-ai")
  implementation("com.google.firebase:firebase-appcheck-debug")
}

אחרי שמוסיפים את התלויות, מסנכרנים את פרויקט Android עם Gradle.

הגדרת ספק ניפוי הבאגים של App Check לפיתוח מקומי

החל מתחילת יולי 2026, כחלק מתהליך ההגדרה המודרך של AI Logic במסוף Firebase, ייאכף באופן אוטומטי השימוש ב-Firebase App Check כדי להגן על Gemini API. בפיתוח מקומי, צריך להגדיר את ספק הניפוי באגים של App Check כדי לעקוף את האימות, ועדיין לשמור על האכיפה של App Check.

1. בגרסת הניפוי באגים, מגדירים את App Check לשימוש ב-factory של ספק ניפוי הבאגים:

   Kotlin

   Firebase.initialize(context = this)
   Firebase.appCheck.installAppCheckProviderFactory(
       DebugAppCheckProviderFactory.getInstance(),
   )
   

   Java

   FirebaseApp.initializeApp(/*context=*/ this);
   FirebaseAppCheck firebaseAppCheck = FirebaseAppCheck.getInstance();
   firebaseAppCheck.installAppCheckProviderFactory(
           DebugAppCheckProviderFactory.getInstance());
   

2. קבלת טוקן לניפוי באגים:

   1. מריצים את האפליקציה באמולטור או במכשיר הבדיקה.

   2. מחפשים את אסימון הניפוי באגים של App Check ביומנים. לדוגמה:

      D DebugAppCheckProvider: Enter this debug secret into the allow list
      in the Firebase Console for your project: 123a4567-b89c-12d3-e456-789012345678
      

   3. מעתיקים את הטוקן (לדוגמה, 123a4567-b89c-12d3-e456-789012345678).

3. רושמים את טוקן הניפוי באגים ב-App Check:

   1. במסוף Firebase, עוברים אל Security (אבטחה) > App Check (בדיקת אפליקציות) > הכרטיסייה Apps (אפליקציות).

   2. מוצאים את האפליקציה, לוחצים על תפריט האפשרויות הנוספות () ובוחרים באפשרות ניהול אסימוני ניפוי באגים.

   3. פועלים לפי ההוראות במסך כדי לרשום את אסימון הניפוי באגים.

פרטים על ספק ניפוי הבאגים (כולל איך מקבלים אסימון ניפוי באגים חדש) מופיעים במסמכים הרשמיים של App Check.

הנה כמה נקודות חשובות לגבי ספק ניפוי הבאגים של App Check:

• חשוב לשמור על הפרטיות של אסימון הניפוי וגרסת הניפוי. אל תבצעו קומיט של טוקן ניפוי הבאגים למאגר ציבורי, ואל תשלחו את טוקן ניפוי הבאגים או את גרסת ה-build לניפוי הבאגים בגרסאות ה-build של האפליקציה בסביבת הייצור.
• לפני שמשחררים את האפליקציה למשתמשי הקצה, צריך לרשום אותה אצל ספק אימות בסביבת ייצור. תצטרכו: לרשום את האפליקציה אצל ספק אימות של App Check בסביבת ייצור (לדוגמה, Play Integrity) כדי שמשתמשי הקצה יוכלו להשתמש בתכונה עם App Check מופעל.

שילוב של Firebase AI Logic ואתחול של מודל גנרטיבי

מוסיפים את ההרשאה RECORD_AUDIO לקובץ AndroidManifest.xml של האפליקציה:

<uses-permission android:name="android.permission.RECORD_AUDIO" />

מאתחלים את שירות ה-Backend של Gemini Developer API וניגשים אל LiveModel. משתמשים במודל שתומך ב-Live API, כמו gemini-2.5-flash-native-audio-preview-12-2025. מידע נוסף על מודלים זמינים של Live API זמין במסמכי העזרה של Firebase.

כדי לציין קול, מגדירים את שם הקול באובייקט speechConfig כחלק מהגדרת המודל. אם לא מציינים קול, ברירת המחדל היא Puck.

Kotlin

// Initialize the `LiveModel`
val model = Firebase.ai(backend = GenerativeBackend.googleAI()).liveModel(
    modelName = "gemini-2.5-flash-native-audio-preview-12-2025",
    generationConfig = liveGenerationConfig {
        responseModality = ResponseModality.AUDIO
        speechConfig = SpeechConfig(voice = Voice("FENRIR"))
    }
)
GeminiLive.kt

Java

// Initialize the `LiveModel`
LiveGenerativeModel model = FirebaseAI
       .getInstance(GenerativeBackend.googleAI())
       .liveModel(
              "gemini-2.5-flash-native-audio-preview-12-2025",
              new LiveGenerationConfig.Builder()
                     .setResponseModality(ResponseModality.AUDIO)
                     .setSpeechConfig(new SpeechConfig(new Voice("FENRIR"))
              ).build(),
        null,
        null
);

אפשר להגדיר הנחיית מערכת כדי להגדיר פרסונה או תפקיד שהמודל יגלם:

Kotlin

val systemInstruction = content {
    text("You are a helpful assistant, you main role is [...]")
}

val model = Firebase.ai(backend = GenerativeBackend.googleAI()).liveModel(
    modelName = "gemini-2.5-flash-native-audio-preview-12-2025",
    generationConfig = liveGenerationConfig {
        responseModality = ResponseModality.AUDIO
        speechConfig = SpeechConfig(voice = Voice("FENRIR"))
    },
    systemInstruction = systemInstruction,
)
GeminiLive.kt

Java

Content systemInstruction = new Content.Builder()
       .addText("You are a helpful assistant, you main role is [...]")
       .build();

LiveGenerativeModel model = FirebaseAI
       .getInstance(GenerativeBackend.googleAI())
       .liveModel(
              "gemini-2.5-flash-native-audio-preview-12-2025",
              new LiveGenerationConfig.Builder()
                     .setResponseModality(ResponseModality.AUDIO)
                     .setSpeechConfig(new SpeechConfig(new Voice("FENRIR"))
              ).build(),
        tools, // null if you don't want to use function calling
        systemInstruction
);

כדי להתאים את השיחה עם המודל באופן ספציפי יותר, אפשר להשתמש בהוראות מערכת כדי לספק הקשר שספציפי לאפליקציה (לדוגמה, היסטוריית הפעילות של המשתמש באפליקציה).

אתחול של סשן Live API

אחרי שיוצרים את מופע LiveModel, קוראים ל-model.connect() כדי ליצור אובייקט LiveSession וליצור חיבור מתמשך עם המודל באמצעות סטרימינג עם השהיה נמוכה. LiveSession מאפשר לכם לקיים אינטראקציה עם המודל על ידי התחלה ועצירה של סשן קולי, וגם שליחה וקבלה של טקסט.

אחר כך תוכלו להתקשר אל startAudioConversation() כדי להתחיל את השיחה עם המודל:

Kotlin

val session = model.connect()
session.startAudioConversation()
GeminiLive.kt

Java

LiveModelFutures model = LiveModelFutures.from(liveModel);
ListenableFuture<LiveSession> sessionFuture = model.connect();

Futures.addCallback(sessionFuture, new FutureCallback<LiveSession>() {
    @Override
    public void onSuccess(LiveSession ses) {
        LiveSessionFutures session = LiveSessionFutures.from(ses);
        session.startAudioConversation();
    }
    @Override
    public void onFailure(Throwable t) {
        // Handle exceptions
    }
}, executor);

חשוב לזכור שבשיחות עם המודל, הוא לא יודע להתמודד עם הפרעות. בנוסף, Live API הוא דו-כיווני, כך שמשתמשים באותו חיבור כדי לשלוח ולקבל תוכן.

אתם יכולים גם להשתמש ב-Gemini Live API כדי ליצור אודיו ממגוון אמצעי קלט:

• שליחת טקסט וקלט אודיו
• שליחת קלט וידאו (אפשר לעיין באפליקציית ההפעלה המהירה של Firebase).

בקשות להפעלת פונקציות: חיבור Gemini Live API לאפליקציה

כדי להרחיב את השימוש במודל, אפשר גם להפעיל אותו כך שיקיים אינטראקציה ישירה עם הלוגיקה של האפליקציה באמצעות קריאה לפונקציה.

בקשה להפעלת פונקציה (או בקשה להפעלת כלי) היא תכונה של יישומי AI גנרטיבי שמאפשרת למודל להפעיל פונקציות מיוזמתו כדי לבצע פעולות. אם לפונקציה יש פלט, המודל מוסיף אותו להקשר ומשתמש בו ליצירות הבאות.

איור 1: דיאגרמה שממחישה איך Gemini Live API מאפשר למודל לפרש הנחיה של משתמש, להפעיל פונקציה מוגדרת מראש עם ארגומנטים רלוונטיים באפליקציית Android, ואז לקבל מהמודל תשובת אישור.

כדי להטמיע קריאה לפונקציה באפליקציה, מתחילים ביצירת אובייקט FunctionDeclaration לכל פונקציה שרוצים לחשוף למודל.

לדוגמה, כדי לחשוף פונקציה addList שמצרפת מחרוזת לרשימה של מחרוזות ל-Gemini, מתחילים ביצירת משתנה FunctionDeclaration עם שם ותיאור קצר באנגלית פשוטה של הפונקציה והפרמטר שלה:

Kotlin

val itemList = mutableListOf<String>()

fun addList(item: String) {
    itemList.add(item)
}

val addListFunctionDeclaration = FunctionDeclaration(
    name = "addList",
    description = "Function adding an item the list",
    parameters = mapOf(
        "item" to Schema.string("A short string describing the item to add to the list")
    )
)
GeminiLive.kt

Java

HashMap<String, Schema> addListParams = new HashMap<String, Schema>(1);

addListParams.put("item", Schema.str("A short string describing the item to add to the list"));

FunctionDeclaration addListFunctionDeclaration = new FunctionDeclaration(
    "addList",
    "Function adding an item the list",
    addListParams,
    Collections.emptyList()
);

אחר כך מעבירים את FunctionDeclaration כ-Tool למודל כשיוצרים מופע שלו:

Kotlin

val addListTool = Tool.functionDeclarations(listOf(addListFunctionDeclaration))

val model = Firebase.ai(backend = GenerativeBackend.googleAI()).liveModel(
    modelName = "gemini-2.5-flash-native-audio-preview-12-2025",
    generationConfig = liveGenerationConfig {
        responseModality = ResponseModality.AUDIO
        speechConfig = SpeechConfig(voice = Voice("FENRIR"))
    },
    systemInstruction = systemInstruction,
    tools = listOf(addListTool)
)
GeminiLive.kt

Java

LiveGenerativeModel model = FirebaseAI.getInstance(
    GenerativeBackend.googleAI()).liveModel(
        "gemini-2.5-flash-native-audio-preview-12-2025",
  new LiveGenerationConfig.Builder()
        .setResponseModalities(ResponseModality.AUDIO)
        .setSpeechConfig(new SpeechConfig(new Voice("FENRIR")))
        .build(),
  List.of(Tool.functionDeclarations(List.of(addListFunctionDeclaration))),
               null,
               systemInstruction
        );

לבסוף, מטמיעים פונקציית handler לטיפול בקריאה לכלי שהמודל מבצע ומעבירים לו בחזרה את התשובה. פונקציית ה-handler הזו מסופקת ל-LiveSession כשמפעילים את startAudioConversation, היא מקבלת פרמטר FunctionCallPart ומחזירה FunctionResponsePart:

Kotlin

session.startAudioConversation(::functionCallHandler)

// ...

fun functionCallHandler(functionCall: FunctionCallPart): FunctionResponsePart {
    return when (functionCall.name) {
        "addList" -> {
            // Extract function parameter from functionCallPart
            val itemName = functionCall.args["item"]!!.jsonPrimitive.content
            // Call function with parameter
            addList(itemName)
            // Confirm the function call to the model
            val response = JsonObject(
                mapOf(
                    "success" to JsonPrimitive(true),
                    "message" to JsonPrimitive("Item $itemName added to the todo list")
                )
            )
            FunctionResponsePart(functionCall.name, response)
        }
        else -> {
            val response = JsonObject(
                mapOf(
                    "error" to JsonPrimitive("Unknown function: ${functionCall.name}")
                )
            )
            FunctionResponsePart(functionCall.name, response)
        }
    }
}
GeminiLive.kt

Java

Futures.addCallback(sessionFuture, new FutureCallback<LiveSessionFutures>() {

    @RequiresPermission(Manifest.permission.RECORD_AUDIO)
    @Override
    @OptIn(markerClass = PublicPreviewAPI.class)
    public void onSuccess(LiveSessionFutures ses) {
        ses.startAudioConversation(::handleFunctionCallFuture);
    }

    @Override
    public void onFailure(Throwable t) {
        // Handle exceptions
    }
}, executor);

// ...

ListenableFuture<JsonObject> handleFunctionCallFuture = Futures.transform(response, result -> {
    for (FunctionCallPart functionCall : result.getFunctionCalls()) {
        if (functionCall.getName().equals("addList")) {
            Map<String, JsonElement> args = functionCall.getArgs();
            String item =
                    JsonElementKt.getContentOrNull(
                            JsonElementKt.getJsonPrimitive(
                                    locationJsonObject.get("item")));
            return addList(item);
        }
    }
    return null;
}, Executors.newSingleThreadExecutor());

השלבים הבאים

• אפשר להתנסות ב-Gemini Live API באפליקציית הדוגמה של קטלוג ה-AI ב-Android.
• מידע נוסף על Gemini Live API זמין במאמרי העזרה של Firebase AI Logic.
• מידע נוסף על המודלים הזמינים של Gemini
• מידע נוסף על קריאה לפונקציה
• אסטרטגיות לעיצוב הנחיות