ממשקי API של Android 3.0

רמת API: 11

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

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

סקירה כללית על API

הקטעים הבאים מספקים סקירה טכנית של התכונות החדשות שזמינות למפתחים ב-Android 3.0, כולל תכונות חדשות ושינויים ב-framework API מאז הגרסה הקודמת.

מקטעים

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

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

בנוסף:

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

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

כדי לבצע עסקה, כמו הוספה או הסרה של מקטע, צריך ליצור FragmentTransaction. לאחר מכן תוכלו להפעיל שיטות כמו add() remove() או replace(). לאחר החלת כל את השינויים שברצונך לבצע עבור העסקה, עליך לקרוא ל-commit() והמערכת מחילה את טרנזקציית המקטעים על הפעילות.

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

סרגל פעולות

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

  • להוסיף אפשרויות בתפריט ישירות בסרגל הפעולות, בתור "פעולות לביצוע".

    בהצהרת ה-XML של האפשרות בתפריט, צריך לכלול את המאפיין android:showAsAction עם הערך "ifRoom". כשיש מספיק מקום, התפריט הפריט מופיע ישירות בסרגל הפעולות. אחרת, הפריט ימוקם אפשרויות נוספות, שנחשף באמצעות סמל התפריט בצד שמאל של סרגל הפעולות.

  • החלפה של פריט פעולה בווידג'ט (כמו תיבת חיפוש) — יצירת 'תצוגת פעולה'.

    בהצהרת ה-XML של האפשרות בתפריט, צריך להוסיף את המאפיין android:actionViewLayout עם משאב פריסה או המאפיין android:actionViewClass עם שם המחלקה לווידג'ט הזה. (צריך גם להצהיר על המאפיין android:showAsAction כדי שהפריט יופיע בסרגל הפעולות.) אם אין מספיק מקום בסרגל הפעולות והפריט מופיע האפשרות 'אפשרויות נוספות' מתנהגת כמו אפשרות בתפריט רגיל ולא מציגה את הווידג'ט.

  • הוספת פעולה ללוגו של האפליקציה והחלפתה בלוגו מותאם אישית

    ללוגו של האפליקציה מוקצה באופן אוטומטי המזהה android.R.id.home, שהמערכת שולחת את הקריאה החוזרת (callback) של הפעילות שלך ב-onOptionsItemSelected() כשנוגעים בה. פשוט צריך להשיב למזהה הזה בקריאה החוזרת כדי לבצע פעולה, כמו מעבר לדף הבית של האפליקציה פעילות.

    כדי להחליף את הסמל בלוגו, יש לציין את הלוגו של האפליקציה בקובץ המניפסט עם android:logo ואז קריאה ל-setDisplayUseLogoEnabled(true) בפעילות שלך.

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

סרגל הפעולות משמש כתקן לכל האפליקציות שמשתמשות בעיצוב ההולוגרפי החדש, משמש גם להגדרת ברירת המחדל כשמגדירים את android:minSdkVersion או את android:targetSdkVersion לערך "11".

מידע נוסף על סרגל הפעולות זמין במסמכי התיעוד של סרגל הפעולות. כמה הדוגמאות זמינות גם ב יישום 'הדגמות של API'.

לוח העריכה של המערכת

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

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

כדי להתחיל להשתמש בלוח, צריך להשיג את האובייקט הגלובלי ClipboardManager באמצעות הטלפון getSystemService(CLIPBOARD_SERVICE).

כדי להעתיק פריט ללוח, צריך ליצור אובייקט ClipData חדש, שכולל לפחות פריט אחד (ClipData.Item) אובייקטים, שכל אחד מהם מתאר ישות אחת. כדי ליצור אובייקט ClipData שמכיל רק ClipData.Item אחד, תוכלו להשתמש באחת מהשיטות המסייעות, כמו newPlainText(), newUri() ו-newIntent(), שכל אחד מהם מחזיר אובייקט ClipData שנטען מראש עם ClipData.Item שמספקים.

