בתוך חבילות OTA

המערכת בונה את העדכון הבינארי bootable/recovery/updater ומשתמשת בו בחבילת OTA.

החבילה עצמה היא קובץ .zip ( ota_update.zip , incremental_ota_update.zip ) המכיל את הקובץ הבינארי להפעלה META-INF/com/google/android/update-binary .

Updater מכיל מספר פונקציות מובנות ומתורגמן לשפת סקריפטים הניתנת להרחבה ( edify ) התומכת בפקודות למשימות טיפוסיות הקשורות לעדכון. Updater מחפש בקובץ .zip של החבילה סקריפט בקובץ META-INF/com/google/android/updater-script .

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

תקן תחביר

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

(expr )
 expr + expr  # string concatenation, not integer addition
 expr == expr
 expr != expr
 expr && expr
 expr || expr
 ! expr
 if expr then expr endif
 if expr then expr else expr endif
 function_name(expr, expr,...)
 expr; expr

כל מחרוזת של התווים az, AZ, 0-9, _, :, /, . שאינה מילה שמורה נחשבת למחרוזת מילולית. (מילים שמורות הן אם אחרת אז אנדיפ. ) מילולי מחרוזת עשויות להופיע גם במירכאות כפולות; כך יוצרים ערכים עם רווח לבן ותווים אחרים שאינם בקבוצה שלמעלה. \n, \t, \", ו-\\ משמשים כ-escapes בתוך מחרוזות במירכאות, וכך גם \x ## .

ה-&& ו-|| מפעילים מקצרים; הצד הימני אינו מוערך אם התוצאה הלוגית נקבעת על ידי הצד השמאלי. הדברים הבאים מקבילים:

e1 && e2
if e1 then e2 endif

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

prepare();
do_other_thing("argument");
finish_up();

פונקציות מובנות

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

abort([ msg ])

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

assert( expr [, expr , ...])

מעריך כל expr בתורו. אם אחד מהם הוא שקר, מבטל מיד את הביצוע עם ההודעה "assert failed" וטקסט המקור של הביטוי שנכשל.

apply_patch( src_file , tgt_file , tgt_sha1 , tgt_size , patch1_sha1 , patch1_blob , [...])

מחיל תיקון בינארי על src_file כדי לייצר את tgt_file . אם היעד הרצוי זהה למקור, העבר "-" עבור tgt_file . tgt_sha1 ו- tgt_size הם הגיבוב הסופי של SHA1 וגודל קובץ היעד הצפוי. הארגומנטים הנותרים חייבים לבוא בזוגות: hash SHA1 (מחרוזת hex של 40 תווים) ו-blob. הכתם הוא התיקון שיש להחיל כאשר לתוכן הנוכחי של קובץ המקור יש את ה-SHA1 הנתון.

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

תחביר מיוחד נתמך כדי להתייחס לתוכן של מחיצות התקן זיכרון (MTD) כקבצים, מה שמאפשר תיקון של מחיצות גולמיות כגון אתחול. כדי לקרוא מחיצת MTD, עליך לדעת כמה נתונים אתה רוצה לקרוא מכיוון שלמחיצה אין מושג של סוף קובץ. אתה יכול להשתמש במחרוזת "MTD: partition : size_1 : sha1_1 : size_2 : sha1_2 " כשם קובץ כדי לקרוא את המחיצה הנתונה. עליך לציין לפחות זוג אחד (גודל, sha-1) ; אתה יכול לציין יותר מאחד אם ישנן אפשרויות מרובות למה שאתה מצפה לקרוא.

apply_patch_check( filename , sha1 [, sha1 , ...])

מחזירה true אם לתוכן של שם הקובץ או לעותק הזמני במחיצת המטמון (אם קיים) יש סכום ביקורת SHA1 השווה לאחד מערכי sha1 הנתונים. ערכי sha1 מצוינים כ-40 ספרות hex. פונקציה זו שונה מ- sha1_check(read_file( filename ), sha1 [, ...]) בכך שהיא יודעת לבדוק את עותק מחיצת המטמון, כך ש- apply_patch_check() יצליח גם אם הקובץ נפגם על ידי apply_patch() update שנקטע.

apply_patch_space( bytes )

מחזירה true אם לפחות בתים של שטח בסיס זמין להחלת תיקונים בינאריים.

concat( expr [, expr , ...])

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

file_getprop( filename , key )

קורא את שם הקובץ הנתון, מפרש אותו כקובץ מאפיינים (למשל /system/build.prop ), ומחזיר את הערך של המפתח הנתון, או את המחרוזת הריקה אם המפתח אינו קיים.

format( fs_type , partition_type , location , fs_size , mount_point )

פורמט מחדש מחיצה נתונה. סוגי מחיצות נתמכים:

