גרסת נובמבר 2026 של Jetpack Compose היא גרסה יציבה. הגרסה הזו כוללת את גרסה 1.13 במודולים העיקריים של Compose (ראו את מיפוי ה-BOM המלא), ומציגה עדכונים לטקסט, לגרפיקה, לפריסות, לביצועים ועוד – לצד כמה הוצאות משימוש ושינויים חשובים בהתנהגות שחשוב לשים לב אליהם.
כדי לעדכן את הפרויקט לגרסה הזו, צריך לשדרג את גרסת ה-BOM של Compose ל-2026.11.01. חשוב לזכור שהשדרוג הזה דורש את Kotlin 2.2 (או גרסה חדשה יותר) ואת compileSdk 37.1.
implementation(platform("androidx.compose:compose-bom:2026.11.01"))
גרפיקה
אנחנו ממשיכים להוסיף ל-Compose הרבה תכונות גרפיות חדשות. בגרסה 1.13 של Compose נוספו צורות של פוליגונים, טשטוש הדרגתי והיכולת להגדיר מאפייני טשטוש ישירות בתיבות דו-שיח ובחלונות קופצים.
טשטוש הדרגתי
בגרסה 1.13 של Jetpack Compose יש טשטוש הדרגתי, שמאפשר להעביר רכיבים מחדות לטשטוש בצורה חלקה. טשטוש הדרגתי מבוסס על פונקציית למבדה של שלב השרטוט באמצעות Modifier.blur { ... } ו-BlurRadiusSpec. אפשר להטמיע מעברי צבע לינאריים (כמו מעברים אנכיים או אופקיים), מעברי צבע רדיאליים לאפקטים של זרקור ממוקד, או אפילו להעביר AGSL RuntimeShaders בהתאמה אישית כדי להפעיל מפות טשטוש דינמיות ופרוצדורליות.
בין אם אתם משלבים את הקצה התחתון של תמונת כותרת ברקע באמצעות BlurredEdgeTreatment.Unbounded, או עוקבים אחרי קואורדינטות מגע באמצעות זרקור רדיאלי, טשטוש הדרגתי מאפשר לכם להטמיע בקלות אפקטים של עומק שדה פרימיום ב-Android.
Modifier.blur { blurRadiusSpec = BlurRadiusSpec.linearGradient( start = DpOffset.Zero, end = DpOffset(size.width, size.height), stops = listOf( BlurStop(fraction = 0f, radius = 0.dp), BlurStop(fraction = 0.5f, radius = 0.dp), BlurStop(fraction = 0.75f, radius = 14.dp), BlurStop(fraction = 1f, radius = 28.dp), ), ) }
צורות מצולעות ושינוי צורה
בגרסה 1.13 של Compose נוספו PolygonShape וגם MorphPolygonShape ל-androidx.compose.foundation:foundation. עד עכשיו, כדי ליצור מצולעים מעוגלים, כוכבים ושינוי צורה ב-Compose, היה צריך להשתמש ישירות ב-androidx.graphics:graphics-shapes – להוסיף את התלות, ליצור RoundedPolygon בגודל הפיקסלים הנכון, להמיר אותו ל-Path ולכתוב Shape משלכם כדי להתאים אותו לגבולות הפריסה.
PolygonShape הוא Shape רגיל של Compose, כך שהוא פועל עם Modifier.clip או עם פרמטר הצורה של כל רכיב, והוא פותר את גודל הפריסה באופן אוטומטי. MorphPolygonShape יוצר אנימציה בין שתי צורות של פוליגונים על ידי קריאת למבדה של התקדמות בזמן השרטוט, ללא קומפוזיציה מחדש. השתמשו ב-graphics-shapes ישירות רק כשאתם מחוץ לממשק המשתמש של Compose או כשאתם צריכים את הגיאומטריה הגולמית של RoundedPolygon. אין צורך להוסיף את graphics-shapes כדי להשתמש ב-PolygonShape, כי foundation כבר תלוי בו.
var recording by remember { mutableStateOf(false) } val progress by animateFloatAsState(if (recording) 1f else 0f) val shape = remember { MorphPolygonShape( start = PolygonShape.circle(), end = PolygonShape.star( numPoints = 9, innerRadiusRatio = 0.8f, outerRounding = CornerRounding.fraction(0.5f), ), progress = { progress }, ) } Box( Modifier .size(96.dp) .clip(shape) .background(MaterialTheme.colorScheme.primary) .clickable { recording = !recording } )
מאפייני טשטוש הרקע והחלון הקופץ
עכשיו אפשר להגדיר את blurBehindRadius, backgroundBlurRadius, scrimAlpha, וגם windowShape (כדי לחתוך את הטשטוש של הרקע בתיבת הדו-שיח לפינות מעוגלות) ישירות ב-DialogProperties (וגם blurBehindRadius/scrimAlpha ב-PopupProperties).
אפשר גם לשלוח שאילתה לגבי מצב הטשטוש של המערכת בין חלונות באמצעות WindowInfo.isCrossWindowBlurEnabled.
שיפורים בביצועי הגרפיקה
שיפורים בשמירה במטמון
ב-Compose 1.13, העיבוד של סמלים סטטיים יעיל יותר. VectorPainter משתף באופן אוטומטי מטמוני ציור שעברו רסטריזציה ומשתמש בהם מחדש בין רכיבי רינדור שמציגים את אותו ImageVector סטטי באותו גודל ובאותה הגדרה, וכך מבטל הקצאות מיותרות של מפות סיביות ורסטריזציה. כדי למקסם את השמירה במטמון, כדאי להשתמש שוב במופעים של ImageVector בקומפוזיציה במקום ליצור אותם מחדש. האופטימיזציה הזו מופעלת כברירת מחדל באמצעות ComposeUiFlags.isVectorDrawCacheSharingEnabled.
שיפורים בגבולות של מקשי הצירופים
ב-Modifier.border יש עכשיו הטמעה מהירה יותר עם ביצועים טובים יותר, תמיכה נוספת בהצללות בזמן ריצה (ShaderBrush עם RuntimeShader) בכל סוגי הצורות, ושימוש עקבי בגודל קווי המתאר בזמן רינדור הגבולות.
כדי לקבל מידע נוסף על כל תכונות הגרפיקה החדשות ב-Compose ובפלטפורמת Android, כדאי לצפות בהרצאה ממפגש של מפתחי Android בשנת 2026:
Material 3 1.5.0
גרסה 1.5.0 של Compose Material 3 היא עכשיו יציבה וכוללת את התכונות הבאות:
-
Sliderו-RangeSliderהועברו למודל עם שמירת מצב באמצעותSliderState. - רכיבים חדשים להבעת רגשות, כולל
ToggleButtons,WavyProgressIndicatorsוגםTimePickers. - ממשקי API, כולל
BottomAppBar,TopAppBar variantsו-BasicAlertDialog, הפכו ליציבים. material3-rippleעם טבעות מיקוד פנימיות.
בגרסה הזו, צמצמנו את ההערות הניסיוניות ב-52% – מ-120 ל-58. בנוסף, כמעט כל הרכיבים החדשים של העיצוב האקספרסיבי עברו לשלב היציב. Material 3 נכנס לשנה השישית שלו, והספרייה Compose Material 2 הוצאה משימוש ולא מתוחזקת יותר באופן פעיל. מומלץ לעבור מ-Material 2 ל-Material 3 כדי לקבל את תיקוני הבאגים העדכניים ביותר ואת שפת העיצוב העדכנית ביותר ל-Android. כדי להוסיף את הרכיבים האקספרסיביים החדשים האלה לאפליקציות שלכם, שדרגו עוד היום את יחסי התלות ל-Material 3 1.5.0. מידע נוסף על כל הרכיבים החדשים, עדכוני הביצועים והשינויים בהתנהגות זמין בפוסט בבלוג.
טקסט
מעבר ל-BasicTextField מבוסס-מצב
הערכים BasicTextField שמבוססים על ערך ו-Material 2 TextField הוצאו משימוש באופן רשמי. השינוי הזה מחייב אתכם לעבור לממשקי ה-API החזקים יותר, BasicTextField ו-TextFieldState, שמבוססים על מצב.
אם אתם משתמשים ב-Material 3, עומסי היתר הקיימים של TextField שמבוססים על ערכים עדיין לא הוצאו משימוש בגרסה 1.5.0, אבל אנחנו ממליצים לעבור לעומסי היתר של TextField ו-OutlinedTextField שמבוססים על מצב כדי לנצל את כל היתרונות של מצב סינכרוני, ביצועים משופרים ותכונות עתידיות. אם אתם עדיין משתמשים ב-Material 2, עברו ישירות לשדות הטקסט מבוססי המצב של Material 3.
כשעוברים אל TextFieldState, שתומך באופן מובנה בשמירה ובשחזור של סגנונות מעוצבים, נהנים מביצועים משופרים ומוכנים לשימוש וממודל מצב סינכרוני ובטוח יותר. בגרסה הזו גם הוסרו הערות ניסיוניות מהיסטוריית הביטול/הביצוע מחדש וממאגרי המעקב אחר שינויים. כלי שירות מדור קודם כמו VisualTransformation הוצאו משימוש בגרסה הזו, ופינו את מקומם לחלופות יעילות כמו OutputTransformation ו-InputTransformation, כולל המסננים המובנים להגבלת האורך.
כדי לקבל מידע נוסף על המעבר לשדות טקסט מבוססי-מצב, כדאי לצפות בהרצאה הזו ממפגש של מפתחי Android בשנת 2026:
גובה שורה לכל שורה
כשמציגים טקסט בכמה שפות או גופנים בגדלים שונים בפסקה אחת, מרווח אחיד בין השורות עלול לגרום לכתבים גבוהים (כמו בורמזית, חמרית או תאית) להתנגש בשורות סמוכות. בגרסה 1.13 של Compose נוסף המאפיין LineHeightStyle.Mode.PerLine, שמחשב את גובה השורה בנפרד לכל שורה. כך שורות עם גליפים גבוהים יותר או טווחים גדולים יותר יכולות להתרחב באופן דינמי כדי להתאים לגבולות הטבעיים שלהן בלי לחתוך או לשבש את שאר הפסקה.
Mergeable FontVariation.Settings
בגרסה 1.13 של Compose נוספו עומסי מיזוג ל-FontVariation.Settings, שמאפשרים להגדיר בקלות הגדרות בסיסיות של גופנים משתנים ולשנות באופן דינמי צירים ספציפיים (כמו עובי, נטייה או רוחב) בלי להקצות מחדש או לבנות מחדש את כל רשימת ההגדרות.
// Define a shared base configuration for your variable font val baseVariation = FontVariation.Settings(FontVariation.weight(400), FontVariation.width(100f)) // Easily override or combine specific axes inline val boldVariation = baseVariation.merge(FontVariation.weight(700)) val condensedVariation = baseVariation.merge(FontVariation.width(85f))
ביצועים
מיומנות ניתוח סטטי של ביצועים
הוספנו מיומנות חדשה של ניתוח סטטי לביצועים של Jetpack Compose. המיומנות הזו מאפשרת לבדוק וליצור קוד בלי הגדרה מראש בשבע קטגוריות עיקריות: מצב ויציבות, פריסות עם טעינה מדורגת, פריסות, גרפיקה, אנימציה, אפקטים ושרשורים, והעברות של Modifier.Node. כך אתם יכולים להריץ בדיקות עצמאיות בכל בקשת Pull, קובץ או מסך כדי לעמוד בשיטות המומלצות הנוכחיות. כדאי לנסות את זה כבר היום דרך Android CLI.
computedStateOf
בגרסה 1.13 הוספנו מנגנון חדש לחישוב מצב, computedStateOf. הוא מספק חלופה קלה ל-derivedStateOf, ומיועד לבדיקות תנאים ולמצב מסונן שמחושב ממצבים אחרים שמשתנים לעיתים קרובות (כמו מיקום הגלילה וספי האנימציה). הפונקציה לא שומרת במטמון את תוצאות החישוב, ולכן היא דורשת פחות משאבים מאשר derivedStateOf – במיוחד כשהחישוב מבוטל בגלל שינוי באחד מהמצבים שאליהם הוא מפנה.
שתי הווריאציות של המצב מבטלות את הקומפוזיציה כשהתוצאה של החישוב משתנה, ולא כשמצבי הקלט שלהן משתנים. בדרך כלל משתמשים בהם כדי להמיר מצבים שמשתנים לעיתים קרובות למצבים שמשתנים לעיתים רחוקות, וכך למנוע ביטולים בהיררכיית הקומפוזיציה בגלל שינויי מצב שלא משפיעים. כדאי לשמור את derivedStateOf לחישובים כבדים או למקרים שבהם נדרש אחסון במטמון. באופן כללי, מומלץ להשתמש ב-computedStateOf במקום ב-derivedStateOf לחישוב מצב.
מעקב אחרי הרכבה מחדש ב-Perfetto
מעקב אחרי רה-קומפוזיציה הוא דרך חדשה להרחיב את המעקב הקיים אחרי קומפוזיציה באמצעות מידע חדש על קריאות מצב וכתיבות מצב, כדי לספק לכם סקירה כללית מלאה על שינויי המצב שגרמו לרה-קומפוזיציות. לכל פעולת קריאה וכתיבה שמשפיעה על הקומפוזיציה, הוא מתעד את ייצוג המחרוזת של המצב ואת דוח הקריסות כדי לאתר את שורת הקוד המדויקת שבה השינוי התרחש.
חשוב לזכור שתיעוד נתונים נוספים למעקב אחרי הרכבה מחדש מוסיף תקורה, לכן חשוב להשבית אותו כשבודקים את הביצועים של האפליקציה.
נקודות השוואה מרכזיות
גרסה 1.13 של Compose תואמת לגרסה 1.12.1 של Compose בכל נקודות ההשוואה הבסיסיות שלנו להפעלה ולגלילה, עם שיעור של 0% של קפיצות בפריימים ב-Pixel 6. בהפעלות מההתחלה (cold startup), גרסה 1.13 של Compose עדיין משיגה זמן מהיר יותר להצגה ראשונית (147.65 אלפיות השנייה) בהשוואה ל-Views (152.87 אלפיות השנייה)
התצוגות נשארות מהירות יותר ב-Time to Full Display (180.32 אלפיות השנייה לעומת 202.79 אלפיות השנייה ב-Compose) בגלל הבדלים בהתחלות של זרימת הנתונים ובעבודה של ה-GPU shader. משך הזמן של גלילת פריים (P50) הוא 3.51 אלפיות השנייה ב-Compose בהשוואה ל-3.06 אלפיות השנייה בתצוגות, והביצועים הכוללים נשארים יציבים ועקביים בהרצות בדיקה תקינות. אנחנו ממשיכים להשקיע מאמצים רבים בשיפור הביצועים בכל המדדים לבדיקת ביצועים, תוך התמקדות במדדי ההפעלה. כדי לראות את התוצאות המלאות, אפשר לעיין במסמכי התיעוד.
כדי לקבל מידע נוסף על ביצועים, כדאי לצפות בהרצאה ממפגש מפתחי Android לשנת 2026:
פריסות
FlexBox ו-Grid יציבים
פריסות FlexBox ו-Grid (שהוכרזו ב-Compose 1.11) עוברות באופן רשמי מגרסה ניסיונית לגרסה יציבה. ממשקי ה-API האלה מוכנים לייצור, והם חלופות יעילות מאוד לרשתות עטופות ולעיצובים רספונסיביים. ב-FlexBox יש גם הגדרה חדשה maxItemsInEachLine שמאפשרת להגביל את מספר הפריטים בשורה כשמופעלת גלישת טקסט.
FlexBox מחליף את פריסות Flow (FlowRow ו-FlowColumn), ואנחנו ממליצים להשתמש ב-FlexBox במקום בפריסות Flow בקוד חדש. להשוואה מפורטת בין מאגרי הפריסה, אפשר לעיין במאמר בנושא מאגרי פריסה.
הוצאה משימוש של ConstraintLayout ו-MotionLayout
עם השקת כלים מודרניים יותר לפריסה ולאנימציה ב-Compose וממשקי API חדשים של Shared Element, אנחנו מוציאים משימוש באופן רשמי את ConstraintLayout ואת MotionLayout ב-Compose (פריט מידע שנוצר בתהליך פיתוח (Artifact) של androidx.constraintlayout:constraintlayout-compose).
החלופות החדשות האלה מספקות פתרונות יעילים, ומציעות גישה יעילה ליצירת ממשקי משתמש מורכבים שמותאמים ל-Compose. מומלץ להעביר את השימושים ב-ConstraintLayout Compose לחלופות שלמעלה.
Stable LazyLayoutCacheWindow
הייצוב של LazyLayoutCacheWindow מביא מטמון חזק ושליפה מראש מבוססת-חלון ישירות לכל משפחות האוספים הראשיות של טעינה מדורגת – רשימות, רשתות ורשתות מדורגות. הפונקציונליות הזו משפרת את הביצועים של פריסות עם טעינה מדורגת בקומפוזיציות מחוץ למסך.
התכונות העיקריות בגרסה הזו:
- הגדרת API פשוטה יותר: הגדרות חלון המטמון הועברו ממחזיק מצב הגלילה (כמו
rememberLazyListState) ישירות לרכיבי ה-composable של הפריסה (LazyColumn, LazyVerticalGrid וכו'), כך שהאחזור מראש והשמירה במטמון קשורים ישירות לפריסה. - אחזור מראש מבוסס-חלון: מחליף את האחזור מראש הקודם מבוסס-הפריט במנוע אחזור מראש מבוסס-חלון שמוגדר כברירת מחדל. המנוע מחשב באופן דינמי חלון קדימה על סמך מדדי אזור התצוגה, עם אפשרות להתאים אישית את החלונות קדימה ואחורה כדי לשמור קומפוזיציות מחוץ למסך.
בפוסט בבלוג מוסבר איך Instagram Direct השתמשה ב-LazyLayoutCacheWindow, ובמסמכי התיעוד מפורט מידע נוסף.
אנימציה
בגרסה 1.13 של Compose, הפונקציה DeferredTransition יציבה ונוספה פונקציה קומפוזבילית חדשה, CapturedAnimatedVisibility.
CapturedAnimatedVisibility
הפונקציה AnimatedVisibility דורשת שהתוכן והמצבים היוצאים יישמרו במהלך אנימציית היציאה, כי היא ממשיכה ליצור את התוכן שלה עד שהאנימציה מסתיימת. כשהתוכן תלוי במצב שכבר לא קיים, יכול להיות ריצוד גלוי. לדוגמה, כשסוגרים חלונית פרטים, הפריט שנבחר מוגדר כ-null, ולכן אין יותר תוכן קיים להצגה. או שמופיע מסך ריק או הבהוב באמצע האנימציה, או שמתרחשת קריסה אם השתמשתם ב-!!, או שאתם צריכים לשמור את הערך הישן בעצמכם.
ב-Compose 1.13 יש CapturedAnimatedVisibility. הפונקציה הקומפוזבילית הזו לא דורשת מהפונקציה הקוראת לנהל ערכים דינמיים במהלך היציאה, כי היא מצלמת תמונת מצב של הפריים האחרון במקום זאת כש-visible הופך ל-false. אתם יכולים לנקות את המצב באופן מיידי, ואנימציית היציאה עדיין תציג את מה שהיה על המסך.
@Composable fun TrackDetails(track: Track?) { // `track` becomes null as soon as the details are closed. CapturedAnimatedVisibility // removes the content right away and animates a snapshot of its last frame instead. CapturedAnimatedVisibility( visible = track != null, enter = fadeIn() + expandVertically(), exit = fadeOut(tween(800)) + shrinkVertically(tween(800)), ) { if (track != null) { TrackCard(track) } } }
שחרור המצב באופן מיידי גם מוזיל את היציאות: בבדיקות שלנו, הביצועים במהלך היציאה מהירים יותר ב-7-8% מבחינת זמן רינדור פריים בהשוואה ל-AnimatedVisibility. המשיכו להשתמש ב-AnimatedVisibility כשהתוכן הקיים צריך להישאר פעיל, או כשצריך להשתמש ב-Modifier.animateEnterExit() בצאצאים שלו. אחרת, עדיף להשתמש ב-CapturedAnimatedVisibility.
טיפול מותאם אישית בכשלים בבדיקות
כדי לנפות באגים בבדיקות ממשק משתמש שנכשלו, במיוחד בסביבות CI, לעיתים קרובות צריך לבדוק את מצב המסך ואת היררכיית הסמנטיקה ברגע המדויק שבו טענת הנכוֹנוּת (assertion) נכשלת. בגרסה 1.13 של Compose יש צינור עיבוד נתונים מובנה לטיפול בכשלים באמצעות TestFailurePolicy ב-ComposeUiTestConfig כדי להפוך את אבחון הבדיקות לאוטומטי.
בעזרת TestFailurePolicy, אתם יכולים:
- תיעוד פריטי מידע מובנים: מגדירים את
screenshotCaptureModeואתuiHierarchyCaptureModeלערךCaptureMode.Enabledכדי ליצור באופן אוטומטי צילום מסך ועץ סמנטיקה של ממשק המשתמש בכל פעם שבדיקה נכשלת. - הפעלה של פונקציות טיפול מותאמות אישית במקרה של כשל: רושמים מופע אחד או יותר של
TestFailureHandlerכדי לעבד אתFailureContext, שמספק את השורשerrorוכלartifactsשנוצר. כך תוכלו להעלות צילומי מסך או להעביר נתוני טלמטריה של כשלים לכלי דיווח חיצוניים. - הגדרת תיעודים בכל חבילת המקרים לבדיקה: אתם יכולים להפעיל תיעודים של צילומי מסך והיררכיית ממשק המשתמש באופן גלובלי ב-
build.gradle.ktsבאמצעותtestInstrumentationRunnerArguments(androidx.compose.ui.test.failure.isScreenshotCaptureEnabledו-androidx.compose.ui.test.failure.isUiHierarchyCaptureEnabled) בלי לשנות קובצי בדיקה ספציפיים, ועדיין לשמור על היכולת לשנות אותם בכל בדיקה.
val customConfig = ComposeUiTestConfig( failurePolicy = TestFailurePolicy( screenshotCaptureMode = TestFailurePolicy.CaptureMode.Enabled, uiHierarchyCaptureMode = TestFailurePolicy.CaptureMode.Enabled, failureHandlers = listOf( TestFailureHandler { context -> val screenshot = context.artifacts.firstOrNull { it.type == FailureArtifact.Type.Screenshot } // Process or upload the artifact and context.error } ) ) ) @Test fun myTest() = runComposeUiTest(config = customConfig) { // Test content }
מיומנות הסתגלותית
השתמשו במיומנות המעודכנת להתאמה כדי לבצע אופטימיזציה של ממשק המשתמש של Compose למכשירים מתקפלים ולמחשבים.
במכשירים מתקפלים, אפשר ליצור חוויות שימוש על משטח ללא מגע ידיים. לשם כך, צריך להציג את התוכן במסך האנכי ולמקם את לחצני השליטה בחצי התחתון השטוח, כדי שהאצבעות לא יסתירו את התצוגה.
הקורס גם יעזור לכם ליצור באפליקציה תחושה של אפליקציה מקומית במחשב, באמצעות מקשי קיצור, הסברים קצרים וסמני עכבר בהתאמה אישית, וגם דפוסים מוכחים למניעת אובדן מצב כשהמשתמשים מסובבים או פותחים את המכשירים שלהם. כדאי לנסות את זה כבר היום דרך Android CLI.
כדאי לצפות בהרצאה הזו ממפגש של מפתחי Android כדי לראות איך אפשר לשפר את התמיכה במכשירים מתקפלים ובמחשבים:
חישוב מדויק של מהירות הגלילה בתצוגות גלילה מקוננות
באפליקציות עם ארכיטקטורות של ממשק משתמש היברידי, פתרנו בעיה שבה גלילה מהירה ב-Compose שמוטמע בתוך קונטיינרים של גלילה ב-Android View (כמו ScrollView, NestedScrollView או CoordinatorLayout) חישבה לפעמים מהירות שגויה. העברת המהירות מחושבת עכשיו בצורה מדויקת, מה שמונע עצירות פתאומיות או קפיצות בגלילה ומבטיח חוויית גלילה חלקה וזורמת בין View ל-Compose.
שינוי בהתנהגות:
התכונה Modifier.onFocusedBoundsChanged הוצאה משימוש
Modifier.onFocusedBoundsChanged הוצא משימוש ב-Compose 1.12, ובגרסה 1.13 ההטמעה שלו הוסרה, כלומר אין לו השפעה אם מפעילים את ה-modifier. ההטמעה הישנה לא דיווחה על גבולות המיקוד באופן מהימן במצבים רבים, והיו בה בעיות בביצועים.
קונטיינרים מובנים לגלילה כמו LazyColumn ו-Modifier.verticalScroll כבר מציגים תוכן ממוקד בלי ה-API הזה, ולכן הם לא מושפעים.
כדי לקבל את הגבולות של הרכיב הממוקד, קוראים ל- FocusTargetModifierNode.getFocusedRect() מ-Modifier.Node בהתאמה אישית. הוא מחזיר את הגבולות כשמבקשים אותם, במקום לדווח על כל שינוי באמצעות קריאה חוזרת (callback). כדי להגיב לשינויים במיקוד, משתמשים ב- Modifier.onFocusChanged. כדי לגלול פריט ממוקד לתצוגה בקונטיינר מותאם אישית, צריך להתאים את onFocusChanged עם BringIntoViewRequester.
שינוי בהתנהגות: אפקטים קוליים של אינטראקציה עם הפלטפורמה ב-Android
רכיבים שאפשר ללחוץ עליהם ומוגדרים באמצעות Modifier.clickable (או רכיבים שמבוססים עליו) מפעילים עכשיו באופן אוטומטי אפקטים קוליים רגילים של אינטראקציה ב-Android, בהתאם להגדרות הצלילים של המשתמש במערכת. בעבר, כדי להפעיל אפקטים קוליים ברכיבים של Compose שניתן ללחוץ עליהם, היה צריך להפעיל אותם באופן ידני כדי להשיג שוויון עם תצוגות Android רגילות. העדכון הזה מבטיח שרכיבים אינטראקטיביים יספקו משוב קולי מיידי וירגישו כמו חלק מפלטפורמת Android כבר מההתחלה.
עדכון לגבי סגנונות
ב-Google I/O הצגנו דרך חדשה להתאים אישית רכיבים בלי לפצל את קוד המקור. ב-Compose 1.13, הארכיטקטורה הבסיסית הזו התפתחה למנוע עיצוב לא דעתני. במקום שהמסגרת תגדיר מאפיינים חזותיים באופן קשיח, הגדרות המאפיינים הועברו לשכבת מערכת העיצוב, וכך הצוותים יכולים להצהיר על אסימוני מותג מותאמים אישית (stylePropertyOf / styleLocalOf) באופן אוטונומי לחלוטין.
בגלל השינוי הזה בארכיטקטורה, Styles API נשאר ניסיוני ב-Compose 1.13. אנחנו פועלים באופן פעיל עם שותפים ועם Material 3 כדי לשפר את מיזוג הסגנונות ואת ארגונומיית המפתחים לפני הזמינות לכלל המשתמשים (GA). במהלך המעבר, הסרנו את התיעוד ואת המיומנות של Styles.
ספריית Compose Web חדשה למעבר קל יותר ל-WebView (אלפא)
הטמעת תוכן מהאינטרנט ב-Compose היא אחת מנקודות החיכוך האחרונות בהעברת אפליקציות. הטמעות קודמות באמצעות AndroidView עלולות לגרום לגמגום בגלילה, לאובדן מצב במהלך שינויים בהגדרות או בניווט, ולתקורה של עיבוד יכולת פעולה הדדית.
כדי לפתור את הבעיה הזו, אנחנו משיקים שתי ספריות שמבוססות על שני פרימיטיבים משלימים ב-androidx.web:
-
WebContent(זמין עכשיו ב-androidx.web:web:1.0.0-alpha01): מאחסן מצב שמפריד בין מצב האינטרנט (כולל מיקום הגלילה, קלט של טפסים, היסטוריית הניווט ומצב JavaScript) לבין היררכיית התצוגות, כך שהוא נשמר גם אחרי שינויים בהגדרות ובניווט בלי לדלוף ל-Activity.
@Composable // Assumes `webContent` is already created and retained (e.g., in a ViewModel or via `retain`) fun WebContentPage(webContent: WebContent, startUrl: String, modifier: Modifier = Modifier) { key(webContent) { AndroidView( factory = { context -> webContent.attach(context, ::WebContentView).apply { settings.javaScriptEnabled = true if (url == null) loadUrl(startUrl) } }, modifier = modifier, onRelease = { view -> // The view must leave the hierarchy before WebContent is detached. (view.parent as? ViewGroup)?.removeView(view) webContent.detach() }, ) } }
-
WebSurface(בקרוב): רכיב קומפוזבילי ייעודי שעבר אופטימיזציה ל-WebContentועוקף את התקורה של יכולת הפעולה ההדדית שלAndroidView.
כדי לנסות את ממשקי ה-API כבר היום, אתם יכולים לייבא את androidx.web:web:1.0.0-alpha01. כדאי גם להמשיך להתעדכן לגבי גרסת האלפא של WebSurface שתצא בקרוב.
כלי חדש לעיבוד הממשק של A2UI ב-Jetpack Compose
התשובות של מודל השפה הגדול (LLM) בזמן הריצה לא צריכות להיות מוגבלות לטקסט פשוט. מנוע העיבוד החדש של Jetpack Compose A2UI מטמיע את פרוטוקול Agent-to-UI (A2UI) הפתוח.
implementation("androidx.compose.material3:material3-a2ui:1.0.0-alpha02")
סוכני AI יכולים ליצור ממשקי משתמש עשירים ואינטראקטיביים בזמן הריצה, שמוצגים כרכיבי Compose מקוריים בלי להריץ קוד שרירותי. ה-renderer מנתח את ההודעות ומאמת את הסכימה, ומזין את נתוני הנציג למצב של תמונת המצב של Compose. אתם יכולים להשתמש בקטלוג Basic המוכן, או לחבר רכיבים קומפוזביליים ומערכת עיצוב משלכם. כדי להתחיל, אפשר לעיין במסמכי התיעוד או לצפות בהרצאה מ-Android DevSummit.
עדכוני מסמכים
יש לנו מאמרי עזרה חדשים בנושאים Anchored draggable, Navigation3 Deep Links ו-AppState.
בהצלחה!
גרסה 1.13 של Compose הופכת את פיתוח האפליקציות לקל וליצירתי יותר מאי פעם, עם עדכונים לטקסט, לגרפיקה, לפריסות, לביצועים ועוד. כדי לראות את כל השינויים בין גרסאות ה-BOM, אפשר להשתמש בכלי להשוואת BOM.
כדי ללמוד עוד על החידושים ב-Compose, כדאי לצפות בהרצאות האחרונות ממפגש של מפתחי Android.
כמו תמיד, אנחנו מעריכים את המשוב שלכם. אתם מוזמנים לשתף את המשוב שלכם על השינויים האלה או על מה שתרצו לראות בהמשך ב-Issue Tracker שלנו. בהצלחה!
-
חדשות על המוצרהיום, קטגוריית המשחקים ל-Android Auto ולמכוניות עם Android Automotive OS ושירותי Google מובנים עוברת באופן רשמי מגרסת בטא לזמינות לכלל המשתמשים (GA).
Jan Kleinert • משך הקריאה: 3 דקות -
חדשות על המוצראנחנו שמחים לראות שמפתחים ממשיכים להביא את האפליקציות והחוויות שלהם ל-Android לרכבים. בשנה האחרונה, המשכנו לראות צמיחה חזקה ותנופה בסביבת האפליקציות ב-Android Auto וברכבים עם שירותי Google מובנים.
Jan Kleinert, Noam Gefen, Thomas Weathers • משך הקריאה: 3 דקות -
חדשות על המוצרבמהלך כמעט 5 השנים שחלפו מאז שהשקנו את Jetpack Compose, השקענו מאמצים כדי לספק לכם את כל התכונות, הביצועים והכלים שאתם צריכים כדי ליצור ממשקי משתמש מדהימים במגוון מכשירי Android.
Nick Butcher • משך הקריאה: 2 דקות
רוצים לקבל טיפים עדכניים לפיתוח Android ישירות לאימייל כל שבוע?