כדי להוסיף את ClipData ללוח, צריך להעביר אותו אל setPrimaryClip() בשביל המופע של ClipboardManager.

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

הלוח מכיל רק פיסת נתונים אחת שנחתכה (ClipData) ) בכל פעם, אבל ClipData אחד יכול להכיל מספר ערכים של ClipData.Item.

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

גרירה ושחרור

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

לפעולת גרירה ושחרור יש מחזור חיים המוגדר על ידי מספר פעולות גרירה - כל אחת מוגדר על ידי אובייקט DragEvent, כמו ACTION_DRAG_STARTED, ACTION_DRAG_ENTERED, ACTION_DROP כל תצוגה שרוצה להשתתף בגרירה יכולה להאזין לפעולות האלה.

כדי להתחיל לגרור תוכן בפעילות שלך, צריך להתקשר למספר startDrag() ב-View, מספק אובייקט ClipData שמייצג את הנתונים שיש לגרור, View.DragShadowBuilder להצגת ה"צל" שמשתמשים רואים מתחת לאצבעות שלהם בזמן הגרירה, וObject שיכול לשתף מידע על אובייקט הגרירה עם תצוגות שעשויות לקבל את האובייקט.

כדי לקבל אובייקט גרירה ב-View (קבלת ה'שחרור'), צריך לרשום את התצוגה עם OnDragListener באמצעות חיוג אל setOnDragListener(). כשמתרחש אירוע גרירה בתצוגה, המערכת קוראת ל-onDrag() עבור ה-OnDragListener, שמקבל DragEvent שמתאר את סוג פעולת הגרירה שאירעה (למשל ACTION_DRAG_STARTED, ACTION_DRAG_ENTERED ו- ACTION_DROP). במהלך גרירה, המערכת קוראת שוב ושוב ל-onDrag() לתצוגה שמתחת לגרירה, כדי להעביר זרם של אירועי גרירה. התצוגה המקבלת יכולה לברר לגבי סוג האירוע שהועבר אל onDragEvent() על ידי התקשרות אל getAction() ב-DragEvent.

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

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

אפליקציות ווידג'ט

מערכת Android 3.0 תומכת בכמה מחלקות חדשות של ווידג'טים כדי ליצור ווידג'טים אינטראקטיביים יותר של אפליקציות למשתמשים מסך הבית, כולל: GridView, ListView, StackView, ViewFlipper ו-AdapterViewFlipper.

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

המחלקה AppWidgetProviderInfo (שמוגדרת ב-XML עם רכיב <appwidget-provider>) תומכת גם בשני שדות חדשים: autoAdvanceViewId ו-previewImage. השדה autoAdvanceViewId מאפשר לציין את מזהה התצוגה של התצוגה המשנית של הווידג'ט של האפליקציה שהמארח של הווידג'ט של האפליקציה צריך להתקדם בה באופן אוטומטי. השדה previewImage מציין תצוגה מקדימה של הווידג'ט של האפליקציה נראה כמו ומוצג למשתמש בכלי לבחירת ווידג'טים. אם לא מזינים את השדה הזה זמין, סמל הווידג'ט של האפליקציה ישמש לתצוגה המקדימה.

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

אתם יכולים לראות איך להטמיע את התכונות החדשות של הווידג'ט לאפליקציה ב-StackView App Widget ובווידג'ט Weather List תרגום מכונה.

התראות בשורת הסטטוס

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

התכונות החדשות כוללות:

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

טעינת תוכן

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

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

מידע נוסף זמין במסמכי התיעוד של Loaders. אפשר גם לראות קוד לדוגמה באמצעות מטענים ב-LoaderCursor ו- דוגמאות של LoaderThrottle.

ממשקי API של Bluetooth A2DP ואוזניות

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

