ממשקי API של Android 4.4

רמת API: ‏ 19

‫Android 4.4‏ (KITKAT) היא גרסה חדשה של פלטפורמת Android שמציעה תכונות חדשות למשתמשים ולמפתחי אפליקציות. במסמך הזה מפורטים ממשקי ה-API החדשים והבולטים ביותר.

כמפתחי אפליקציות, אתם צריכים להוריד את קובץ האימג' של מערכת Android 4.4 ואת פלטפורמת ה-SDK מ-SDK Manager בהקדם האפשרי. אם אין לכם מכשיר עם Android 4.4 כדי לבדוק את האפליקציה, אתם יכולים להשתמש בתמונת המערכת של Android 4.4 כדי לבדוק את האפליקציה באמולטור Android. לאחר מכן, צריך לפתח את האפליקציות בפלטפורמת Android 4.4 כדי להתחיל להשתמש בממשקי ה-API העדכניים.

עדכון של רמת ה-API המטורגטת

כדי לבצע אופטימיזציה של האפליקציה למכשירים עם Android 4.4, צריך להגדיר את targetSdkVersion לערך "19", להתקין אותה בתמונת מערכת של Android 4.4, לבדוק אותה ואז לפרסם עדכון עם השינוי הזה.

כדי להשתמש בממשקי API ב-Android 4.4 וגם לתמוך בגרסאות ישנות יותר, אתם יכולים להוסיף לקוד תנאים שבודקים את רמת ה-API של המערכת לפני הפעלת ממשקי API שלא נתמכים על ידי minSdkVersion. במאמר תמיכה בגרסאות שונות של פלטפורמות מוסבר איך לשמור על תאימות לדורות קודמים.

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

שינויים חשובים בהתנהגות

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

אם האפליקציה קוראת מאחסון חיצוני…

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

אם האפליקציה משתמשת ב-WebView…

יכול להיות שהאפליקציה תפעל בצורה שונה ב-Android 4.4, במיוחד אם מעדכנים את targetSdkVersion של האפליקציה ל-"19" ומעלה.

הקוד שעומד בבסיס המחלקה WebView וממשקי ה-API הקשורים שודרג, ועכשיו הוא מבוסס על תמונת מצב מודרנית של קוד המקור של Chromium. הגרסה הזו כוללת מגוון שיפורים בביצועים, תמיכה בתכונות חדשות של HTML5 ותמיכה בניפוי באגים מרחוק בתוכן של WebView. היקף השדרוג הזה אומר שאם האפליקציה שלך משתמשת ב-WebView, יכול להיות שההתנהגות שלה תושפע במקרים מסוימים. למרות ששינויי ההתנהגות הידועים מתועדים ומשפיעים על האפליקציה בעיקר כשמעדכנים את targetSdkVersion של האפליקציה ל-"19" ומעלה – WebView החדש פועל ב-"מצב תאימות (quirks mode)" כדי לספק פונקציונליות מדור קודם באפליקציות שמטרגטות את רמת ה-API המיועדת 18 ומטה – יכול להיות שהאפליקציה שלכם תלויה בהתנהגויות לא ידועות מהגרסה הקודמת של WebView.

לכן, אם האפליקציה הקיימת שלכם משתמשת ב-WebView, חשוב שתבדקו אותה ב-Android 4.4 בהקדם האפשרי ותעיינו במאמר מעבר ל-WebView ב-Android 4.4 כדי לקבל מידע על האופן שבו האפליקציה עשויה להיות מושפעת כשתעדכנו את targetSdkVersion ל-"19" ומעלה.

אם האפליקציה משתמשת ב-AlarmManager...

כשמגדירים את targetSdkVersion של האפליקציה ל-"19" ומעלה, השעונים המעוררים שיוצרים באמצעות set() או setRepeating() לא יהיו מדויקים.

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

אם ההתראה לא משויכת לשעה מדויקת, אבל עדיין חשוב שהיא תופעל בטווח זמן מסוים (למשל בין 14:00 ל-16:00), אפשר להשתמש בשיטה החדשה setWindow(), שמקבלת את השעה "המוקדמת ביותר" להפעלת ההתראה ו"חלון" זמן אחרי השעה המוקדמת ביותר שבו המערכת צריכה להפעיל את ההתראה.

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

