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

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

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

ציור מקצה לקצה מאחורי סרחי המערכת
איור 1. ציור מקצה לקצה מאחורי סרחי המערכת.

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

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

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

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

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

הגודל של ממשק המשתמש של המערכת והמידע על המיקום שלו צוינו דרך insets.

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

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

WindowInsets.statusBars

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

WindowInsets.statusBarsIgnoringVisibility

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

WindowInsets.navigationBars

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

WindowInsets.navigationBarsIgnoringVisibility

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

WindowInsets.captionBar

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

WindowInsets.captionBarIgnoringVisibility

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

WindowInsets.systemBars

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

WindowInsets.systemBarsIgnoringVisibility

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

WindowInsets.ime

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

WindowInsets.imeAnimationSource

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

WindowInsets.imeAnimationTarget

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

WindowInsets.tappableElement

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

WindowInsets.tappableElementIgnoringVisibility

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

WindowInsets.systemGestures

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

WindowInsets.mandatorySystemGestures

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

WindowInsets.displayCutout

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

WindowInsets.waterfall

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

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

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

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

הגדרת Insets

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

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

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

מגבילי מרווח פנימי

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

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

רכיבי שינוי של גודל הקלט

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

Modifier.windowInsetsStartWidth(windowInsets: WindowInsets)

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

Modifier.windowInsetsEndWidth(windowInsets: WindowInsets)

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

Modifier.windowInsetsTopHeight(windowInsets: WindowInsets)

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

Modifier.windowInsetsBottomHeight(windowInsets: WindowInsets)

החלת הצד התחתון של windowInsets כגובה (כמו Modifier.height)

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

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

צריכת מודעות מוטמעות

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

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

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

לאחר אותה דוגמה של 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 פיתוח נייטיב

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

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

אנימציות 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 בתוך רכיבים אחרים

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

טיפול ברכיבים קומפוזביליים

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

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

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

פיגום

כברירת מחדל, 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

שינוי רכיבי inset שמוגדרים כברירת מחדל

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

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

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

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

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

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

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

משאבים