פלטפורמת Android אחראית לציור ממשק המשתמש של המערכת, כמו שורת המצב וסרגל הניווט. ממשק המשתמש של המערכת מוצג ללא קשר לאפליקציה שבה המשתמש משתמש.
WindowInsets
מספק מידע על המערכת
ממשק משתמש שנועד לוודא שהאפליקציה משורטטת באזור הנכון ושממשק המשתמש לא מוסתר
על ידי ממשק המשתמש של המערכת.
ב-Android מגרסה 14 (רמת API 34) וגרסאות קודמות, ממשק המשתמש של האפליקציה לא מצויר מתחת לסרגלי המידע של המערכת ולא מציג חתכים כברירת מחדל.
ב-Android 15 ואילך (רמת API 35 ואילך), האפליקציה תציג את התוכן מתחת לסרגלי המערכת ותציג פריימים חתוכים אם היא מטרגטת ל-SDK 35. כך חוויית השימוש תהיה חלקה יותר, והאפליקציה תוכל לנצל את כל שטח החלון שזמין לה.
הצגת תוכן מאחורי ממשק המשתמש של המערכת נקראת מלא מסך. בדף הזה תלמדו על הסוגים השונים של רכיבי inset, איך להציג את האפליקציה מקצה לקצה ואיך להשתמש בממשקי ה-API של הרכיבים האלה כדי להוסיף אנימציה לממשק המשתמש ולוודא שרכיבי ממשק המשתמש של המערכת לא מסתירים את התוכן של האפליקציה.
יסודות של מוטמעים
כשאפליקציה מוצגת מקצה לקצה, חשוב לוודא שהתוכן והאינטראקציות החשובים לא מוסתרים על ידי ממשק המשתמש של המערכת. לדוגמה, אם לחצן הוא מאחורי סרגל הניווט, יכול להיות שהמשתמש לא יוכל ללחוץ עליו.
הגודל של ממשק המשתמש של המערכת והמידע על המיקום שלו מצוינים באמצעות הכנסות.
לכל חלק בממשק המשתמש של המערכת יש סוג תואם של פסקה גודלו והמיקום שבו הוא ממוקם. לדוגמה, רכיבי inset של שורת הסטטוס מספקים את הגודל ואת המיקום של שורת הסטטוס, ואילו הרכיבים הפנימיים של סרגל הניווט מספקים הגודל והמיקום של סרגל הניווט. כל סוג של תצוגה מוטמעת מורכב מארבעה מימדים בפיסקלים: למעלה, ימין, שמאל ותחתון. המאפיינים האלה מציינים את המרחק ממשק המשתמש של המערכת מתפרס מהצדדים המתאימים של חלון האפליקציה. כדי להימנע שחופף לסוג ממשק משתמש כזה של המערכת, כלומר, ממשק המשתמש של האפליקציה חייב להיות מוטמע בו לסכום.
סוגי המודעות המובנות האלה ל-Android זמינים דרך WindowInsets
:
התמונות המצורפות שמתארות את שורות הסטטוס. אלה סרחי המערכת העליונים בממשק המשתמש, שמכילים סמלי התראות ואינדיקטורים אחרים. |
|
שורת הסטטוס מודגשת כשהיא מוצגת. אם שורות הסטטוס מוסתרות כרגע (בגלל מעבר למצב צפייה immersive במסך מלא), אז הקטעים הפנימיים של שורת הסטטוס הראשית יהיו ריקים, אבל הקטעים הפנימיים האלה לא יהיו ריקים. |
|
התמונות המצורפות שמתארות את סרגי הניווט. אלה סרחי ממשק המשתמש של המערכת בצד ימין, שמאל או תחתון של המכשיר, שמתארים את סמל שורת המשימות או את סמלי הניווט. הם יכולים להשתנות במהלך זמן הריצה בהתאם לשיטת הניווט המועדפת על המשתמש ולאינטראקציה שלו עם סרגל האפליקציות. |
|
סרגל הניווט נדחק פנימה כשהסמלים גלויים. אם סרגי הניווט מוסתרים כרגע (בגלל מעבר למצב צפייה immersive במסך מלא), אז הקטעים הפנימיים של סרגל הניווט הראשי יהיו ריקים, אבל הקטעים הפנימיים האלה לא יהיו ריקים. |
|
התמונה הממוזערת שמתארת את קישוט החלון של ממשק המשתמש של המערכת, אם מדובר בחלון בצורה חופשית, כמו סרגל הכותרת העליון. |
|
סרגל הכתוביות מופיע כשהסטטוס הוא 'גלוי'. אם סרגלי הכתוביות מוסתרות כרגע, הרכיבים הראשיים של סרגל הכתוביות יהיו ריקים, אבל הרכיבים הפנימיים לא יהיו ריקים. |
|
האיחוד של הרכיבים הנוספים בסרגל המערכת, כולל שורת הסטטוס, סרחי הניווט וסרגל הכותרות. |
|
רכיבי inset של סרגל המערכת מציינים מתי הם מוצגים. אם סרחי המערכת מוסתרים כרגע (בגלל מעבר למצב צפייה immersive במסך מלא), אז הקטעים הפנימיים של סרחי המערכת הראשיים יהיו ריקים, אבל הקטעים הפנימיים האלה לא יהיו ריקים. |
|
הרכיבים הפנימיים שמתארים את כמות המקום בחלק התחתון שתופסת מקלדת התוכנה. |
|
אלמנטים נוספים שמתארים את כמות המקום שתפסה מקלדת התוכנה לפני אנימציית המקלדת הנוכחית. |
|
התמונות הממוזערות שמתארות את נפח המרחב שבו תשתמש מקלדת התוכנה אחרי האנימציה הנוכחית של המקלדת. |
|
סוג של תצוגה מפורטת יותר של ממשק המשתמש של הניווט, שמציג את גודל המרחב שבו המערכת תנהל את 'הקשות', ולא האפליקציה. בסרגלי ניווט שקופים עם ניווט באמצעות תנועות, אפשר להקיש על רכיבים מסוימים באפליקציה דרך ממשק המשתמש של ניווט המערכת. |
|
הרכיב שניתן להקיש עליו מוטמע כדי שניתן יהיה לראות אותם. אם הרכיבים שניתן להקיש עליהם מוסתרים כרגע (בגלל מעבר למצב מסך מלא immersive), אז הרכיבים הראשיים של הרכיבים שניתן להקיש עליהם יהיו ריקים, אבל הרכיבים האלה לא יהיו ריקים. |
|
הקטעים הפנימיים שמייצגים את מספר הקטעים הפנימיים שבהם המערכת תפריע להבעות לצורך ניווט. אפליקציות יכולות לציין ידנית טיפול במספר מוגבל של התנועות האלה באמצעות |
|
קבוצת משנה של תנועות המערכת שתמיד יטופלו על ידי המערכת, ולא ניתן לבטל את ההסכמה לשימוש בהן באמצעות |
|
התמונות הממוזערות שמייצגות את כמות הרווחים הנדרשים כדי למנוע חפיפה עם מגרעת במסך (חור או חריץ). |
|
הרכיבים הפנימיים שמייצגים את האזורים המעוגלים של תצוגת Waterfall. במסך Waterfall יש אזורים מעוגלים בקצוות המסך, שבהם המסך מתחיל להתעגל לאורך הצדדים של המכשיר. |
הסוגים האלה מסוכמים בשלושה סוגים של 'הוספה בחלון משנה' 'בטוחים', שמבטיחים שהתוכן לא מוסתר:
המונחים "בטוחים" סוגי Inset מגינים על תוכן בדרכים שונות, על סמך insets של הפלטפורמה הבסיסית:
- משתמשים ב-
WindowInsets.safeDrawing
כדי להגן על תוכן שאסור לצייר מתחת לממשק המשתמש של המערכת. זהו השימוש הנפוץ ביותר לרכיבי inset: כדי למנוע שרטוט שמוסתר על ידי ממשק המשתמש של המערכת (באופן חלקי או חלקי לגמרי). - שימוש ב-
WindowInsets.safeGestures
כדי להגן על תוכן באמצעות תנועות. הזה מונע התנגשויות של תנועות מערכת עם תנועות באפליקציה (כמו אלה שמיועדות לתחתית המסך גיליונות אלקטרוניים, קרוסלות או משחקים). - צריך להשתמש ב-
WindowInsets.safeContent
כשילוב שלWindowInsets.safeDrawing
וWindowInsets.safeGestures
כדי לוודא אין חפיפה ויזואלית בתוכן או חפיפה בין תנועות.
הגדרת שוליים
כדי לאפשר לאפליקציה לקבל שליטה מלאה על המיקומים שבהם היא מיועדת לתוכן, צריך לפעול לפי ההגדרות הבאות לבצע מיליון שלבים. בלי לבצע את השלבים האלה, יכול להיות שהאפליקציה תציג צבעים שחורים או צבעים מוצקים מאחורי ממשק המשתמש של המערכת, או שהאנימציה לא תהיה מסונכרנת עם המקלדת הווירטואלית.
- מטרגטים ל-SDK 35 ואילך כדי לאכוף תצוגה מקצה לקצה ב-Android 15 ואילך. האפליקציה שלך מוצגת מאחורי ממשק המשתמש של המערכת. אתם יכולים לשנות את ממשק המשתמש של האפליקציה באמצעות רכיבי insets.
- אפשר גם להתקשר למספר
enableEdgeToEdge()
Activity.onCreate()
, שמאפשר להציג את האפליקציה מקצה לקצה גרסאות Android. הגדרת
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 } } }
קטע הקוד הזה מחיל את רכיבי החלון safeDrawing
בתור מרווח פנימי סביב
את כל התוכן של האפליקציה. כך אפשר להבטיח שרכיבים אינטראקטיביים לא
חופפת לממשק המשתמש של המערכת, והמשמעות היא גם שאף אפליקציה לא תעצור
ממשק המשתמש של המערכת כדי ליצור אפקט מקצה לקצה. כדי לנצל את מלוא המודל
בחלון, צריך לבצע כוונון עדין לגבי המיקום של הרכיבים במסך,
או כל רכיב בנפרד.
כל סוגי הרכיבים האלה מונפשים באופן אוטומטי באמצעות אנימציות IME בוצעה העברה לאחור ל-API 21. על ידי הרחבה, כל הפריסות שמשתמשות בערכות ה-inset האלה גם תתבצע אנימציה אוטומטית כשהערכים הקבועים משתנים.
יש שתי דרכים עיקריות להשתמש בסוגי ההכנסה האלה כדי לשנות את הפריסות של Composable: מודפי ריפוד ומודפי שינוי גודל ההכנסה.
משתני מרווח פנימי
Modifier.windowInsetsPadding(windowInsets: WindowInsets)
מחילה את
החלון מוגדר כמרווח פנימי, שפועל בדיוק כמו Modifier.padding
.
לדוגמה, Modifier.windowInsetsPadding(WindowInsets.safeDrawing)
חל
השרטוט הבטוח משתלב כמרווח הפנימי בכל 4 הצדדים.
יש גם כמה שיטות כלי מובנות לסוגי התצוגה הנפוצים ביותר.
Modifier.safeDrawingPadding()
הוא אחד מהשיטות האלה, והוא שווה ערך ל-Modifier.windowInsetsPadding(WindowInsets.safeDrawing)
. יש מודלים מקבילים
עבור סוגי הקלט האחרים.
משתני גודל של תמונות מוטמעות
המשנים הבאים מחילים כמות של רכיבי inset של החלון על ידי הגדרת הגודל של שהרכיב יהיה בגודל הרכיבים הפנימיים:
המערכת מחילה את צד ההתחלה של רכיבי window Inset כרוחב (למשל |
|
החלת הצד הסופי של windowInsets כרוחב (כמו |
|
המערכת מחילה את הצד העליון של רכיבי window Inset כגובה (למשל |
|
|
המערכת מחילה את הצד התחתון של רכיבי window Inset כגובה (למשל |
המשתנים האלה שימושיים במיוחד לקביעת הגודל של Spacer
שיתפוס את המרחב של התמונות הממוזערות:
LazyColumn( Modifier.imePadding() ) { // Other content item { Spacer( Modifier.windowInsetsBottomHeight( WindowInsets.systemBars ) ) } }
צריכה קבועה
משתני הפאדינג של הרכיבים הפנימיים (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 ) ) } }
כאשר ה-IME נסגר, מקש הצירוף imePadding()
לא מוחל לא מרווח פנימי, מכיוון
ל-IME אין גובה. מכיוון שהצירוף imePadding()
לא מוסיף מרווח פנימי,
לא נעשה שימוש בתוספים, והגובה של ה-Spacer
יהיה בגודל של
הצד התחתון של פסי המערכת.
כשה-IME נפתח, האנימציה של הרכיבים הפנימיים של ה-IME מתאימה את עצמה לגודל של ה-IME, והמַגְדִּיל imePadding()
מתחיל להוסיף ריפוד לתחתית כדי לשנות את הגודל של LazyColumn
בזמן פתיחת ה-IME. לאחר תחילת הצירוף של imePadding()
הריפוד התחתון, הוא גם מתחיל לצרוך את הכמות הזו של תוספות. לכן,
הגובה של Spacer
מתחיל לרדת, כחלק מהמרווח בין ערכי המערכת
העמודות כבר הוחלו על ידי הצירוף imePadding()
. ברגע שהמַעַדן imePadding()
מחיל כמות של ריפוד בחלק התחתון שגדולה מהעמודות של המערכת, הגובה של Spacer
הוא אפס.
כשה-IME נסגר, השינויים מתרחשים בכיוון ההפוך: ה-Spacer
מתחיל להתרחב מגובה אפס ברגע שה-imePadding()
חל על פחות מהצד התחתון של סרחי המערכת, עד שה-Spacer
תואם לגובה של הצד התחתון של סרחי המערכת ברגע שהאנימציה של ה-IME מסתיימת.
ההתנהגות הזו מתקבלת באמצעות תקשורת בין כל האנשים.
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)) }
התנהגות הפונקציה Modifier.consumeWindowInsets(paddingValues: PaddingValues)
דומה מאוד לזו של הגרסה עם הארגומנט WindowInsets
, אבל היא מקבלת לשימוש PaddingValues
שרירותי. הדבר שימושי כדי להודיע לצאצאים מתי הרווח או המילוי מסופקים על ידי מנגנון אחר מלבד המשתנים של המילוי הפנימי, כמו Modifier.padding
רגיל או רווחים בגובה קבוע:
Column(Modifier.padding(16.dp).consumeWindowInsets(PaddingValues(16.dp))) { // content Spacer(Modifier.windowInsetsBottomHeight(WindowInsets.ime)) }
במקרים שבהם צריך את הנתונים הגולמיים של חלון ההכנסה ללא צריכה, משתמשים ישירות בערכי 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") } } }
תמיכה ברכיבי Material 3 בתוך רכיבים אחרים
כדי שיהיה קל להשתמש, רבים מהחומרים הקומפוזביליים המובנים של Material 3
(androidx.compose.material3
)
תטפלו ברכיבים שמוטמעים בעצמם, על סמך האופן שבו התכנים הקומפוזביליים ממוקמים באפליקציה שלכם
בהתאם למפרטי החומר.
רכיבים מורכבים בתוך קטע
בהמשך מופיעה רשימה של רכיבי Material שמטפלים באופן אוטומטי בהוספת שוליים.
סרגי האפליקציות
TopAppBar
/SmallTopAppBar
/CenterAlignedTopAppBar
/MediumTopAppBar
/LargeTopAppBar
: המערכת מפעילה את הצדדים העליונים ואת הצדדים האופקיים של סרגלי המערכת כמרווח פנימי כי נעשה בו שימוש בחלק העליון של החלון.BottomAppBar
: המערכת מחילה את הצדדים התחתונים והאופקיים של סרגלי המערכת כמרווח פנימי.
קונטיינרים של תוכן
ModalDrawerSheet
/DismissibleDrawerSheet
/PermanentDrawerSheet
(תוכן בתוך תפריט ניווט מודלי): הוספת הכנסות אנכיות והתחלה לתוכן.ModalBottomSheet
: החלת החתכים התחתונים.NavigationBar
: החלת ההתקדמות התחתונה והאופקית.NavigationRail
: הפעלת הרכיבים האנכיים וההתחלה.
פיגום
כברירת מחדל,
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]) ) } } }
שינוי של ברירת המחדל של הפריטים שמוצגים בחלק הפנימי של המסך
אפשר לשנות את הפרמטר windowInsets
שמועבר לתוכן הקומפוזבילי ל-
להגדיר את ההתנהגות של התוכן הקומפוזבילי. הפרמטר הזה יכול להיות סוג אחר של חלון להטמעה שיחולו עליו במקום זאת, או מושבת על ידי העברת מופע ריק:
WindowInsets(0, 0, 0, 0)
.
לדוגמה, כדי להשבית את הטיפול בהטמעה ב-LargeTopAppBar
, מגדירים את הפרמטר windowInsets
למכונה ריקה:
LargeTopAppBar( windowInsets = WindowInsets(0, 0, 0, 0), title = { Text("Hi") } )
יכולת פעולה הדדית עם התצוגות המפורטות של מערכת View
יכול להיות שתצטרכו לשנות את הגדרות ברירת המחדל של הפריטים שמוצגים בחלק הפנימי של המסך אם במסך מוצגים גם תצוגות וגם קוד ליצירת תוכן באותה היררכיה. במקרה כזה, צריך לציין בבירור איזה רכיב צריך לצרוך את ה-insets ואילו רכיבים צריכים להתעלם מהם.
לדוגמה, אם הפריסה החיצונית ביותר שלך היא פריסת Android View, עליך
צורכים את הרכיבים הפנימיים במערכת התצוגה ומתעלמים מהם לצורך פיתוח נייטיב.
לחלופין, אם הפריסה החיצונית ביותר שלכם היא קומפוזבילית, צריך לצרוך את
inset ב-Compose (כתיבה), ומרפד את התכנים הקומפוזביליים של AndroidView
בהתאם.
כברירת מחדל, כל ComposeView
צורך את כל ה-insets ברמת הצריכה WindowInsetsCompat
. כדי לשנות את התנהגות ברירת המחדל, צריך להגדיר
ComposeView.consumeWindowInsets
אל false
.
משאבים
- עכשיו ב-Android – אפליקציה ל-Android שיש בה פונקציונליות מלאה שפותחה באופן מלא באמצעות Kotlin ו-Jetpack פיתוח נייטיב.
- טיפול באכיפה מקצה לקצה ב-Android 15 – Codelab עם הנחיות לאכיפה מקצה לקצה ב-Android 15
- 3 דברים שיעזרו לכם לשפר את חוויית השימוש באפליקציות ל-Android: תצוגה מלאה, חזרה חזויה ו'בקצרה' – סרטון ב-YouTube שמדבר על האכיפה של תצוגה מלאה ב-Android 15
- תמונות מקצה לקצה ותמונות עם שוליים | טיפים ליצירת תמונות – סרטון ב-YouTube שמראה איך להשתמש בשוליים כדי לצייר תמונות מקצה לקצה
מומלץ עבורך
- הערה: טקסט הקישור מוצג כש-JavaScript מושבת
- רכיבים ופלטפורמות של Material Design
- העברת
CoordinatorLayout
ל-Compose - שיקולים אחרים