ההתנהגות הלא מדויקת הזו של איסוף בקבוצות חלה רק על אפליקציות מעודכנות. אם הגדרתם את targetSdkVersion ל-"18" או פחות, ההתראות ימשיכו לפעול כמו בגרסאות קודמות כשהן פועלות ב-Android 4.4.

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

כשמגדירים את targetSdkVersion של האפליקציה ל-"19" ומעלה, יצירת סנכרון עם addPeriodicSync() תבצע את פעולות הסנכרון בתוך מרווח גמיש שמוגדר כברירת מחדל של כ-4% מהתקופה שציינתם. לדוגמה, אם תדירות הסקר היא 24 שעות, פעולת הסנכרון עשויה להתרחש בטווח של כשעה בכל יום, במקום בדיוק באותה שעה בכל יום.

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

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

מסגרת הדפסה

עכשיו Android כוללת מסגרת מלאה שמאפשרת למשתמשים להדפיס כל מסמך באמצעות מדפסת שמחוברת דרך Wi-Fi, ‏Bluetooth או שירותים אחרים. המערכת מטפלת בעסקה בין אפליקציה שרוצה להדפיס מסמך לבין השירותים שמעבירים את משימות ההדפסה למדפסת. ה-framework של android.print מספק את כל ממשקי ה-API שנדרשים כדי לציין מסמך להדפסה ולהעביר אותו למערכת להדפסה. ממשקי ה-API שאתם צריכים בפועל לעבודת הדפסה מסוימת תלויים בתוכן שלכם.

הדפסת תוכן כללי

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

כדי לכתוב את התוכן שלך ב-ParcelFileDescriptor, צריך להעביר לו קובץ PDF. ממשקי ה-API החדשים של PdfDocument מספקים דרך נוחה לעשות זאת על ידי מתן Canvas מ-getCanvas(), שעליו אפשר לצייר את התוכן שניתן להדפסה. לאחר מכן כותבים את ה-PdfDocument ב-ParcelFileDescriptor באמצעות ה-method‏ writeTo().

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

הדפסת תמונות

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

שירותי הדפסה של מבנים

יצרני ציוד מקורי (OEM) של מדפסות יכולים להשתמש במסגרת android.printservice כדי לספק יכולת פעולה הדדית עם המדפסות שלהם ממכשירי Android. אתם יכולים ליצור ולהפיץ שירותי הדפסה כקובצי APK, שהמשתמשים יכולים להתקין במכשירים שלהם . אפליקציה של שירות הדפסה פועלת בעיקר כשירות ללא ממשק גרפי (headless) על ידי יצירת מחלקת משנה של המחלקה PrintService, שמקבלת משימות הדפסה מהמערכת ומעבירה אותן למדפסות שלה באמצעות הפרוטוקולים המתאימים.

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

ספק SMS

ספק התוכן Telephony ("ספק ה-SMS") מאפשר לאפליקציות לקרוא ולכתוב הודעות SMS ו-MMS במכשיר. הוא כולל טבלאות של הודעות SMS ו-MMS שהתקבלו, נשמרו כטיוטה, נשלחו, ממתינות ועוד.

החל מ-Android 4.4, הגדרות המערכת מאפשרות למשתמשים לבחור "אפליקציית סמס שמוגדרת כברירת מחדל". אחרי הבחירה, רק אפליקציית סמס ברירת המחדל יכולה לכתוב לספק ה-SMS, ורק אפליקציית סמס ברירת המחדל מקבלת את השידור SMS_DELIVER_ACTION כשהמשתמש מקבל סמס או את השידור WAP_PUSH_DELIVER_ACTION כשהמשתמש מקבל MMS. אפליקציית סמס שמוגדרת כברירת מחדל אחראית על כתיבת הפרטים לספק ה-SMS כשהיא מקבלת או שולחת הודעה חדשה.

אפליקציות סמס אחרות שלא נבחרו כאפליקציית ברירת המחדל ל-SMS יכולות רק לקרוא את ספק ה-SMS, אבל הן יכולות גם לקבל התראה כשמגיעה הודעת SMS חדשה על ידי האזנה לשידור SMS_RECEIVED_ACTION, שהוא שידור שלא ניתן לבטל וניתן להעביר אותו למספר אפליקציות. השידור הזה מיועד לאפליקציות שצריכות לקרוא הודעות נכנסות מיוחדות, למשל כדי לבצע Phone Number Verification, גם אם הן לא נבחרו כאפליקציית סמס של ברירת המחדל.