אפשר לאתחל את BluetoothProfile המתאים על ידי קריאה ל-getProfileProxy() באמצעות A2DP או HEADSET קבוע של הפרופיל ו-BluetoothProfile.ServiceListener לקבל קריאה חוזרת (callback) כשלקוח ה-Bluetooth מחובר או מנותק.

מסגרת אנימציה

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

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

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

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

בנוסף, המחלקה LayoutTransition מאפשרת מעבר אוטומטי אנימציות לשינויים שביצעתם בפריסת הפעילות. כדי להפעיל מעברים עבור חלק פריסה, יוצרים אובייקט LayoutTransition ומגדירים אותו כל ViewGroup באמצעות setLayoutTransition(). הדבר גורם לברירת המחדל אנימציות שירוצו בכל פעם שפריטים נוספים לקבוצה או מוסרים ממנה. כדי לציין התאמה אישית אנימציות, קוראים ל-setAnimator() ב-LayoutTransition ומספקים Animator בהתאמה אישית, כמו ValueAnimator או ObjectAnimator שהסברנו למעלה.

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

מסגרת מורחבת של ממשק המשתמש

  • בחירה של שאלות אמריקאיות ל-ListView ול-GridView

    מצב CHOICE_MODE_MULTIPLE_MODAL חדש עבור setChoiceMode() מאפשר למשתמשים לבחור מספר פריטים מ-ListView או GridView. בשימוש ב: ביחד עם סרגל הפעולות, המשתמשים יכולים לבחור פריטים מרובים ולאחר מכן לבחור בפעולה לבצע מתוך רשימת אפשרויות בסרגל הפעולות (שהפך למודל של שאלות אמריקאיות מצב פעולה).

    כדי להפעיל בחירה של שאלות אמריקאיות, צריך להתקשר למספר setChoiceMode(CHOICE_MODE_MULTIPLE_MODAL) ולרשום MultiChoiceModeListener עם setMultiChoiceModeListener().

    כשהמשתמש לוחץ לחיצה ארוכה על פריט, סרגל הפעולות עובר לאפשרות 'שאלה מרובה' מצב פעולה. המערכת שולחת הודעה ל-MultiChoiceModeListener כשהפריטים נבחרים, בהתקשרות אל onItemCheckedStateChanged().

    לדוגמה של בחירה מסוג שאלות אמריקאיות, ראו List15. Java באפליקציה לדוגמה של הדגמות API.

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

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

    שיטות חדשות להגדרת מאפיינים של תצוגה מפורטת כוללות: setAlpha(), setBottom(), setLeft(), setRight(), setBottom(), setPivotX(), setPivotY(), setRotationX(), setRotationY(), setScaleX(), setScaleY(), setAlpha() ועוד.

    לחלק מהשיטות יש גם מאפיין XML תואם שאפשר לציין בפריסה כדי להחיל טרנספורמציה המוגדרת כברירת מחדל. המאפיינים הזמינים הם: translationX, translationY, rotation, rotationX, rotationY, scaleX, scaleY, transformPivotX, transformPivotY ו-alpha.

    שימוש בחלק ממאפייני התצוגה המפורטת החדשים בשילוב עם מסגרת האנימציה החדשה ( שלמעלה), ניתן להחיל בקלות כמה אנימציות מיוחדות על התצוגות. לדוגמה, כדי לסובב על ציר ה-y שלו, מספקים את ObjectAnimator עם ה-View, את ה-"rotationY" ואת ערכי ההתחלה והסיום:

    Kotlin

    ObjectAnimator.ofFloat(myView, "rotationY", 0f, 360f).apply {
    duration = 2000
    start()
}

    Java

    ObjectAnimator animator = ObjectAnimator.ofFloat(myView, "rotationY", 0, 360);
