פיתוח אפליקציות מאובטחות וחסכוניות ל-Android באמצעות Firebase AI Logic ו-Gemini Nano 4

ברוכים הבאים למפגש של מפתחי Android.

אני אנקיטה סקסנה, מנהלת מוצר ב-Firebase.

ואני ארתור תומפסון, מהנדס קשרי מפתחים בצוות Firebase.

היום נראה לכם איך להוסיף תכונות גנרטיביות לאפליקציות ל-Android.

טוב.

מה זה Firebase?

תרימו יד אם שמעתם על Firebase.

אני רואה הרבה.

מצוין.

‫Firebase היא פלטפורמה של Google לפיתוח אפליקציות.

‫Firebase מספקת פלטפורמה מאוחדת שמשלבת יותר מ-20 מוצרים, כך שאתם לא צריכים להתמודד עם חוויה מפוצלת כמו בתוכנות אחרות.

בואו נדבר על האתגרים בהשקת AI גנרטיבי באפליקציות לנייד.

זיהינו את שלושת האתגרים העיקריים.

קודם כול, דליפות של מפתחות API: לוקח כמה דקות לחלץ אותם.

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

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

היכרות עם Firebase AI Logic כפתרון המרכזי להתמודדות עם האתגרים שדיברנו עליהם.

מהי הצעת הערך ש-Firebase AI Logic מספקת לך?

אנחנו בעצם מטפלים בכל ה-back-end המורכב בהתאמה אישית, כדי שלא תצטרכו לפתח אותו בעצמכם.

שנית, באמצעות ערכות ה-SDK שלנו ללקוחות, אתם יכולים לשלוח קריאות ל-Gemini API ישירות ובאופן מאובטח מהאפליקציות שלכם לנייד.

בואו נסתכל מתחת למכסה המנוע ונבין איך הארכיטקטורה פועלת.

בצד ימין, יש לנו את ערכות ה-SDK של לקוח Firebase.

אנחנו תומכים במגוון רחב של ערכות SDK ללקוחות.

אני רוצה לציין שאנחנו תומכים גם ב-Kotlin.

כשמפתחים רוצים לבצע פעולת AI, ה-SDK שולח את הבקשה ל-Firebase AI Logic, שמנתב אותה באופן בטוח ל-Gemini Developer API או ל-Agent Platform Gemini API.

אז בעצם אנחנו מטפלים בכל ה-back-end בהתאמה אישית שאתם יוצרים היום.

והערך שאנחנו מקבלים מזה הוא שאתם מאיצים את זמן היציאה לשוק (Time to market) ללא עלות.

עכשיו לחלק הכיפי.

זו תהיה הדגמה של אפליקציית FriendlyMeals.

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

אפשר לסרוק אותו באמצעות קוד ה-QR שכאן.

בואו נעבור על ההדגמה.

אפליקציית FriendlyMeals עוזרת לכם למצוא מתכונים לפי המרכיבים שאתם מזינים.

אז בתהליך העבודה הזה, אתם רואים את שתי הדרכים, בעצם, לתעד את הרכיבים האלה.

אפשרות אחת היא להזין את המרכיבים שיש לכם.

בשלב השני, מצלמים את המרכיבים.

אני אשתמש בתהליך העבודה הראשון, שהוא הזנת המרכיבים.

זה כל מה שמצאתי במקרר.

בזמן שהמתכון נוצר, אני רוצה לציין כמה דברים.

אז מאחורי הקלעים, אנחנו קוראים למודלים של Gemini.

בתרחיש הספציפי הזה, אנחנו קוראים לשלושה מודלים של Gemini 3.8 Flash.

אם אתם רואים את התמונה למעלה, היא למעשה משתמשת במודל Gemini Nano Banana, שהוא Nano Banana 2.1, הגרסה העדכנית ביותר.

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

הראשון הוא ערכות SDK ללא שרת (serverless).

אתם רוצים להוסיף תכונת AI, אבל לא רוצים להגדיר קצה עורפי.

כאן נכנסות לתמונה ערכות ה-SDK שלנו בצד הלקוח.

אתם מתקשרים ישירות ל-Gemini מאפליקציית Android.

השני הוא אמצעי אבטחה מובנים ומתקדמים.

אז בקריאות שלכם ל-Gemini, אתם יכולים להשתמש בדברים כמו Firebase App Check וגם בתבניות לפרומפטים בצד השרת ועוד, ונדבר יותר על אמצעי האבטחה האלה קצת מאוחר יותר.

היתרון השלישי הוא התמיכה בתכונות מתקדמות כמו קלט מולטימודלי וסטרימינג.