מידע נוסף זמין בפוסט בבלוג, הכנת אפליקציות הסמס ל-KitKat.

תקשורת אלחוטית וקישוריות

Host Card Emulation

אפליקציות ל-Android יכולות עכשיו לדמות כרטיסי NFC מסוג ISO14443-4‏ (ISO-DEP) שמשתמשים ב-APDU להחלפת נתונים (כפי שמפורט ב-ISO7816-4). כך מכשיר עם תמיכה ב-NFC שפועל עם Android 4.4 יכול לדמות כמה כרטיסי NFC בו-זמנית, ומסוף תשלום ב-NFC או קורא NFC אחר יכולים להתחיל עסקה עם כרטיס ה-NFC המתאים על סמך מזהה האפליקציה (AID).

אם אתם רוצים לדמות באפליקציה כרטיס NFC שמשתמש בפרוטוקולים האלה, צרו רכיב שירות שמבוסס על המחלקה HostApduService. לעומת זאת, אם האפליקציה משתמשת ברכיב מאובטח לאמולציית כרטיסים, צריך ליצור שירות שמבוסס על המחלקה OffHostApduService. השירות הזה לא יהיה מעורב ישירות בעסקאות, אבל הוא נדרש כדי לרשום את מזהי האפליקציות (AID) שהרכיב המאובטח אמור לטפל בהם.

מידע נוסף זמין במדריך בנושא אמולציה של כרטיס NFC.

מצב קורא NFC

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

היכולת החדשה הזו, בשילוב עם Host Card Emulation, מאפשרת ל-Android לפעול בשני הקצוות של ממשק תשלום דרך מכשיר נייד: מכשיר אחד פועל כמסוף התשלום (מכשיר שמפעיל פעילות במצב קורא) ומכשיר אחר פועל כלקוח התשלום (מכשיר שמדמה כרטיס NFC).

משדרי אינפרה-אדום

כשמפעילים את האפליקציה במכשיר שכולל משדר אינפרא-אדום (IR), אפשר לשדר אותות IR באמצעות ממשקי ה-API של ConsumerIrManager. כדי לקבל מופע של ConsumerIrManager, צריך להפעיל את getSystemService() עם CONSUMER_IR_SERVICE כארגומנט. לאחר מכן, אפשר לשלוח שאילתה לגבי תדרי האינפרה-אדום שנתמכים במכשיר באמצעות getCarrierFrequencies() ולשדר אותות על ידי העברת התדר הרצוי ותבנית האות באמצעות transmit().

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

מולטימדיה

הפעלה דינמית

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

כדי להפעיל הפעלה מותאמת, צריך להוסיף שני מפתחות ל-MediaFormat שמציינים את הרזולוציה המקסימלית שהאפליקציה דורשת מה-codec: ‏KEY_MAX_WIDTH ו-KEY_MAX_HEIGHT. אחרי שמוסיפים את הפרמטרים האלה ל-MediaFormat, מעבירים את MediaFormat למכונה של MediaCodec באמצעות configure().

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

כדי לשנות את הרזולוציה בזמן פענוח של סרטון H.264, צריך להמשיך להוסיף פריימים לתור באמצעות MediaCodec.queueInputBuffer(), אבל חשוב לספק את הערכים החדשים של Sequence Parameter Set (SPS)‎ ו-Picture Parameter Set (PPS)‎ יחד עם הפריים של Instantaneous Decoder Refresh (IDR)‎ במאגר נתונים זמני אחד.

עם זאת, לפני שמנסים להגדיר את ה-codec להפעלה דינמית, צריך לוודא שהמכשיר תומך בהפעלה דינמית על ידי קריאה ל-isFeatureSupported(String) עם FEATURE_AdaptivePlayback.

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

חותמות זמן של אודיו לפי דרישה

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

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

קורא תמונות של משטחים