animator.setDuration(2000);
animator.start();
  • עיצובים הולוגרפיים חדשים

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

    כל אפליקציה שמטרגטת את פלטפורמת Android 3.0 — על ידי הגדרה של הפרמטר android:minSdkVersion או בערך android:targetSdkVersion ל-"11" – העיצוב ההולוגרפי יורש כברירת מחדל. עם זאת, אם האפליקציה שלך מחילה גם עיצוב משלה, העיצוב שלך יבטל את העיצוב ההולוגרפי, אלא אם תעדכנו את הסגנונות כך שיירשו את העיצוב ההולוגרפי.

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

  • ווידג'טים חדשים
    • AdapterViewAnimator

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

    • AdapterViewFlipper

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

    • CalendarView

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

    • ListPopupWindow

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

    • NumberPicker

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

    • PopupMenu

      מציגה Menu בחלון קופץ מודאלי שמוצמד לתצוגה. החלון הקופץ יופיע מתחת לתצוגת העוגן אם יש מקום, או מעליה אם אין. אם ה-IME מקלדת) גלויה, החלון הקופץ לא חופף ל-IME עד שהמשתמש ייגע תפריט

    • SearchView

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

    • StackView

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

גרפיקה

  • גרפיקה דו-ממדית של האצת חומרה

    עכשיו אפשר להפעיל את רינדור OpenGL לאפליקציה באמצעות הגדרה של android:hardwareAccelerated="true" ברכיב <application> של רכיב המניפסט או עבור <activity> יחיד רכיבים.

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

  • הצגת תמיכה לשכבות חומרה ותוכנה

    כברירת מחדל, לא צוינה שכבה ב-View. אפשר לציין להיות מגובה על ידי שכבת חומרה או תוכנה, המצוינת באמצעות הערכים LAYER_TYPE_HARDWARE ו-LAYER_TYPE_SOFTWARE, באמצעות setLayerType() או layerType .

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

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

    מידע נוסף זמין במסמכי התיעוד בנושא LAYER_TYPE_HARDWARE ו-LAYER_TYPE_SOFTWARE.

  • עיבוד גרפיקה בתלת-ממד של מנוע החיפוש

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

    לקבלת מידע נוסף, אפשר לעיין בעיבוד וחישוב תלת-ממדיים עם תיעוד של Renderscript.

מדיה

  • סרטון Time Lapse

    ממשקי API של Camcorder תומכים עכשיו באפשרות לצלם סרטון Time Lapse. הערך setCaptureRate() קובע את קצב הפריימים צריך לתעד.

  • תמיכה בטקסטורה בסטרימינג של תמונות

    הגרסה החדשה של SurfaceTexture מאפשרת לצלם שידור תמונות בפורמט OpenGL ES טקסטורה. על ידי התקשרות אל setPreviewTexture() עבור של Camera, אפשר לציין את SurfaceTexture שבאמצעותו יש לצייר הפעלת סרטון או להציג תצוגה מקדימה של פריימים מצלמה.

  • סטרימינג בשידור חי בפרוטוקול HTTP

    עכשיו האפליקציות יכולות להעביר כתובת URL של פלייליסט M3U למסגרת המדיה כדי להתחיל שידור HTTP בשידור חי של סטרימינג בשידור חי. ה-framework תומך ברוב המפרט של HTTP בשידור חי כולל קצב העברת נתונים דינמי. אפשר לעיין במסמך פורמטים נתמכים של מדיה עבור מידע נוסף.

  • נתוני EXIF

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

  • פרופילים של מצלמות וידאו

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

  • העברת קובץ של מדיה דיגיטלית

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

  • ניהול זכויות דיגיטלי (DRM)

    מסגרת חדשה לניהול זכויות דיגיטליות (DRM) לבדיקה ואכיפה של מודלים דיגיטליים זכויות. הוא מיושם בשתי שכבות ארכיטקטוניות:

    • ממשק API של מסגרת DRM, שנחשף לאפליקציות ופועל דרך ה-VM של Dalvik לצורך לשימוש רגיל.
    • מנהל DRM קוד מקורי שמטמיע את ממשק ה-API של framework וחושף ממשק עבור DRM יישומי פלאגין לטיפול בניהול זכויות ובפענוח עבור מזימות DRM שונות.

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

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

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

    אפשר למצוא את כל ממשקי ה-API של ניהול זכויות דיגיטליות (DRM) בחבילה android.drm.