נניח שאתם רוצים לפתח אפליקציה שמוסיפה תכונת AI פשוטה ליצירת סיפור על תרמיל קסמים.

import com.google.firebase.Firebase
import com.google.firebase.ai.ai

@Composable
fun MagicBackpackGenerator() {
    var output by remember { mutableStateOf("") }

    LaunchedEffect(Unit) {

       val model=Firebase.ai.generativeModel("gemini-4-argon")

        val response = model.generateContent("Write a story about a magic backpack")

        output = response.text.toString()

    }
    MagicBackpackUI(output)
}

כדי להוסיף את תכונת ה-AI הזו ולהכין אותה לסביבת הייצור, צריך לבצע את שלושת השלבים הפשוטים הבאים.

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

בואו נתחיל עם פרטי האבטחה, החל מ-Firebase App Check.

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

זו שכבת אבטחה נוספת שעוזרת למנוע ניצול לרעה של האפליקציה.

לפני שמתחילים לעבוד עם הקוד, צריך לבצע כמה שלבים במסוף Firebase.

לכן, בקטע App Check במסוף Firebase, אתם צריכים לרשום את האפליקציה ל-Android ולהוסיף את ספקי האימות הרלוונטיים.

לדוגמה, Play Integrity או reCAPTCHA Enterprise.

שימו לב שאחרי שמגדירים את App Check, כדאי להתחיל במצב לא נאכף.

כך האפליקציה תוכל לספק נתוני טלמטריה כדי לוודא שכל האפליקציות מקבלות קריאות ל-API שבוצעו בהצלחה לקצה העורפי לפני האכיפה.

אחרי שמוודאים שהנתונים האלה מתקבלים כמו שצריך, אפשר לאכוף את App Check. בשלב הזה, כל בקשה שלא כוללת אסימון תקין שאומת בחומרה תידחה.

ככה נראה הקוד להטמעת App Check.

class FireTravelApp : Application() {
   lateinit var appContainer: AppContainer
       private set
   override fun onCreate() {
       super.onCreate()
       if (BuildConfig.DEBUG) {
           Firebase.appCheck.installAppCheckProviderFactory(
               DebugAppCheckProviderFactory.getInstance()
           )
       } else {
           Firebase.appCheck.installAppCheckProviderFactory(
               PlayIntegrityAppCheckProviderFactory.getInstance()
           )
       }
       appContainer = AppContainer(this)
   }
}

במחלקה של האפליקציה, מתקינים את הספק של App Check.

בשלבי הפיתוח, כדאי להשתמש בספק האימות לצורכי ניפוי באגים, וכשמוכנים לעבור לסביבת הייצור, לעבור ל-Play Integrity או ל-reCAPTCHA Enterprise.

אבל חשוב לזכור: צריך להגדיר את App Check לפני שמבצעים קריאות אחרות ל-Firebase.

כשמפתחים פיצ'רים מבוססי-AI, המפתחים בדרך כלל מקודדים הנחיות ישירות בתוך הקוד של האפליקציות שלהם, אבל זה יוצר שני אתגרים גדולים.

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

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

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

במקום לשמור את ההנחיות במכשיר, הן נשמרות בענן.

ככה נראית התצוגה של תבניות לפרומפטים בצד השרת במסוף Firebase.

אתם יוצרים את התבניות בפורמט ‎ .prompt.

---
model: 'gemini-3-flash'
input:
  schema:...
tools:...
---
{{role "system"}}
You're a storyteller that tells nice and joyful stories with happy endings.

{{role "user"}}
Create a story about {{topic}} with the length of {{length}} words in the {{language}} language.

אפשר להגדיר את שם המודל כאן.

אפשר לעדכן אותו בכל שלב.

אתם לא צריכים לשלוח את העדכון המלא של האפליקציה.

אפשר גם לעדכן את ההוראות למערכת, והיא גם מקבלת סכימת JSON קפדנית לקלט ולפלט.

שוב, לא צריך לפרסם גרסה חדשה של האפליקציה.

הוא נמצא בענן, אז אפשר לשנות הנחיה או להחליף מודל באופן מיידי.

כך נראה הקוד ב-Kotlin.

val generativeModel = Firebase.ai.templateGenerativeModel()

val response = generativeModel.generateContent("storyteller-v1",
    mapOf(
        "topic" to topic,
        "length" to length,
        "language" to language
    )
)

output.value = response.text

חשוב לציין שתבניות לפרומפטים בשרת נמצאות בגרסת טרום-השקה (Public Preview).

אפשר גם להטמיע מצב Auth-only.

השיטה הזו משתמשת בטוקנים של משתמשים באימות ב-Firebase כדי לאשר בקשות.

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

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

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

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