• fs_type="yaffs2" ו- partition_type="MTD". המיקום חייב להיות שם מחיצת ה-MTD; נבנית שם מערכת קבצים ריקה של yaffs2. הטיעונים הנותרים אינם בשימוש.
• fs_type="ext4" ו-partition_type="EMMC". המיקום חייב להיות קובץ המכשיר עבור המחיצה. נבנית שם מערכת קבצים ריקה של ext4. אם fs_size הוא אפס, מערכת הקבצים תופסת את כל המחיצה. אם fs_size הוא מספר חיובי, מערכת הקבצים לוקחת את הבייטים fs_size הראשונים של המחיצה. אם fs_size הוא מספר שלילי, מערכת הקבצים לוקחת הכל מלבד |fs_size| האחרון בתים של המחיצה.
• fs_type="f2fs" ו- partition_type="EMMC". המיקום חייב להיות קובץ המכשיר עבור המחיצה. fs_size חייב להיות מספר לא שלילי. אם fs_size הוא אפס, מערכת הקבצים תופסת את כל המחיצה. אם fs_size הוא מספר חיובי, מערכת הקבצים לוקחת את הבייטים fs_size הראשונים של המחיצה.
• mount_point צריכה להיות נקודת הטעינה העתידית עבור מערכת הקבצים.

getprop( key )

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

greater_than_int( a , b )

מחזירה אמת אם ורק אם (iff) a (מתפרש כמספר שלם) גדול מ- b (מתפרש כמספר שלם).

ifelse( cond , e1 [, e2 ])

מעריך cond , ואם זה נכון מעריך ומחזיר את הערך של e1 , אחרת הוא מעריך ומחזיר e2 (אם קיים). המבנה "אם ... else ... then ... endif" הוא רק סוכר תחבירי עבור הפונקציה הזו.

is_mounted( mount_point )

מחזירה true אם יש מערכת קבצים נטענת ב- mount_point .

is_substring( needle , haystack )

מחזירה אמת אם מחט היא תת מחרוזת של ערימת שחת .

less_than_int( a , b )

מחזירה true אם a (מתפרש כמספר שלם) קטן מ- b (מתפרש כמספר שלם).

mount( fs_type , partition_type , name , mount_point )

מעלה מערכת קבצים של fs_type ב- mount_point . partition_type חייב להיות אחד מ:

• MTD . שם הוא השם של מחיצת MTD (למשל, מערכת, נתוני משתמש; ראה /proc/mtd במכשיר לרשימה מלאה).
• EMMC.

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

package_extract_dir( package_dir , dest_dir )

מחלץ את כל הקבצים מהחבילה שמתחת ל-package_dir וכותב אותם לעץ המתאים מתחת ל-dest_dir . כל הקבצים הקיימים נמחקים.

package_extract_file( package_file [, dest_file ])

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

read_file( filename )

קורא את שם הקובץ ומחזיר את תוכנו כגוש בינארי.

run_program( path [, arg , ...])

מבצע את הנתיב הבינארי, מעביר arg s. מחזיר את מצב היציאה של התוכנית.

set_progress( frac )

מגדיר את המיקום של מד ההתקדמות בתוך הנתח שהוגדר על ידי הקריאה האחרונה show_progress() . frac חייב להיות בטווח [0.0, 1.0]. מד ההתקדמות לעולם אינו זז לאחור; מתעלמים מניסיונות לגרום לזה לעשות זאת.

sha1_check( blob [, sha1 ])

הארגומנט blob הוא בלוק מהסוג המוחזר על ידי read_file() או הצורה בעלת ארגומנט אחד של package_extract_file() . ללא ארגומנטים sha1 , פונקציה זו מחזירה את ה-hash SHA1 של ה-blob (כמחרוזת hex בת 40 ספרות). עם ארגומנט sha1 אחד או יותר, פונקציה זו מחזירה את ה-hash SHA1 אם הוא שווה לאחד מהארגומנטים, או את המחרוזת הריקה אם היא לא שווה לאף אחד מהם.

show_progress( frac , secs )

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

sleep( secs )

שינה למשך שניות שניות (חייב להיות מספר שלם).

stdout( expr [, expr , ...])

מעריך כל ביטוי ומשליך את הערך שלו ל-stdout. שימושי לניפוי באגים.

tune2fs( device [, arg , …])

כוונון ארג'ים של פרמטרים הניתנים לשינוי במכשיר .

ui_print([ text , ...])

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

unmount( mount_point )

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

wipe_block_device( block_dev , len )

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

wipe_cache()

גורם למחיקת מחיצת המטמון בתום התקנה מוצלחת.

write_raw_image( filename_or_blob , partition )

כותב את התמונה ב- filename_or_blob למחיצת MTD. filename_or_blob יכול להיות מחרוזת הנותנת שם לקובץ מקומי או ארגומנט בעל ערך כתם המכיל את הנתונים לכתיבה. כדי להעתיק קובץ מחבילת OTA למחיצה, השתמש ב: write_raw_image(package_extract_file("zip_filename"), "partition_name");

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