מכשירי Android מתחברים בקלות למסכים חיצוניים

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

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

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

איך זה עובד

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

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

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

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

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

למה הוא חשוב?

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

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

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

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

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

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

מחלקות חדשות של גודל חלון: גדול וגדול מאוד

העדכון הכי גדול ב-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.

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

המערכת הזו לניהול תהליך העבודה של ממשק המשתמש באפליקציה מבוססת על סצנות. סצנה היא פריסה שבה מוצג יעד אחד או יותר בו-זמנית. האובייקט 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 כדי להציג שלוש חלוניות אם רוחב החלון מספיק גדול, והרשומות ממקבץ הפעילויות הקודמות (back stack) הצהירו שהן תומכות בהצגה בסצנה עם שלוש חלוניות.

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. 

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

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

במסמכי התיעוד מוסבר איך יוצרים פריסות בהתאמה אישית באמצעות סצנות ב-Navigation 3.

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

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

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

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

currentWindowAdaptiveInfo(supportLargeAndXLargeWidth = true)

תחילת העבודה

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

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

משוב

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

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

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