הערה לגבי שני המצבים שראינו: שניהם זמינים באותו חלון.

אחרי שמפעילים את המעקב אחרי שימוש בתכונות AI במסוף Firebase, הנתונים מוזנים ישירות למרכז הבקרה של המעקב אחרי שימוש בתכונות AI.

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

אפשר גם לבדוק את Trace viewer כדי לראות עקבות מסוימים.

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

במסוף Firebase, שבו אפשר לקבל את כל נתוני הטלמטריה ולראות איך תכונת ה-AI פועלת.

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

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

אז השימוש במודלים במכשיר של Nano 4 ב-Android, פותח שלושה יתרונות עיקריים, שכולכם אולי מכירים.

הראשון הוא מצב אופליין.

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

העלות.

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

והשלישי הוא פרטיות הנתונים.

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

לכן, באמצעות Firebase AI Logic, אתם יכולים להגדיר את מצבי ההיסק האלה ולקבל אסטרטגיות ניתוב ברורות, כמו PREFER_ON_DEVICE,‏ PREFER_IN_CLOUD או ONLY_ON_DEVICE.

כשבוחרים באפשרות ONLY_ON_DEVICE, ה-SDK משתמש ישירות במודל שבמכשיר, בלי להשתמש בענן בכלל.

בואו נעבור לטלפון.

אז שוב, אנחנו הולכים ל-FriendlyMeals, ואנחנו הולכים להסתכל על כמה מהיכולות במכשיר.

אז הדבר הראשון שננסה לעשות הוא ליצור מתכון על סמך חלק מהמרכיבים שיכול להיות שיש לנו במקרר.

אז קודם ראיתם את אנקיטה משתמשת בשיטה הידנית, פשוט מקלידה את המרכיבים ואז יוצרת את המתכון.

אז בואו ננסה דרך אחרת.

אז בואו ניקח את המקרר האמיתי הזה, שלא נוצר על ידי AI.

יש הרבה זיתים במקרר הזה, אז בואו נראה איזה סוג של מתכון נקבל כאן.

אז אני רוצה לציין כמה דברים.

אחת מהן היא שהתמונה אף פעם לא נשלחה מהמכשיר.

התמונה נותחה באופן מקומי על ידי Nano by Gemma…

Nano 4.

הדבר השני הוא המהירות שבה התקבלה התשובה.

אז נוצרו המרכיבים.

כך אתם נהנים משני היתרונות.

הנתונים לא יוצאים מהמכשיר, וגם זמן האחזור מתקצר משמעותית.

אוקיי, בואו נראה איזה מתכון נקבל מהמקרר שמלא בזיתים.

אז הפעם אנחנו משתמשים בענן.

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

לא ראיתי סלמון במקרר, אבל אני רואה סלמון במתכון.

אבל בואו נחזור לשקפים, בבקשה.

כמו שראינו בהדגמה, המעבר בין מודל מקומי למודל בענן הוא די פשוט.

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

כדי לנהל את ההסקה הזו, אפשר לחשוב על זה כמו על מעקות בטיחות.

לכן, הארכיטקטורה כוללת תמיכה מובנית בתכונות כמו סכימות מולטימודליות וסכימות קלט ופלט, וגם שילוב מלא עם Gemma, סליחה, עם Gemini Nano 4.

בואו נראה איך אמצעי ההגנה האלה מיושמים בפועל.

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

מבחינת הקוד, זה פשוט פרמטר נוסף.

מעבירים פרמטר onDeviceConfig כדי להגדיר את המצב המועדף.

import com.google.firebase.Firebase
import com.google.firebase.ai.ai

@Composable
fun MagicBackpackGenerator() {
    var output by remember { mutableStateOf("") }

    LaunchedEffect(Unit) {

        val model = Firebase.ai.generativeModel(modelName = "gemini-3.8-flash",
onDeviceConfig = OnDeviceConfig(mode = InferenceMode.PREFER_ON_DEVICE))

       val response = model.generateContent("Write a story about a magic backpack")

        output = response.text.toString()

    }
    MagicBackpackUI(output)
}

במקרה כזה, ה-SDK ינסה קודם את המודל המקומי, ואם הוא לא זמין, הוא יעבור אוטומטית לענן.

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

תכונות גנרטיביות יכולות להתרחב במהירות, וכך גם החיוב ב-Cloud.

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

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

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

כאן נכנסות לתמונה תקרות ההוצאות ב-Firebase.

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

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

כשההוצאות מגיעות ל-100%, מערכת Firebase משהה באופן אוטומטי את שירות ה-AI כדי למנוע חיובים לא צפויים.

מעבר למגבלות הוצאה פשוטות, יש כמה אסטרטגיות מתקדמות לאופטימיזציה של עלויות.

