הפעלת פלטפורמות אינטראקטיביות באמצעות Remote Compose

שלום לכולם,

אני ניקולס רוארד, המוביל הטכני של הפרויקט Remote Compose.

אני ג'ון הופורד.

אני מפתח ב-Remote Compose.

ואני ג'ון זולר, ואני עובד בקשרי מפתחים ב-Wear OS.

אוקיי, בואו נתחיל.

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

אז בדרך כלל כשמדברים או כשחושבים על ממשק המשתמש ב-Android, חושבים על ממשק המשתמש כחלק מהאפליקציה ומתהליך האפליקציה, נכון?

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

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

כל אלה הן דוגמאות לפלטפורמות חיצוניות.

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

וגם…

מה לגבי הרמקול שלי?

יש מרחק בין שתי האפשרויות האלה.

והמרחק הזה יכול להיות מרחק פיזי, או חיבור לרשת, נכון?

יכול להיות גם רק גבול של תהליך.

אתם יכולים להיות באותו מכשיר.

אבל לא משנה מה זה, יש לזה מחיר.

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

הבעיה היא שזה לא ממש מהיר, נכון?

אז מה שאנחנו עושים עם Remote Compose במקום זאת, זה לשלוח מסמך שמייצג את ממשק המשתמש הזה.

חשוב לזכור שלעסק קטן יש הרבה יתרונות.

זה חשוב.

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

הזמנתם טיסה הלוך ושוב.

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

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

וזה לא טוב.

אז במובנים רבים, זה מה שאנחנו מנסים לפתור באמצעות Remote Compose.

אז ראינו שהמסמך נשלח.

חוץ מהמסמך, יש עוד כמה תחומים חשובים מאוד.

הראשון הוא איך יוצרים את המסמך.

והשני הוא איך משחקים בו.

ציינתי שאנחנו יוצרים מסמך.

אנחנו לא שולחים צילום מסך, וגם לא שולחים אפליקציה.

יש שלוש דרכים שונות ליצור את המסמך הזה.

הראשון הוא Compose API, השני הוא Kotlin API פרוצדורלי, KMP, והשלישי הוא פורמט JSON.

כולם פולטים את אותם בייטים.

לכן אנחנו מספקים קבוצה של כלים ליצירת המסמכים האלה, ובעזרת Compose API אנחנו יכולים לנצל את הכלים הקיימים ב-Android Studio.

לדוגמה, אתם יכולים להשתמש בתצוגה המקדימה כדי לראות בזמן אמת את מה שאתם מפתחים, ישירות ב-IDE.

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

בואו נסתכל רגע על המסמך עצמו.

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

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

מבחינתנו, קטן זה טוב.

אז בדרך כלל מדובר בכמה קילובייטים, נכון?

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

אנחנו אורזים את כל הנכסים במסמך הזה.

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

חשוב לזכור את זה.

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

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

זהו מקרה קצה מרכזי של הפילוסופיה שמאחורי Remote Compose.

כמו שראינו, ברור שיש לזה השפעה על הזמן שלוקח לפיקסל הראשון להופיע על המסך, אבל אופס, סליחה.

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

אנחנו נראה איך אנחנו מנצלים את זה כשאנחנו תומכים בווידג'טים.

גם הנגנים עצמם נוטים להיות קטנים, עם מעט מאוד תלויות.

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

וזה חשוב במיוחד לפלטפורמות מוגבלות, כפי שתראו.

אז דיברתי הרבה על ההעברה והמרחק, אבל Remote Compose עצמו לא ממש עוסק בהעברה.

זה תלוי בכם.

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

אנחנו מספקים מחבר לווידג'טים.

אבל באופן כללי, כדאי לזכור שאתם אחראים על ההובלה.

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

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

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

וזה בעצם כל הרעיון.

אנחנו רוצים שהמסמך ייצור ממשק משתמש שהוא קצת אוטונומי, שלא צריך לחזור למי שיצר אותו, נכון?

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

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

אנחנו מספקים שלושה נגנים רשמיים, בעיקר דרך ספריות AndroidX ב-Remote Compose.

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

יש לנו גם נגן View, אם אתם עדיין משתמשים ב-View.

יש לנו גם הטמעה של RemoteViews שזמינה בפלטפורמת Android החל מ-API 36, ומאפשרת ליצור ווידג'טים ל-Android שפועלים במרכז האפליקציות באמצעות Remote Compose.

יש לנו גם כמה נגנים ניסיוניים אם אתם מעוניינים, חלקם ב-C++‎ שפועלים ב-Skia, ב-TypeScript ואפילו ב-Compose Multiplatform.

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

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

כן.‏

אז בואו נדבר קצת על היכולות שתקבלו במסמך Remote Compose.

אז בבסיס יש Canvas, והוא כולל את כל התכונות של Android Canvas.