תמיכה במקלדת

  • תמיכה במקשי הצירוף Control, Meta, Caps Lock, Num Lock ו- Scroll Lock. לקבלת מידע נוסף, לראות את META_CTRL_ON ושדות קשורים.
  • תמיכה במקלדות מלאות בסגנון שולחן עבודה, כולל תמיכה במקשים כמו Escape, Home, End, מחיקה ואחרים. אפשר לקבוע אם האירועים המרכזיים מגיעים ממקלדת מלאה כך: שליחת שאילתה אל getKeyboardType() ובדיקה של KeyCharacterMap.FULL
  • ב-TextView יש עכשיו תמיכה בחיתוך ובהעתקה מבוססי מקלדת להדביק ולבחור הכול באמצעות שילובי המקשים Control+X, Control+C Control+V ו-Control+A. הוא תומך גם ב-PageUp/PageDown, Home/End וכן בחירת טקסט שמבוססת על המקלדת.
  • ב-KeyEvent נוספו כמה שיטות חדשות כדי שיהיה קל יותר לבדוק את המפתח את מצב השינוי בצורה נכונה ועקבית. ראו hasModifiers(int), hasNoModifiers(), metaStateHasModifiers(), metaStateHasNoModifiers()
  • אפליקציות יכולות להטמיע מקשי קיצור מותאמים אישית על ידי סיווג של Activity, Dialog או View והטמעה onKeyShortcut() ה-framework קורא לשיטה הזו בכל פעם שמשלב מפתח עם מקש Control. כשיוצרים תפריט אפשרויות, אפשר לרשום את המקלדת קיצורי דרך באמצעות הגדרה של המאפיין android:alphabeticShortcut או המאפיין android:numericShortcut לכל <item> רכיב (או עם setShortcut()).
  • Android 3.0 כולל "מקלדת וירטואלית" חדשה מכשיר עם המזהה KeyCharacterMap.VIRTUAL_KEYBOARD. הווירטואלי במקלדת יש מפה של מפתחות בארה"ב בסגנון מחשב, שבעזרתה אפשר לסנתוז אירועים מרכזיים לצורך בדיקה. מהקלט.

אירועי Split Touch

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

אירועי מגע מפוצלים מופעלים כברירת מחדל כשאפליקציה מטרגטת Android 3.0. כלומר, כשהאפליקציה הגדירה את הערך android:minSdkVersion או את הערך של המאפיין android:targetSdkVersion ל-"11".

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

  • המאפיין android:splitMotionEvents לתצוגה מפורטת של קבוצות מאפשרת להשבית אירועי מגע מפוצל שמתרחשים בין צפיות צאצא בפריסה. לדוגמה: 
    <LinearLayout android:splitMotionEvents="false" ... >
    ...
</LinearLayout>

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

  • המאפיין בסגנון android:windowEnableSplitTouch מאפשרת להשבית אירועי מגע מפוצל בין חלונות, על ידי החלתו על עיצוב של הפעילות או את היישום כולו. לדוגמה: 
    <style name="NoSplitMotionEvents" parent="android:Theme.Holo">
    <item name="android:windowEnableSplitTouch">false</item>
    ...
</style>

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

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