‫ImageReader API החדש נותן לכם גישה ישירה למאגרי תמונות כשהם עוברים עיבוד (render) ל-Surface. אפשר לקבל ImageReader באמצעות ה-method הסטטית newInstance(). אחר כך קוראים ל-getSurface() כדי ליצור Surface חדש ומעבירים את נתוני התמונה באמצעות יצרן כמו MediaPlayer או MediaCodec. כדי לקבל התראה כשתמונות חדשות זמינות מהמשטח, מטמיעים את הממשק ImageReader.OnImageAvailableListener ורושמים אותו באמצעות setOnImageAvailableListener().

עכשיו, כשמשרטטים תוכן ב-Surface, ה-ImageReader.OnImageAvailableListener מקבל קריאה ל-onImageAvailable() כשכל פריים חדש של תמונה הופך לזמין, ומספק את ה-ImageReader התואם. אפשר להשתמש ב-ImageReader כדי לקבל את נתוני התמונה של הפריים כאובייקט Image על ידי קריאה ל-acquireLatestImage() או ל-acquireNextImage().

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

מדידת שיא ו-RMS

עכשיו אפשר לשלוח שאילתה לגבי שיא העוצמה וה-RMS של שידור האודיו הנוכחי מ-Visualizer. כדי לעשות את זה, יוצרים מופע חדש של Visualizer.MeasurementPeakRms ומעבירים אותו אל getMeasurementPeakRms(). כשמפעילים את השיטה הזו, ערכי השיא וה-RMS של Visualizer.MeasurementPeakRms הנתון מוגדרים לערכים האחרונים שנמדדו.

מגביר עוצמת קול

‫LoudnessEnhancer היא תת-מחלקה חדשה של AudioEffect שמאפשרת להגביר את עוצמת הקול של MediaPlayer או AudioTrack. האפשרות הזו יכולה להיות שימושית במיוחד בשילוב עם השיטה החדשה getMeasurementPeakRms() שהוזכרה קודם, כדי להגביר את עוצמת הקול של טראקים של אודיו של דיבור בזמן שמדיה אחרת מופעלת.

שלטים רחוקים

ב-Android 4.0 (רמת API ‏14) הושקו ממשקי ה-API של RemoteControlClient, שמאפשרים לאפליקציות מדיה לצרוך אירועים של ממשק השליטה במדיה מלקוחות מרוחקים, כמו ממשק השליטה במדיה במסך הנעילה. עכשיו ממשקי ה-API החדשים של RemoteController מאפשרים לך ליצור שלט רחוק משלך, וכך ליצור אפליקציות וציוד היקפי חדשים וחדשניים שיכולים לשלוט בהפעלה של כל אפליקציית מדיה שמשולבת עם RemoteControlClient.

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

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

דירוגים משלטים רחוקים

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

המחלקה החדשה Rating כוללת מידע על דירוג של משתמש. הדירוג מוגדר לפי סגנון הדירוג (RATING_HEART,‏ RATING_THUMB_UP_DOWN,‏ RATING_3_STARS,‏ RATING_4_STARS,‏ RATING_5_STARS או RATING_PERCENTAGE) וערך הדירוג שמתאים לסגנון הזה.

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

כדי לקבל קריאה חוזרת (callback) כשהמשתמש משנה את הדירוג מהשלט הרחוק, צריך להטמיע את הממשק החדש RemoteControlClient.OnMetadataUpdateListener ולהעביר מופע אל setMetadataUpdateListener(). כשהמשתמש משנה את הדירוג, ה-RemoteControlClient.OnMetadataUpdateListener שלך מקבל קריאה ל-onMetadataUpdate(), ומעביר את RATING_KEY_BY_USER כמפתח ואובייקט Rating כערך.

כתוביות

VideoView תומך עכשיו בטראקים של כתוביות בפורמט WebVTT כשמפעילים סרטונים ב-HTTP Live Stream ‏(HLS). הטראק של הכתוביות מוצג בהתאם להעדפות של הכתוביות הסמויות שהמשתמש הגדיר בהגדרות המערכת.

אתם יכולים גם לספק ל-VideoView את טראקים של כתוביות WebVTT באמצעות השיטה addSubtitleSource(). השיטה הזו מקבלת InputStream שכולל את נתוני הכתוביות ואובייקט MediaFormat שמציין את הפורמט של נתוני הכתוביות, שאפשר לציין באמצעות createSubtitleFormat(). הכתוביות האלה מופיעות גם על גבי הסרטון בהתאם להעדפות של המשתמש.

