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

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

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

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

ב-Android מגרסה 14 (רמת API 34) וגרסאות קודמות, ממשק המשתמש של האפליקציה לא מצויר מתחת לסרגלי המידע של המערכת ולא מציג חתכים כברירת מחדל.

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

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

יסודות של מוטמעים

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

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

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

סוגי המודעות המובנות האלה ל-Android זמינים דרך WindowInsets:

WindowInsets.statusBars

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

WindowInsets.statusBarsIgnoringVisibility

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

WindowInsets.navigationBars

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

WindowInsets.navigationBarsIgnoringVisibility

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

WindowInsets.captionBar

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

WindowInsets.captionBarIgnoringVisibility

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

WindowInsets.systemBars

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

WindowInsets.systemBarsIgnoringVisibility

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

WindowInsets.ime

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

WindowInsets.imeAnimationSource

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

WindowInsets.imeAnimationTarget

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

WindowInsets.tappableElement

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

WindowInsets.tappableElementIgnoringVisibility

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

WindowInsets.systemGestures

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

WindowInsets.mandatorySystemGestures

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

WindowInsets.displayCutout

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

WindowInsets.waterfall

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

הסוגים האלה מסוכמים בשלושה סוגים של 'הוספה בחלון משנה' 'בטוחים', שמבטיחים שהתוכן לא מוסתר:

המונחים "בטוחים" סוגי Inset מגינים על תוכן בדרכים שונות, על סמך insets של הפלטפורמה הבסיסית:

  • משתמשים ב-WindowInsets.safeDrawing כדי להגן על תוכן שאסור לצייר מתחת לממשק המשתמש של המערכת. זהו השימוש הנפוץ ביותר לרכיבי inset: כדי למנוע שרטוט שמוסתר על ידי ממשק המשתמש של המערכת (באופן חלקי או חלקי לגמרי).
  • שימוש ב-WindowInsets.safeGestures כדי להגן על תוכן באמצעות תנועות. הזה מונע התנגשויות של תנועות מערכת עם תנועות באפליקציה (כמו אלה שמיועדות לתחתית המסך גיליונות אלקטרוניים, קרוסלות או משחקים).
  • צריך להשתמש ב-WindowInsets.safeContent כשילוב של WindowInsets.safeDrawing וWindowInsets.safeGestures כדי לוודא אין חפיפה ויזואלית בתוכן או חפיפה בין תנועות.

הגדרת שוליים

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

  1. מטרגטים ל-SDK 35 ואילך כדי לאכוף תצוגה מקצה לקצה ב-Android 15 ואילך. האפליקציה שלך מוצגת מאחורי ממשק המשתמש של המערכת. אתם יכולים לשנות את ממשק המשתמש של האפליקציה באמצעות רכיבי insets.
  2. אפשר גם להתקשר למספר enableEdgeToEdge() Activity.onCreate(), שמאפשר להציג את האפליקציה מקצה לקצה גרסאות Android.

  3. הגדרת android:windowSoftInputMode="adjustResize" בהגדרות הפעילות שלך ערך AndroidManifest.xml. ההגדרה הזו מאפשרת לאפליקציה לקבל את הגודל של ה-IME של התוכנה כרכיבי inset, שבהם תוכלו להשתמש כדי לרבד ולפרוס תוכן. כאשר ה-IME מופיע ונעלם באפליקציה.

    <!-- in your AndroidManifest.xml file: -->
<activity
  android:name=".ui.MainActivity"
  android:label="@string/app_name"
  android:windowSoftInputMode="adjustResize"
  android:theme="@style/Theme.MyApplication"
  android:exported="true">

כתיבת ממשקי API

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

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

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)

    enableEdgeToEdge()

    setContent {
        Box(Modifier.safeDrawingPadding()) {
            // the rest of the app
        }
    }
}
InsetsSnippets.kt

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

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

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

משתני מרווח פנימי

Modifier.windowInsetsPadding(windowInsets: WindowInsets) מחילה את החלון מוגדר כמרווח פנימי, שפועל בדיוק כמו Modifier.padding. לדוגמה, Modifier.windowInsetsPadding(WindowInsets.safeDrawing) חל השרטוט הבטוח משתלב כמרווח הפנימי בכל 4 הצדדים.

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

