ממשקי API של Android 3.0

רמת API: 11

למפתחים, פלטפורמת Android 3.0‏ (HONEYCOMB) זמינה כרכיב שניתן להורדה ל-Android SDK. הפלטפורמה שניתן להורדה כוללת ספרייה ותמונת מערכת של 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. לגבי הפעילות, למשל כדי לנהל את ההתקדמות של הורדה שמתרחשת רק בזמן פעילה.

בנוסף:

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

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

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

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

סרגל הפעולות

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

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

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

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

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

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

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

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

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

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

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

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

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

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

כדי להתחיל להשתמש בלוח, צריך להשיג את האובייקט הגלובלי 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 Demos, והטמעה מלאה יותר בדוגמה של Note Pad.

גרירה ושחרור

ממשקי 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 כדי לקבל קריאות חזרה (callbacks) כשמתבצעת בקשה לטעינה של מעבד נתונים חדש או כשהנתונים משתנים, ואז לבצע קריאה ל-initLoader() כדי לאתחל את מעבד הנתונים לפעילות או לחלק.

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

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

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

אפשר לאתחל את BluetoothProfile המתאים על ידי קריאה ל-getProfileProxy() עם קבוע הפרופיל A2DP או HEADSET ו-BluetoothProfile.ServiceListener כדי לקבל קריאות חזרה (callbacks) כשלקוח ה-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 Demos.

  • ממשקי 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 – על ידי הגדרת הערך "11" לערך של android:minSdkVersion או של android:targetSdkVersion – יורשת את העיצוב ההולוגרפי כברירת מחדל. עם זאת, אם האפליקציה שלך מחילה גם עיצוב משלה, העיצוב שלך יבטל את העיצוב ההולוגרפי, אלא אם תעדכנו את הסגנונות כך שיירשו את העיצוב ההולוגרפי.

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

    מידע נוסף זמין במאמר עיבוד ויצירת גרפיקת 3D באמצעות 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 שונות.

    למפתחי אפליקציות, המסגרת מציעה ממשק API מופשט ומאוחד שמפשט את הניהול של תוכן מוגן. ה-API מסתיר את המורכבות של פעולות ה-DRM ומאפשר מצב פעולה עקבי גם לתוכן מוגן וגם לתוכן לא מוגן, במגוון של סכמות 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() המסגרת מפעילה את השיטה הזו בכל פעם שמקש משולב עם מקש Control. כשיוצרים תפריט אפשרויות, אפשר לרשום את המקלדת קיצורי דרך באמצעות הגדרה של המאפיין android:alphabeticShortcut או המאפיין android:numericShortcut לכל <item> רכיב (או עם setShortcut()).
  • Android 3.0 כולל מכשיר חדש מסוג 'מקלדת וירטואלית' עם המזהה KeyCharacterMap.VIRTUAL_KEYBOARD. במקלדת הווירטואלית יש מפת מפתחות של ארה"ב בסגנון מחשב, שמתאימה ליצירת אירועים מרכזיים לצורך בדיקת קלט.

אירועי Split Touch

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

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

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

  • המאפיין 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() קריאה חוזרת (callback), כדי להמשיך את העיבוד שמשויך ל-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 3D Transform Module, הדפדפן מאפשר לבצע טרנספורמציה של רכיבים שנעשה להם רינדור באמצעות CSS בשלושה ממדים.

כלי JSON

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

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

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

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

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

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

  • "android.hardware.faketouch"

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

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

    כל המכשירים עם מסך מגע תומכים גם ב-"android.hardware.faketouch", כי יכולות מסך המגע הן קבוצה גדולה יותר מיכולות 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. ל-Android 3.0 API מוקצה מזהה שלם – 11 – שנשמר במערכת עצמה. המזהה הזה, שנקרא 'רמת API', מאפשר כדי לקבוע בצורה נכונה אם אפליקציה תואמת במערכת, לפני התקנת האפליקציה.

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

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