אם אתם לא משתמשים ב-VideoView כדי להציג את קטע הווידאו, שכבת הכתוביות צריכה להתאים ככל האפשר להעדפות הכתוביות הסמויות של המשתמש. ‫API חדש של CaptioningManager מאפשר לשלוח שאילתות לגבי ההעדפות של המשתמשים בנוגע לכתוביות סמויות, כולל סגנונות שמוגדרים על ידי CaptioningManager.CaptionStyle, כמו משפחת גופנים וצבע. אם המשתמש משנה חלק מההעדפות אחרי שהסרטון כבר התחיל, צריך להאזין לשינויים בהעדפות על ידי רישום מופע של CaptioningManager.CaptioningChangeListener כדי לקבל קריאה חוזרת (callback) כשחלק מההעדפות משתנות, ואז לעדכן את הכתוביות לפי הצורך.

אנימציה וגרפיקה

סצנות ומעברים

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

כדי לעבור בין שתי סצנות, בדרך כלל צריך לבצע את הפעולות הבאות:

  1. מציינים את ה-ViewGroup שמכיל את רכיבי ממשק המשתמש שרוצים לשנות.
  2. מציינים את הפריסה שמייצגת את התוצאה הסופית של השינוי (הסצנה הבאה).
  3. מציינים את סוג המעבר שצריך להנפיש את השינוי בפריסה.
  4. מבצעים את המעבר.

אפשר להשתמש באובייקט Scene כדי לבצע את שלבים 1 ו-2. Scene מכיל מטא-נתונים שמתארים את המאפיינים של פריסה שנדרשים כדי לבצע מעבר, כולל התצוגה הראשית של הסצנה והפריסה של הסצנה. אפשר ליצור Scene באמצעות בנאי של מחלקה או השיטה הסטטית getSceneForLayout().

לאחר מכן, צריך להשתמש ב-TransitionManager כדי לבצע את שלבים 3 ו-4. דרך אחת היא להעביר את Scene ל-static method go(). הפעולה הזו מאתרת את התצוגה להורה של הסצנה בפריסה הנוכחית ומבצעת מעבר בתצוגות לילדים כדי להגיע לפריסה שהוגדרה על ידי Scene.

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

כדי לקבל שליטה נוספת, אתם יכולים להגדיר קבוצות של מעברים שצריכים להתרחש בין סצנות מוגדרות מראש, באמצעות קובץ XML בספרייה res/transition/ של הפרויקט. בתוך רכיב <transitionManager>, מציינים תג <transition> אחד או יותר, שכל אחד מהם מציין סצנה (הפניה לקובץ פריסה) ואת המעבר שצריך להחיל כשנכנסים לסצנה הזו או יוצאים ממנה. ואז להרחיב את קבוצת המעברים הזו באמצעות inflateTransitionManager(). משתמשים ב-TransitionManager שהוחזר כדי לבצע כל מעבר באמצעות transitionTo(), ומעבירים Scene שמיוצג על ידי אחד מהתגים של <transition>. אפשר גם להגדיר קבוצות של מעברים באופן פרוגרמטי באמצעות ממשקי ה-API של TransitionManager.

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

מידע נוסף זמין במאמרי העזרה של TransitionManager.

השהיית האנימציה

ממשקי ה-API של Animator מאפשרים עכשיו להשהות אנימציה פעילה ולהמשיך אותה באמצעות השיטות pause() ו-resume().

כדי לעקוב אחרי מצב האנימציה, אתם יכולים להטמיע את הממשק Animator.AnimatorPauseListener, שמספק קריאות חוזרות (callbacks) כשהאנימציה מושהית ומופעלת מחדש: pause() ו-resume(). לאחר מכן מוסיפים את ה-listener לאובייקט Animator באמצעות addPauseListener().

לחלופין, אפשר ליצור מחלקת משנה של המחלקה המופשטת AnimatorListenerAdapter, שכוללת עכשיו הטמעות ריקות של פונקציות ה-callback להשהיה ולהמשכה שמוגדרות על ידי Animator.AnimatorPauseListener.

מפות סיביות לשימוש חוזר