משתני גודל של תמונות מוטמעות

המשנים הבאים מחילים כמות של רכיבי inset של החלון על ידי הגדרת הגודל של שהרכיב יהיה בגודל הרכיבים הפנימיים:

Modifier.windowInsetsStartWidth(windowInsets: WindowInsets)

המערכת מחילה את צד ההתחלה של רכיבי window Inset כרוחב (למשל Modifier.width)

Modifier.windowInsetsEndWidth(windowInsets: WindowInsets)

החלת הצד הסופי של windowInsets כרוחב (כמו Modifier.width)

Modifier.windowInsetsTopHeight(windowInsets: WindowInsets)

המערכת מחילה את הצד העליון של רכיבי window Inset כגובה (למשל Modifier.height)

Modifier.windowInsetsBottomHeight(windowInsets: WindowInsets)

המערכת מחילה את הצד התחתון של רכיבי window Inset כגובה (למשל Modifier.height)

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

LazyColumn(
    Modifier.imePadding()
) {
    // Other content
    item {
        Spacer(
            Modifier.windowInsetsBottomHeight(
                WindowInsets.systemBars
            )
        )
    }
}
InsetsSnippets.kt

צריכה קבועה

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

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

כתוצאה מכך, משתני padding בתוך עץ משנים באופן אוטומטי את כמות ה-padding שחלה על כל רכיב.

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

LazyColumn(
    Modifier.imePadding()
) {
    // Other content
    item {
        Spacer(
            Modifier.windowInsetsBottomHeight(
                WindowInsets.systemBars
            )
        )
    }
}
InsetsSnippets.kt

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

כשה-IME נפתח, האנימציה של הרכיבים הפנימיים של ה-IME מתאימה את עצמה לגודל של ה-IME, והמַגְדִּיל imePadding() מתחיל להוסיף ריפוד לתחתית כדי לשנות את הגודל של LazyColumn בזמן פתיחת ה-IME. לאחר תחילת הצירוף של imePadding() הריפוד התחתון, הוא גם מתחיל לצרוך את הכמות הזו של תוספות. לכן, הגובה של Spacer מתחיל לרדת, כחלק מהמרווח בין ערכי המערכת העמודות כבר הוחלו על ידי הצירוף imePadding(). ברגע שהמַעַדן imePadding() מחיל כמות של ריפוד בחלק התחתון שגדולה מהעמודות של המערכת, הגובה של Spacer הוא אפס.

כשה-IME נסגר, השינויים מתרחשים בכיוון ההפוך: ה-Spacer מתחיל להתרחב מגובה אפס ברגע שה-imePadding() חל על פחות מהצד התחתון של סרחי המערכת, עד שה-Spacer תואם לגובה של הצד התחתון של סרחי המערכת ברגע שהאנימציה של ה-IME מסתיימת.

איור 2. עמודה עצלה מקצה לקצה עם TextField.

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

גם Modifier.consumeWindowInsets(insets: WindowInsets) צורך רכיבי inset באותו אופן כמו Modifier.windowInsetsPadding, אבל הוא לא מחיל את רכיבי ה-inset שנצרכו כמילוי. זה שימושי בשילוב עם הרכיב המוטמע לשינויי גודל, כדי לציין לאחיות שכמות מסוימת של תוספות גודל כבר נצרכו:

Column(Modifier.verticalScroll(rememberScrollState())) {
    Spacer(Modifier.windowInsetsTopHeight(WindowInsets.systemBars))

    Column(
        Modifier.consumeWindowInsets(
            WindowInsets.systemBars.only(WindowInsetsSides.Vertical)
        )
    ) {
        // content
        Spacer(Modifier.windowInsetsBottomHeight(WindowInsets.ime))
    }

    Spacer(Modifier.windowInsetsBottomHeight(WindowInsets.systemBars))
}
InsetsSnippets.kt