אבל עם כמה ממשקי API נוספים.

אבל אחד הדברים המיוחדים הוא שאפשר להחליף את כל הערכים מסוג float ב-Android Canvas בביטויים.

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

אפשר לעשות איתו הרבה דברים שונים.

קצת יותר על ביטויים.

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

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

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

בנוסף, יש לנו את הרכיבים הבסיסיים, דברים של Compose, דברים שאתם מכירים.

הוא מייצר API מוכר מאוד, תיבה, שורה, עמודה, דברים כאלה.

אבל בנוסף, יש לנו רכיבים דינמיים.

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

בנוסף, יש לנו אנימציה של רכיבים.

אפשר להוסיף אנימציה לכל השינויים, כך שאם משהו נעלם, אפשר להוסיף לו אנימציה.

אתם יכולים גם לכתוב אנימציות בהתאמה אישית.

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

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

אפשר ללחוץ על דברים, להשתמש באירועי מגע, לגלול וכו'.

גם הנגישות חשובה, ולכן כל ממשקי ה-API להטמעת תכונות נגישות נמצאים שם.

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

הכול נמצא במסמך.

כל מה שאתם רואים, בלי לחזור לשרת.

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

אתם יכולים ליצור אינטראקציה בין שתי האפליקציות.

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

אז אני יכולה ללכת לשני הכיוונים.

בואו נראה איך יוצרים מסמך כזה.

למעשה, יש שלושה ממשקי API: ‏Compose, ‏Kotlin ו-JSON.

אתם כבר מכירים את Compose API.

יש כמה דברים שצריך לשים לב אליהם, ונעבור עליהם בפירוט.

ה-API של Kotlin הוא פרוצדורלי מאוד.

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

ה-JSON הוא תחביר JSON שאפשר להמיר ל-Remote Compose באמצעות הממירים שלנו.

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

אז בואו ניכנס ל-Compose ונבנה משהו.

במקרה כזה, תראו שזה רכיב קומפוזבילי ורכיב קומפוזבילי מרוחק.

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

עכשיו, כל הפקודות שבתוכו יוצרות בפועל פקודות של מסמך Remote Compose של פקודה מרחוק בזמן שהן עוברות.

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

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

אתם רואים את הביטויים האלה שם.

בואו נדבר קצת על מה זה ואיך זה עובד.

בצד ימין, תראו משהו שנראה כמו גיליון אלקטרוני.

זו טבלה של הערכים בנקודה צפה (float).

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

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

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

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

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

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

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

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

אתם יודעים, הוא באמת מראה את השעה.

עוד דבר מעניין הוא שאפשר לכתוב את אותו הדבר ב-JSON, ואם זה היה ב-JSON, אפשר היה לתקשר בקלות עם מודל שפה גדול (LLM) ולומר, "שנה את מחוג הדקות לירוק", והוא היה מבין למה הכוונה.

זה ממש נחמד.

אוקיי.

בסדר.

אני מקווה שזה נותן לכם מושג על היכולות של Remote Compose.

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

אז ציינתי שאלו בעיקר ספריות AndroidX, אז כל מה שנמצא ב-DAC, אתם יודעים איפה למצוא אותו.

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

כמו תמיד, ג'ון הדגים מה אפשר לעשות ב-Android Studio.

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

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

אנחנו לא מנסים להסתיר את זה, זה גלוי.

אתם יכולים לראות איך הוא עובד, איך הוא בנוי ואיך הוא מקודד.

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

ואל תשכחו את מה שאמרתי על מפות סיביות.

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

לכן אנחנו מפתחים כמה כלים שיעזרו לכם לקחת קובץ Lottie, למשל, או אולי פורמט אחר, ולהמיר אותו לרכיב RemoteCompose שתוכלו להשתמש בו בקובץ RemoteCompose.

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

במקרה שלנו, זה מסמך.

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

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

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

אבל יש לנו כלים נוספים.

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

אחד הדברים האחרונים שאנחנו עובדים עליהם הוא גם Layout Inspector מקיף, כלומר, סוג של יכולות בדיקת פריסה שאתם רגילים אליהן ב-Android Studio, אבל כאן, הן מיושמות על הפעולות ועל המסמכים, נכון?

ואנחנו יכולים להרחיב עוד יותר את השימוש בתלת-ממד.

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

זה חשוב.

אנחנו רוצים מסמכים קטנים.

זה עוזר לכולם.

עליך לעשות זאת.

אז מה אפשר לעשות?

ניקח דוגמה נפוצה של ממשק משתמש, בסדר?

משהו שיש בו הרבה שורות.

השורות עצמן, אתם יודעים, יש שם, גרף קטן ואולי כפתור.

די אופייני.

ממשק המשתמש הזה כבר די קטן.

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

בואו נעבור עליהם.

