ניהול החלונות

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

איור 1. חלון של אפליקציה במכשירים שונים.

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

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

גודל ההשקה הראשונית

אפליקציות יכולות לבקש את גודל ההפעלה הראשוני שלהן בדרכים הבאות:

אפשר להשתמש בגודל ההשקה רק בסביבות למחשב. כך מנהל החלונות יכול לספק לכם את הגבולות והכיוון הנכונים. כדי לציין העדפות כשמשתמשים במצב מחשב, מוסיפים את המטא תגים הבאים בתוך התג <activity>:
```
&lt;meta-data android:name=&#34;WindowManagerPreference:FreeformWindowSize&#34;
           android:value=&#34;[phone|tablet|maximize]&#34; /&gt;
&lt;meta-data android:name=&#34;WindowManagerPreference:FreeformWindowOrientation&#34;
           android:value=&#34;[portrait|landscape]&#34; /&gt;
```

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

&lt;layout android:defaultHeight=&#34;500dp&#34;
            android:defaultWidth=&#34;600dp&#34;
            android:gravity=&#34;top|end&#34;
            android:minHeight=&#34;450dp&#34;
            android:minWidth=&#34;300dp&#34; /&gt;

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

שינוי הגודל של חלונות

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

איור 2. חלון אפליקציה שאפשר לשנות את הגודל שלו.

יש שתי אפשרויות לטיפול בשינוי גודל החלון כשמשתמשים במחלקה View:

כדי להגיב לשינויים בהגדרות באופן דינמי, צריך לקרוא ל-onConfigurationChanged(..). לדוגמה, אפשר להוסיף את השורה android:configChanges="screenSize|smallestScreenSize|orientation|screenLayout" למניפסט של הפעילות. מידע נוסף על טיפול בשינויים בהגדרות זמין במאמר טיפול בשינויים בהגדרות.
מאפשרים למערכת להפעיל מחדש את הפעילות. במקרה כזה, צריך להטמיע את onSaveInstanceState ולהשתמש ברכיב ViewModel architecture כדי לשחזר את המצב הקודם שנשמר.

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

מידות החלון

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

כדי לקבוע את ההגדרה הנוכחית, קוראים ל-getResources().getConfiguration() בפעילות הנוכחית. לא משתמשים בהגדרה של פעילות הרקע או במשאב המערכת. לפעילות ברקע אין גודל, והגדרת המערכת עשויה לכלול כמה חלונות עם גדלים וכיוונים סותרים, ולכן לא ניתן לחלץ נתונים שמישים.

שימו לב שגודל החלון וגודל המסך הם לא אותו דבר. כדי לקבל את גודל החלון ב-DP, משתמשים בפונקציות Activity.getResources().getConfiguration().screenWidth ו-Activity.getResources().getConfiguration().screenHeight. סביר להניח שלא תצטרכו להשתמש בגודל המסך.

גבולות התוכן

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

אפליקציות שמשתמשות בתהליך הפריסה של Android נפרסות באופן אוטומטי בשטח הזמין.
אפליקציות מקוריות צריכות לקרוא את האזור הזמין ולעקוב אחרי שינויים בגודל כדי למנוע מצב שבו רכיבי ממשק המשתמש לא נגישים. מפעילים את ה-methods הבאות כדי לקבוע את הגודל הזמין הראשוני של השטח הזה:
- NativeActivity.mLastContent[X/Y/Width/Height]()
- findViewById(android.R.id.content).get[Width/Height]()
אפשר לבצע מעקב רציף באמצעות אובייקט observer:
- NativeActivity.onContentRectChangedNative()
- NativeActivity.onGlobalLayout()
- הוספת מאזין ל-view.addOnLayoutChangeListener(findViewById(android.R.id.content))
אם האפליקציה מבצעת שינוי גודל מראש של הגרפיקה שלה, צריך לעשות זאת בכל פעם שהרזולוציה משתנה.

שינוי גודל חופשי

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

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

מצב מסך מלא

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

כיוון המסך

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

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

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

הפעילות והכיוון של הרכיב הבסיסי

חלון Chromebook מורכב מערימה של חלונות פעילות. לכל חלון בערימה יש את אותו גודל ואותו כיוון.

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

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

הנחיות לגבי כיוון

חשוב להקפיד על ההנחיות הבאות לגבי כיוון:

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

דברים נוספים שכדאי לזכור

הנה עוד כמה דברים שכדאי לקחת בחשבון כשעובדים עם אפליקציות ל-Android ב-ChromeOS:

אל תפעילו את finish() בשיטה onDestroy של הפעילות. כתוצאה מכך, האפליקציה נסגרת כשמשנים את הגודל שלה ולא מופעלת מחדש.
אל תשתמשו בסוגי חלונות לא תואמים, כמו TYPE_KEYGUARD ו-TYPE_APPLICATION_MEDIA.
כדי להפעיל מחדש פעילויות במהירות, אפשר לשמור במטמון אובייקטים שהוקצו בעבר.
אם לא רוצים שהמשתמש יוכל לשנות את הגודל של האפליקציה, צריך לציין את הערך android:resizeableActivity=false בקובץ המניפסט.
בודקים את האפליקציה כדי לוודא שהיא מטפלת בצורה נכונה בשינויים בגודל החלון.