התנהגות הפונקציה Modifier.consumeWindowInsets(paddingValues: PaddingValues) דומה מאוד לזו של הגרסה עם הארגומנט WindowInsets, אבל היא מקבלת לשימוש PaddingValues שרירותי. הדבר שימושי כדי להודיע לצאצאים מתי הרווח או המילוי מסופקים על ידי מנגנון אחר מלבד המשתנים של המילוי הפנימי, כמו Modifier.padding רגיל או רווחים בגובה קבוע:

Column(Modifier.padding(16.dp).consumeWindowInsets(PaddingValues(16.dp))) {
    // content
    Spacer(Modifier.windowInsetsBottomHeight(WindowInsets.ime))
}
InsetsSnippets.kt

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

שלבי Insets ו-Jetpack פיתוח נייטיב

התכונה 'פיתוח נייטיב' משתמשת בממשקי ה-API הבסיסיים של AndroidX כדי לעדכן ולהנפיש רכיבי inset, שמבוססים על ממשקי ה-API של הפלטפורמה הבסיסית שמנהלים insets. בגלל התנהגות הפלטפורמה הזו, ל-insets יש קשר מיוחד לשלבים של Jetpack Compose.

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

אנימציות IME במקלדת עם WindowInsets

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

class WindowInsetsExampleActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        WindowCompat.setDecorFitsSystemWindows(window, false)

        setContent {
            MaterialTheme {
                MyScreen()
            }
        }
    }
}

@OptIn(ExperimentalLayoutApi::class)
@Composable
fun MyScreen() {
    Box {
        LazyColumn(
            modifier = Modifier
                .fillMaxSize() // fill the entire window
                .imePadding() // padding for the bottom for the IME
                .imeNestedScroll(), // scroll IME at the bottom
            content = { }
        )
        FloatingActionButton(
            modifier = Modifier
                .align(Alignment.BottomEnd)
                .padding(16.dp) // normal 16dp of padding for FABs
                .navigationBarsPadding() // padding for navigation bar
                .imePadding(), // padding for when IME appears
            onClick = { }
        ) {
            Icon(imageVector = Icons.Filled.Add, contentDescription = "Add")
        }
    }
}
MigrationOtherConsiderationsSnippets.kt

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

תמיכה ברכיבי Material 3 בתוך רכיבים אחרים

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

רכיבים מורכבים בתוך קטע

בהמשך מופיעה רשימה של רכיבי Material שמטפלים באופן אוטומטי בהוספת שוליים.

סרגי האפליקציות

  • TopAppBar / SmallTopAppBar / CenterAlignedTopAppBar / MediumTopAppBar / LargeTopAppBar: המערכת מפעילה את הצדדים העליונים ואת הצדדים האופקיים של סרגלי המערכת כמרווח פנימי כי נעשה בו שימוש בחלק העליון של החלון.
  • BottomAppBar: המערכת מחילה את הצדדים התחתונים והאופקיים של סרגלי המערכת כמרווח פנימי.

קונטיינרים של תוכן

פיגום

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

Scaffold { innerPadding ->
    // innerPadding contains inset information for you to use and apply
    LazyColumn(
        // consume insets as scaffold doesn't do it by default
        modifier = Modifier.consumeWindowInsets(innerPadding),
        contentPadding = innerPadding
    ) {
        items(count = 100) {
            Box(
                Modifier
                    .fillMaxWidth()
                    .height(50.dp)
                    .background(colors[it % colors.size])
            )
        }
    }
}
InsetsSnippets.kt

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

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

לדוגמה, כדי להשבית את הטיפול בהטמעה ב-LargeTopAppBar, מגדירים את הפרמטר windowInsets למכונה ריקה:

LargeTopAppBar(
    windowInsets = WindowInsets(0, 0, 0, 0),
    title = {
        Text("Hi")
    }
)
InsetsSnippets.kt

יכולת פעולה הדדית עם התצוגות המפורטות של מערכת View

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

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

כברירת מחדל, כל ComposeView צורך את כל ה-insets ברמת הצריכה WindowInsetsCompat. כדי לשנות את התנהגות ברירת המחדל, צריך להגדיר ComposeView.consumeWindowInsets אל false.

משאבים