WebKit

  • מחלקה חדשה של WebViewFragment כדי ליצור מקטע שמורכב מ- WebView.
  • אמצעי WebSettings חדשים:
    • setDisplayZoomControls() מאפשר לך להסתיר האפשרויות לשינוי מרחק התצוגה במסך, אבל המשתמש עדיין יכול לשנות את מרחק התצוגה באמצעות תנועות אצבע (יש להגדיר setBuiltInZoomControls() true).
    • שיטת WebSettings החדשה, setEnableSmoothTransition(), מאפשרת לך כדי לאפשר מעברים חלקים במהלך הזזה ושינוי מרחק התצוגה. כשהאפשרות מופעלת, מערכת WebView תבחר פתרון כדי למקסם את הביצועים (לדוגמה, ייתכן שהתוכן של ה-WebView לא יתעדכן במהלך מעבר לכך).
  • אמצעי WebView חדשים:
    • קריאה חוזרת של onPause(), כדי להשהות את העיבוד שמשויך ל-WebView כשהוא מוסתר. האפשרות הזו שימושית כדי להפחית את הצורך במעבד (CPU) תנועה ברשת כשה-WebView לא בחזית.
    • קריאה חוזרת של onResume(), כדי להמשיך את העיבוד המשויך ל-WebView, שהושהה במהלך onPause().
    • saveWebArchive() מאפשר לך לשמור את התצוגה הנוכחית כארכיון אינטרנט במכשיר.
    • showFindDialog() יתחיל חיפוש טקסט ב בתצוגה הנוכחית.

דפדפן

יישום הדפדפן מוסיף את התכונות הבאות לתמיכה באפליקציות אינטרנט:

  • צילום מדיה

    כפי שהוגדר על ידי HTML Media Recording מפרט, הדפדפן מאפשר לאפליקציות אינטרנט לגשת לצילום אודיו, תמונות ווידאו ביכולות של המכשיר. לדוגמה, קוד ה-HTML הבא מספק למשתמש קלט צילום תמונה להעלאה:

    <input type="file" accept="image/*;capture=camera" />

    לחלופין, על ידי החרגה של הפרמטר capture=camera, המשתמש יכול לבחור אם לתעד תמונה חדשה באמצעות המצלמה, או לבחור תמונה מהמכשיר (למשל, מאפליקציית הגלריה).

  • כיוון המכשיר

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

    כיוון המכשיר מבוטא באמצעות הצירים x, y ו-z, במעלות ובתנועה הוא מבוטאת בנתונים של תאוצה וקצב סיבוב. דף אינטרנט יכול להירשם לקבלת כיוון אירועים על ידי חיוג אל window.addEventListener עם אירוע מסוג "deviceorientation" ולהירשם לאירועי תנועה, על ידי רישום של אירוע מסוג "devicemotion".

  • טרנספורמציות תלת-ממדיות ב-CSS

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

כלי עזר ל-JSON

כיתות חדשות, JsonReader ו-JsonWriter, יכולות לעזור לך קריאה וכתיבה של זרמי JSON. ממשקי ה-API החדשים משלימים את המחלקות org.json, שמשפיעות על מסמך בזיכרון.

אפשר ליצור מופע של JsonReader בקריאה באמצעות constructor שלו, ומעביר את הפרמטר InputStreamReader שמזין את מחרוזת ה-JSON. אחר כך, מתחילים לקרוא אובייקט בקריאה ל-beginObject(), קוראים שם מפתח עם nextName(), יש לקרוא את הערך באמצעות שיטות בהתאמה לסוג, למשל nextString() ו-nextInt(), וממשיכים לעשות זאת כל עוד hasNext() הוא True.

אפשר ליצור מופע של JsonWriter על ידי קריאה ל-constructor שלו להעביר את הערך המתאים של OutputStreamWriter. ואז כותבים את נתוני ה-JSON באופן דומה ל-Reader, משתמש ב-name() כדי להוסיף שם של נכס ו-method מתאים של value() כדי להוסיף עם ערך מסוים.

כברירת מחדל, המחלקות האלה מחמירות. setLenient() בכל מחלקה מגדירה אותם לליברליות יותר מבחינת מה שהם מקבלים. ההתאמה הקלה הזו מצב הניתוח תואם גם למנתח ברירת המחדל של org.json.

קבועים של תכונות חדשות