עכשיו אפשר להשתמש שוב בכל מפת סיביות ניתנת לשינוי ב-BitmapFactory כדי לפענח כל מפת סיביות אחרת – גם אם מפת הסיביות החדשה היא בגודל שונה – כל עוד מספר הבייטים שנוצר ממפת הסיביות המפוענחת (זמין מ-getByteCount()) קטן ממספר הבייטים שהוקצה למפת הסיביות שנעשה בה שימוש חוזר (זמין מ-getAllocationByteCount()) או שווה לו. מידע נוסף זמין במאמר inBitmap.

ממשקי API חדשים של Bitmap מאפשרים הגדרה מחדש דומה לשימוש חוזר מחוץ ל-BitmapFactory (ליצירת מפת סיביות ידנית או לוגיקת פענוח בהתאמה אישית). עכשיו אפשר להגדיר את המידות של מפת סיביות באמצעות השיטות setHeight() ו-setWidth(), ולציין Bitmap.Config חדש באמצעות setConfig() בלי להשפיע על ההקצאה הבסיסית של מפת הסיביות. ה-method‏ reconfigure() גם מספקת דרך נוחה לשלב את השינויים האלה בקריאה אחת.

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

תוכן משתמשים

מסגרת גישה לאחסון

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

אם אתם מפתחים אפליקציה שמספקת שירותי אחסון לקבצים (כמו שירות שמירה בענן), אתם יכולים להשתתף בממשק המשתמש המאוחד הזה לבחירת קבצים על ידי הטמעת ספק לניהול גישה כמחלקת משנה של המחלקה החדשה DocumentsProvider. מחלקה המשנה של DocumentsProvider צריכה לכלול מסנן Intent שמקבל את הפעולה PROVIDER_INTERFACE ("android.content.action.DOCUMENTS_PROVIDER"). לאחר מכן צריך להטמיע את ארבע השיטות המופשטות ב-DocumentsProvider:

queryRoots()
הפונקציה הזו צריכה להחזיר Cursor שמתאר את כל תיקיות השורש של אחסון המסמכים, באמצעות עמודות שמוגדרות ב-DocumentsContract.Root.
queryChildDocuments()
‫
הפונקציה הזו צריכה להחזיר Cursor שמתאר את כל הקבצים בספרייה שצוינה, באמצעות עמודות שמוגדרות ב-DocumentsContract.Document.
queryDocument()
הפונקציה צריכה להחזיר Cursor שמתאר את הקובץ שצוין, באמצעות עמודות שמוגדרות ב-DocumentsContract.Document.
openDocument()
הפונקציה צריכה להחזיר ParcelFileDescriptor שמייצג את הקובץ שצוין. המערכת קוראת ל-method הזו אחרי שהמשתמש בוחר קובץ ואפליקציית הלקוח מבקשת גישה אליו באמצעות קריאה ל-openFileDescriptor().

מידע נוסף זמין במדריך בנושא Storage Access Framework.

גישה לאחסון חיצוני

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

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

הרשומה הראשונה במערך File שמוחזר נחשבת לאחסון החיצוני הראשי של המכשיר, והיא זהה ל-File שמוחזר על ידי שיטות קיימות כמו getExternalFilesDir().

הערה: החל מ-Android 4.4, הפלטפורמה כבר לא דורשת שהאפליקציה תבקש את ההרשאות WRITE_EXTERNAL_STORAGE או READ_EXTERNAL_STORAGE כשצריך לגשת רק לאזורים הספציפיים לאפליקציה באחסון החיצוני באמצעות השיטות שלמעלה. עם זאת, ההרשאות נדרשות אם רוצים לגשת לאזורים הניתנים לשיתוף של האחסון החיצוני, שסופקו על ידי getExternalStoragePublicDirectory().

מתאמי סנכרון

ה-method החדשה requestSync() ב-ContentResolver מפשטת חלק מהתהליך של הגדרת בקשת סנכרון ל-ContentProvider, על ידי הכללת בקשות באובייקט החדש SyncRequest, שאפשר ליצור באמצעות SyncRequest.Builder. המאפיינים ב-SyncRequest מספקים את אותה פונקציונליות כמו קריאות הסנכרון הקיימות של ContentProvider, אבל מוסיפים את היכולת לציין שצריך לבטל סנכרון אם הרשת נמדדת, על ידי הפעלת setDisallowMetered().