הדבר הראשון שאנחנו עושים, וזה בחינם, אנחנו נעשה את זה בשבילכם, אם אתם שולחים את אותן מחרוזות, אנחנו נבחין בזה.

אנחנו יכולים לחסוך כמה בייטים אם נצביע על אותה מחרוזת.

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

אז כאן השתמשתי בפעולת הלולאה הזו כדי לצייר את הגרף הקטן שלי, נכון?

וזה חוסך עוד כמה בייטים.

יש לנו גם פונקציות.

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

ושוב, זה יחסוך לי כמה בייטים.

ולרכיב יש לנו תבניות, נכון?

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

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

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

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

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

אנחנו לא דוחסים אותו.

זה מאוד שימושי אם רוצים לעבור במהירות על הרבה מסמכים בלי לחלץ אותם.

אז בשורה התחתונה, המסמכים קטנים, אתם יודעים, out-of-the-box, אבל אתם יכולים גם להקטין אותם עוד יותר.

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

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

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

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

אבל אנחנו יכולים לעשות יותר, נכון?

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

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

בעצם, אנחנו נותנים לכם הרבה יותר גמישות ויכולות.

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

כך תוכלו לראות משחק מלא בווידג'ט.

הייתי מצביע על הגודל האמיתי של הווידג'ט הזה.

אנחנו מדברים על 4KB.

ציינתי שהעברה היא לא משהו שאנחנו מטפלים בו ישירות ב-Remote Compose.

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

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

ועכשיו, בואו נדבר על Wear OS.

תודה, ניקו.

מה קורה, חברים?

אני ג'ון זולר.

אני כאן כדי לדבר איתך על Wear OS.

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

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

אז בואו נדבר על Remote Compose ועל כמה מהיתרונות הגדולים שלו ב-Wear OS.

קודם כול, נדבר על מעקב האימונים החדש ב-Wear OS.

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

זה לוקח קצת זמן.

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

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

בלי Remote Compose, אם היינו עושים את זה רק עם Compose רגיל, לא היינו יכולים לרענן את המדדים בזמן אמת במסך בכל שנייה.

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

זה יתרון משמעותי.

למעשה, תאמינו או לא, זה קובץ GIF.

זו לא תמונה.

אני יודע שהיא עדיין לא זזה, והיא תזוז בעוד כ-45 שניות כשנגיע לעדכון המדדים הבא.

אבל זה היתרון של Remote Compose.

ונחשו מה?

היא זמינה, Wear Workout Tracker.

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

הבא בתור: ווידג'טים של Wear OS.

זו עוד דוגמה נהדרת שממחישה מהו Remote Compose.

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

אתם יכולים לעשות את כל זה באמצעות "כתיבה מרחוק".

מכיוון שהם חלק מ-Jetpack Glance, הווידג'טים ב-Wear OS הם חלק מהסביבה העסקית המאוחדת של הווידג'טים ב-Android.

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

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

ב-Wear OS 7, יצרני החומרה כבר משתמשים במגשים עם גלילה אנכית.

זה Samsung Galaxy Watch, ואפשר לראות איך הווידג'טים נגללים אנכית במגשים כאן.

בקישור הזה אפשר לקרוא מידע נוסף על העברת המשבצת לווידג'ט.

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

בנוסף, הם תואמים באופן מלא לדורות קודמים של Wear OS 4.

בקישור הזה אפשר לקרוא מידע נוסף על תאימות לדורות קודמים.

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

אתם יכולים לראות את זה.

זה הכול ממני.

כן, חזרה אליך, ניקו.

תודה.

טוב.

זה מסכם את השיחה שלנו.

סקרנו כמה מהיכולות של Remote Compose.

יש עוד כמה שלא דיברנו עליהם.

זו מסגרת עשירה מאוד.

מומלץ לעיין במסמכים הזמינים ובמסמכים שיתפרסמו בקרוב.

הייתי אומר שהמטרה שלנו היא באמת לבנות עתיד שבו תוכלו להשתמש ב-Remote Compose כדי לטפל בכל המשטחים המרוחקים השונים האלה.

וראיתם חלק מהם, נכון, כמו ה-Wear, הווידג'טים.

אבל יש עוד הרבה דברים בדרך.

הייתי אומר גם שזה פרויקט מתמשך.

היא נמצאת בשלבי פיתוח.

אנחנו מפתחים את כל זה באופן גלוי.

אתם יכולים לראות מה אנחנו עושים.

אבל הייתי אומר שאנחנו באמת רוצים לשמוע מהמפתחים, נכון?

אנחנו מפתחים את זה בשבילכם.

אז אם יש לכם רעיונות נוספים או דברים שחסרים לכם, דברו איתנו.

נשמח לשמוע ממך.

אני רוצה לסיים עם זה: כל המצגת שראיתם עכשיו, כמובן, נעשתה ב-Remote Compose, כולל האנימציות.