הפעם אנחנו רוצים להתמקד בטריגרים של Firebase AI Logic.

מה קורה אם אתם צריכים לוגיקה מותאמת אישית באמצע?

אלה הטריגרים של Firebase AI Logic.

אפשר להריץ פונקציה לפני יצירת התוכן או אחריו.

אפשר להשתמש בו כדי לבדוק את המשתמש, לסנן את הקלט, להוסיף הקשר וגם להתאים את התשובה.

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

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

כדי להסיק מסקנות, לכתוב קוד, ליצור מדיה ולעבד טקסט במהירות גבוהה, אתם יכולים להשתמש במודלים Gemini 4 Argon,‏ Gemini 3.1 Pro,‏ Gemini 3.8 Flash ועוד.

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

ולבסוף, בתחום הקול, אנחנו מספקים המרת טקסט לדיבור (TTS) טבעית ויצירת אודיו ב-Gemini Live.

נעבור לטלפון פעם נוספת.

אז כאן יש לנו את המתוק והמלוח.

אוי, סליחה, לא זה.

הנה הטוסט המהיר שלנו עם גבינה וקטשופ.

נשמע טעים.

הדבר הראשון שנרצה לבדוק הוא Live API.

אז במקרה הזה, נוכל להשתמש בסרטון שחוזר ואני יכול להגיד, "היי Gemini, אתה יכול להגיד לי מהם המצרכים שעל השולחן?"

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

טוב.

אז אפשר להתחיל עם השלב הראשון במתכון?

כן.

השלב הראשון הוא לחמם מראש את הטוסטר אובן או את הגריל לחום בינוני-גבוה.

תודה.

טוב.

אז במקרה הזה, זה היה Live API והשיחה הזו תישאר פתוחה עד שאסגור אותה בפועל.

התכונה השנייה שאני רוצה להראות היא המרת דיבור לטקסט, או המרת טקסט לדיבור, סליחה.

ובדוגמה הזו, עם המרת טקסט לדיבור, יש לנו את ההוראות של המתכון.

אז במקום לקרוא את ההוראות, אני יכול ללחוץ על "יצירה" או "דיבור" והטקסט של ההוראות יישלח למודל המרת הטקסט לדיבור (TTS).

הוא ייצור את האודיו וישלח אותו בחזרה למכשיר.

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

1.

מחממים מראש טוסטר אובן או גריל לחום בינוני-גבוה.

2.

מניחים שתי פרוסות לחם על תבנית אפייה או על מגש של טוסטר אובן.

נחמד.

מגניב, נכון?

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

בואו נחזור לשקפים.

עכשיו, אחרי שראינו בהדגמה איך Gemini Live API עובד, מה אם אתם רוצים ליצור בעצמכם ממשק צ'אט עם AI בהפעלה קולית?

כאן נכנס לתמונה Gemini Live API, שמאפשר ליצור שיחות קוליות דו-כיווניות.

אפליקציית Android יכולה לשדר אודיו מהמיקרופון ופריימים מהמצלמה בזמן אמת, ולקבל בחזרה תשובות קוליות טבעיות בזמן אמת ועם זמן אחזור קצר.

ב-Kotlin, ההגדרה הזו נראית די מוכרת.

val model = Firebase.ai.liveModel(
    modelName = "gemini-3.1-flash-live-preview",
    generationConfig = liveGenerationConfig {
        responseModality = ResponseModality.AUDIO
   },
   systemInstruction = "Your main job is to change the color...",
   tools = listOf(Tool.functionDeclarations(listOf(changeColorFunction)))
)

val session = model.connect(::handler)

session.startAudioConversation(::handler)

session.stopAudioConversation()

אתם יוצרים מופע של מודל Live שמוגדר לתשובות קוליות, ומתחברים לסשן באמצעות handler של סטרימינג.

הנקודה הכי חשובה שצריך לציין כאן היא שה-SDK מטפל בכל מה שקשור ל-WebSocket ולפרוטוקולים של סטרימינג מאחורי הקלעים.

אז לא צריך לתכנת את זה, נכון?

ממשיכים לכתוב שורות.

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

# Execute to add agent capabilities to your workspace
npx skills add firebase/agent-skills

בנוסף, אם אתם משתמשים ב-Antigravity וב-Android Studio, כבר שילבנו את Firebase AI Logic ישירות בתהליך ההצטרפות.

לסיום, הנה שלוש נקודות חשובות: התחילו לבנות, היעזרו בכלים בשלב מוקדם, כמו כלי האבטחה שדיברנו עליהם היום, והשתמשו במיומנויות של הסוכנים בכל מקום שאפשר.

תודה.