אנחנו שמחים לבשר על אבן דרך משמעותית בקירוב בין מחשוב נייד למחשוב שולחני ב-Android: תמיכה בצגים מחוברים הגיעה לזמינות לכלל המשתמשים (GA) עם הגרסה Android 16 QPR3! 

כפי שהוצג ב- Google I/O 2025, צגים מחוברים מאפשרים למשתמשים לחבר את מכשירי Android שלהם למסך חיצוני ולקבל גישה מיידית לסביבת חלונות של מחשב. אפשר להשתמש באפליקציות בחלונות חופשיים או בחלונות מוגדלים, והמשתמשים יכולים לבצע ריבוי משימות כמו במערכת הפעלה למחשב.

‫Google ו-Samsung שיתפו פעולה כדי לספק חוויית שימוש חלקה ועוצמתית בממשק מחשב במכשירים שפועלת בהם מערכת Android 16 בסביבת Android, כשהם מחוברים למסך חיצוני. 
התכונה הזו זמינה עכשיו לכלל המשתמשים במכשירים נתמכים*, שמאפשרת להם לחבר את טלפוני Pixel ו-Samsung הנתמכים שלהם לצגים חיצוניים. כך הם יכולים ליצור חוויות שימוש באפליקציות שהן יותר מעניינות ויותר פרודוקטיביות, ומתאימות למגוון גורמי צורה.

איך זה עובד

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

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

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

כשמכשיר שתומך בממשק מחשב (כמו טאבלט Samsung Galaxy Tab S11) מחובר למסך חיצוני, סביבת העבודה במחשב מורחבת לשני המסכים, ומתקבלת סביבת עבודה רחבה עוד יותר. שני המסכים פועלים כמערכת אחת רציפה, ומאפשרים לחלונות של האפליקציות, לתוכן ולסמן לעבור בחופשיות בין המסכים.

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

למה הוא חשוב?

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

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

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

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

בנייה לעתיד של המחשבים עם כלים מודרניים

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

סיווגים חדשים של גודל החלון: Large ו-Extra-large

העדכון הכי משמעותי ב-Jetpack WindowManager 1.5.0 הוא הוספה של שתי קטגוריות חדשות של גודל חלון לפי רוחב: Large ו-Extra-large.

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

אלה נקודות עצירה חדשות לרוחב:

• גדול: לרוחב של 1,200dp עד 1,600dp
• גדול במיוחד: לרוחבים של ‎≥1600dp

הסיווגים השונים של גודל החלון על סמך רוחב התצוגה.

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

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

val currentWindowMetrics =
    WindowMetricsCalculator.getOrCreate()
    .computeCurrentWindowMetrics(LocalContext.current)

val sizeClass = WindowSizeClass.BREAKPOINTS_V2
    .computeWindowSizeClass(currentWindowMetrics)

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

if(sizeClass.isWidthAtLeastBreakpoint(
    WindowSizeClass.WIDTH_DP_LARGE_LOWER_BOUND)){
    ...
	// Window is at least 1200 dp wide.
}

פיתוח פריסות מותאמות באמצעות Jetpack Navigation 3

‫Navigation 3 הוא התוסף האחרון לאוסף Jetpack. ‫Navigation 3, שהגיע לאחרונה לגרסה היציבה הראשונה שלו, הוא ספריית ניווט עוצמתית שנועדה לעבוד עם Compose.

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

המערכת הזו לניהול זרימת ממשק המשתמש של האפליקציה מבוססת על Scenes. סצנה היא פריסה שמציגה יעד אחד או יותר בו-זמנית. ‫SceneStrategy קובע אם אפשר ליצור סצנה. שרשור של מופעים של SceneStrategy מאפשר ליצור ולהציג סצנות שונות לגדלים שונים של מסכים ולתצורות שונות של מכשירים.

כדי ליצור פריסות קנוניות מוכנות לשימוש, כמו רשימה עם פרטים וחלון תומך, אפשר להשתמש בסצנות מהספרייה של Compose Material 3 Adaptive (זמינה בגרסה 1.3 ואילך).

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

class ThreePaneScene<T : Any>(
    override val key: Any,
    override val previousEntries: List<NavEntry<T>>,
    val firstEntry: NavEntry<T>,
    val secondEntry: NavEntry<T>,
    val thirdEntry: NavEntry<T>
) : Scene<T> {
    override val entries: List<NavEntry<T>> = listOf(firstEntry, secondEntry, thirdEntry)
    override val content: @Composable (() -> Unit) = {
        Row(modifier = Modifier.fillMaxSize()) {
            Column(modifier = Modifier.weight(1f)) {
                firstEntry.Content()
            }
            Column(modifier = Modifier.weight(1f)) {
                secondEntry.Content()
            }
            Column(modifier = Modifier.weight(1f)) {
                thirdEntry.Content()
            }
        }
    }

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

class ThreePaneSceneStrategy<T : Any>(val windowSizeClass: WindowSizeClass) : SceneStrategy<T> {
    override fun SceneStrategyScope<T>.calculateScene(entries: List<NavEntry<T>>): Scene<T>? {
        if (windowSizeClass.isWidthAtLeastBreakpoint(WIDTH_DP_LARGE_LOWER_BOUND)) {
            val lastThree = entries.takeLast(3)
            if (lastThree.size == 3 && lastThree.all { it.metadata.containsKey(MULTI_PANE_KEY) }) {
                val firstEntry = lastThree[0]
                val secondEntry = lastThree[1]
                val thirdEntry = lastThree[2]


                return ThreePaneScene(
                    key = Triple(firstEntry.contentKey, secondEntry.contentKey, thirdEntry.contentKey),
                    previousEntries = entries.dropLast(3),
                    firstEntry = firstEntry,
                    secondEntry = secondEntry,
                    thirdEntry = thirdEntry
                )
            }
        }
        return null
    }
}

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

val strategy = ThreePaneSceneStrategy() then TwoPaneSceneStrategy()

NavDisplay(..., 
  sceneStrategy = strategy,
  entryProvider = entryProvider { 
    entry<MyScreen>(metadata = mapOf(MULTI_PANE_KEY to true))) { ... }
    ... other entries...
  }
)

אם אין מספיק מקום להצגת שלושה או שני חלונות – שתי האסטרטגיות שלנו ליצירת סצנות בהתאמה אישית מחזירות null. במקרה כזה, NavDisplay חוזר להצגת הרשומה האחרונה במקבץ פעילויות קודמות (back stack) בחלונית אחת באמצעות SinglePaneScene. 

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

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

בתיעוד מוסבר איך ליצור פריסות בהתאמה אישית באמצעות סצנות בגרסה 3 של Navigation.

פריסות מותאמות עצמאיות

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

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

כדי להפעיל את התכונה, צריך להצהיר בקובץ ה-build של Gradle שרוצים להשתמש בנקודות העצירה החדשות:

currentWindowAdaptiveInfo(supportLargeAndXLargeWidth = true)

תחילת העבודה

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

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

משוב

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

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

*הערה: בזמן כתיבת המאמר, יש תמיכה במסכים מחוברים בסדרות Pixel 8,‏ 9 ו-10 ובמגוון רחב של מכשירי Samsung, כולל S26,‏ Fold7,‏ Flip7 ו-Tab S11.