קלט של משתמשים

סוגי חיישנים חדשים

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

בנוסף, Android תומכת עכשיו בחיישני צעדים מובנים בחומרה:

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

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

שני חיישני הצעדים תלויים בחומרה (Nexus 5 הוא המכשיר הראשון שתומך בהם), לכן צריך לבדוק את הזמינות באמצעות hasSystemFeature(), בעזרת הקבועים FEATURE_SENSOR_STEP_DETECTOR ו-FEATURE_SENSOR_STEP_COUNTER.

אירועי חיישן באצווה

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

כדי לספק אצווה, המחלקה SensorManager מוסיפה שתי גרסאות חדשות של השיטה registerListener() שמאפשרות לציין את "זמן האחזור המקסימלי של הדוח". הפרמטר החדש הזה מציין את העיכוב המקסימלי ש-SensorEventListener יכול לסבול בהעברת אירועים חדשים של החיישן. לדוגמה, אם מציינים זמן אחזור של דקה אחת, המערכת תשלח את קבוצת האירועים האחרונה שנאספה במרווח זמן שלא עולה על דקה אחת, על ידי ביצוע קריאות רצופות ל-method‏ onSensorChanged() – פעם אחת לכל אירוע שנאסף. אירועי החיישן אף פעם לא יתעכבו יותר מערך זמן האחזור המקסימלי לדיווח, אבל יכול להיות שהם יגיעו מוקדם יותר אם אפליקציות אחרות ביקשו זמן אחזור קצר יותר לאותו חיישן.

עם זאת, חשוב לזכור שהחיישן יעביר לאפליקציה את האירועים שנאספו לפי זמן האחזור של הדיווח רק כשהמעבד (CPU) פעיל. למרות שחיישן חומרה שתומך באצווה ימשיך לאסוף אירועי חיישן בזמן שה-CPU במצב שינה, הוא לא יעיר את ה-CPU כדי להעביר לאפליקציה את האירועים שנאספו. כשהזיכרון של החיישן לאירועים מתמלא, הוא מתחיל למחוק את האירועים הישנים ביותר כדי לשמור את האירועים החדשים ביותר. כדי למנוע אובדן של אירועים, אפשר להעיר את המכשיר לפני שהזיכרון של החיישן מתמלא, ואז להפעיל את flush() כדי לתעד את קבוצת האירועים האחרונה. כדי להעריך מתי הזיכרון יהיה מלא וצריך לרוקן אותו, צריך להפעיל את getFifoMaxEventCount() כדי לקבל את המספר המקסימלי של אירועי חיישן שאפשר לשמור, ולחלק את המספר הזה בקצב שבו האפליקציה רוצה כל אירוע. משתמשים בחישוב הזה כדי להגדיר התראות התעוררות באמצעות AlarmManager שמפעילות את Service (שמטמיע את SensorEventListener) כדי לרוקן את החיישן.

הערה: לא כל המכשירים תומכים באירועי חיישנים באצווה, כי נדרשת תמיכה של חיישן החומרה. עם זאת, החל מ-Android 4.4, תמיד צריך להשתמש בשיטות registerListener() החדשות, כי אם המכשיר לא תומך באצווה, המערכת מתעלמת בצורה חלקה מהארגומנט של זמן האחזור של האצווה ומעבירה אירועי חיישנים בזמן אמת.

זהויות של נאמני מידע

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

מכשירים מחוברים מספקים עכשיו גם מזהי מוצרים וספקים שזמינים מ-getProductId() ומ-getVendorId(). אם אתם צריכים לשנות את מיפוי המקשים בהתאם למקשים שזמינים במכשיר, אתם יכולים להשתמש ב-hasKeys(int...) כדי לבדוק אם מקשים מסוימים זמינים.

ממשק משתמש

מצב מסך מלא אימרסיבי

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

סרגלי מידע שקופים למחצה

עכשיו אפשר להפוך את סרגלי המידע לשקופים חלקית באמצעות עיצובים חדשים, Theme.Holo.NoActionBar.TranslucentDecor ו-Theme.Holo.Light.NoActionBar.TranslucentDecor. כשמפעילים סרגלי מידע שקופים, הפריסה ממלאת את האזור שמאחורי סרגלי המידע. לכן, צריך להפעיל את fitsSystemWindows גם בחלק של הפריסה שלא אמור להיות מכוסה על ידי סרגלי המידע.

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