<uses-feature> יש להשתמש ברכיב Manfest כדי ליידע ישויות חיצוניות (כמו Google Play) על קבוצת תכונות חומרה ותוכנה שבהן האפליקציה שלך תלויה. בגרסה הזו, מערכת Android מוסיפה את הקבועים החדשים הבאים שהאפליקציות יכולות להצהיר עליהם באמצעות הרכיב הזה:

  • "android.hardware.faketouch"

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

    אם האפליקציה לא מחייבת תנועות מורכבות לא רוצים שהאפליקציה תסונן ממכשירים עם אמולציה של מסך המגע, צריך להצהיר על "android.hardware.faketouch" עם <uses-feature> לרכיב מסוים. כך האפליקציה תהיה זמינה למספר הגדול ביותר של סוגי מכשירים, כולל אלה שמספקים רק קלט אמולציה של מסך מגע.

    כל המכשירים שכוללים מסך מגע תומכים גם ב-"android.hardware.faketouch", כי יכולות של מסך מגע הן קבוצת-על של יכולות מזויפות. לכן, אלא אם אתם באמת צריכים מסך מגע, צריך להוסיף <uses-feature> ל-faketouch.

הרשאות חדשות

  • "android.permission.BIND_REMOTEVIEWS"

    צריך להצהיר על כך כהרשאה נדרשת במניפסט של <service> ליישום של RemoteViewsService. לדוגמה, כאשר ליצירת ווידג'ט של אפליקציה שמשתמש ב-RemoteViewsService כדי לאכלס תצוגת האוסף, רשומת המניפסט עשויה להיראות כך:

    <service android:name=".widget.WidgetService"
    android:exported="false"
    android:permission="android.permission.BIND_REMOTEVIEWS" />

טכנולוגיות פלטפורמה חדשות

  • אחסון
    • תמיכה במערכת הקבצים ext4 כדי להפעיל אחסון eMMC מובנה.
    • מערכת הקבצים FUSE לתמיכה במכשירי MTP.
    • תמיכה במצב מארח USB כדי לתמוך במקלדות ובמפצלים של USB.
    • תמיכה ב-MTP/PTP
  • ליבה (Kernel) של Linux
    • שודרג ל-2.6.36
  • מכונת VM של Daalvik
    • קוד חדש לתמיכה ולאופטימיזציה ל-SMP
    • שיפורים שונים בתשתית JIT
    • שיפורים באיסוף אשפה:
      • עבר כוונון ל-SMP
      • תמיכה בגודלי ערימה גדולים יותר
      • טיפול אחיד למפות סיביות ולמאגרי בייטים
  • ספריות הליבה של דאלוויק
    • הטמעה חדשה ומהירה בהרבה של NIO (ספריית I/O מודרנית)
    • הודעות חריגות משופרות
    • נכונות ותיקוני ביצועים לאורך

דוח הבדלים בין ממשקי API

לתצוגה מפורטת של כל שינויי ה-API ב-Android 3.0 (רמת API) 11), ניתן לעיין בדוח ההבדלים ב-API.

רמת API

פלטפורמת Android 3.0 מספקת גרסה מעודכנת של ממשק ה-API של framework. ממשק ה-API של Android 3.0 מקבלים מזהה של מספר שלם – 11 – כלומר מאוחסנים במערכת עצמה. המזהה הזה, שנקרא 'רמת API', מאפשר כדי לקבוע בצורה נכונה אם אפליקציה תואמת במערכת, לפני התקנת האפליקציה.

כדי להשתמש בממשקי API שנוספו ל-Android 3.0 באפליקציה שלכם: צריך להדר את האפליקציה מול ספריית Android שמופיעה פלטפורמת Android 3.0 SDK. בהתאם לצרכים שלכם, ייתכן צריך להוסיף גם android:minSdkVersion="11" לרכיב <uses-sdk> . אם האפליקציה מיועדת לפעול רק ב-Android מגרסה 2.3 ואילך, הצהרה על המאפיין מונעת את התקנת האפליקציה בשלב מוקדם יותר של הפלטפורמה.

מידע נוסף זמין במאמר מהו API רמה?