האזנה להתראות משופרות

ב-Android 4.3 נוספו ממשקי ה-API של NotificationListenerService, שמאפשרים לאפליקציות לקבל מידע על התראות חדשות כשהן מתפרסמות על ידי המערכת. ב-Android 4.4, מאזינים להתראות יכולים לאחזר מטא-נתונים נוספים של ההתראה ופרטים מלאים על הפעולות של ההתראה:

השדה החדש Notification.extras כולל Bundle כדי לספק לבונה ההתראות מטא-נתונים נוספים כמו EXTRA_TITLE ו-EXTRA_PICTURE. הכיתה החדשה Notification.Action מגדירה את המאפיינים של פעולה שמצורפת להתראה, שאפשר לאחזר מהשדה החדש actions.

שיקוף של רכיבים גרפיים בפריסות מימין לשמאל (RTL)

בגרסאות קודמות של Android, אם האפליקציה כוללת תמונות שצריך להפוך את הכיוון האופקי שלהן בפריסות מימין לשמאל, צריך לכלול את התמונה ההפוכה בספריית משאבים מסוג drawables-ldrtl/. עכשיו המערכת יכולה להפוך תמונות באופן אוטומטי. כדי לעשות את זה, צריך להפעיל את המאפיין autoMirrored בפריט גרפי שניתן להזזה או להפעיל את setAutoMirrored(). כשההגדרה הזו מופעלת, ה-Drawable משתקף באופן אוטומטי כשכיוון הפריסה הוא מימין לשמאל.

נגישות

הכיתה View מאפשרת עכשיו להצהיר על "אזורים פעילים" בחלקים של ממשק המשתמש שמתעדכנים באופן דינמי עם תוכן טקסט חדש, על ידי הוספת המאפיין החדש accessibilityLiveRegion לפריסת ה-XML או קריאה ל-setAccessibilityLiveRegion(). לדוגמה, מסך התחברות עם שדה טקסט שמוצגת בו ההתראה "סיסמה שגויה" צריך להיות מסומן כאזור פעיל (live region), כדי שקורא המסך יקריא את ההודעה כשהיא משתנה.

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

הרשאות לאפליקציה

אלה ההרשאות החדשות שהאפליקציה צריכה לבקש באמצעות התג <uses-permission> כדי להשתמש בממשקי API חדשים מסוימים:

INSTALL_SHORTCUT
מאפשרת לאפליקציה להתקין קיצור דרך במרכז האפליקציות
UNINSTALL_SHORTCUT
מאפשרת לאפליקציה להסיר קיצור דרך במרכז האפליקציות
TRANSMIT_IR
ההרשאה מאפשרת לאפליקציה להשתמש במשדר האינפרא-אדום של המכשיר, אם הוא זמין

הערה: החל מ-Android 4.4, הפלטפורמה כבר לא דורשת שהאפליקציה תרכוש את WRITE_EXTERNAL_STORAGE או את READ_EXTERNAL_STORAGE כשרוצים לגשת לאזורים הספציפיים לאפליקציה באחסון החיצוני באמצעות שיטות כמו getExternalFilesDir(). עם זאת, עדיין צריך את ההרשאות אם רוצים לגשת לאזורים הניתנים לשיתוף של האחסון החיצוני, שמסופקים על ידי getExternalStoragePublicDirectory().

תכונות המכשיר

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

FEATURE_CONSUMER_IR
המכשיר יכול לתקשר עם מכשירי אינפרה-אדום (IR) לצרכנים.
FEATURE_DEVICE_ADMIN
המכשיר תומך באכיפה של מדיניות המכשיר באמצעות מנהלי מכשירים.
FEATURE_NFC_HOST_CARD_EMULATION
המכשיר תומך באמולציה של כרטיס NFC שמבוססת על מארח.
FEATURE_SENSOR_STEP_COUNTER
המכשיר כולל מונה צעדים פיזי.
FEATURE_SENSOR_STEP_DETECTOR
המכשיר כולל גלאי צעדים בחומרה.

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