דף זה תורגם על ידי Cloud Translation API.

פורמט הפעלה מסוג Dalvik

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

מדריך לסוגים

שם	תיאור
בייט	חשבון שמחובר לחשבון 8 ביט
בייט	חיבור לא חתום של 8 ביט
סרטון קצר	כניסת 16 ביט, Small-endian
Ushort	16-bit unsigned int, Little-endian
INT	חיבור 32 ביט מחובר, דלת קטנה
Uint	32 -bit unsigned int, Little-endian
ארוך	64-bit, חיבור קליטה, Littleendian
אולונג	64 -bit unsigned int, Little-endian
sleb128	LEB128 חתום, אורך משתנה (ראו בהמשך)
uleb128	LEB128 לא חתום, אורך-משתנה (ראו בהמשך)
uleb128p1	LEB128 לא חתום בתוספת `1`, אורך משתנה (ראו בהמשך)

LEB128

LEB128 ("Little-Endian Base 128") הוא קידוד באורך משתנה עבור כמויות של מספרים שלמים שרירותיים או לא חתומים הפורמט היה מושאל מ-DWARF3 למפרט. בקובץ .dex, ה-LEB128 משמש רק לצורך לקודד כמויות של 32 ביט.

כל ערך בקידוד LEB128 מורכב מאחד עד חמישה בייטים, שמייצגים יחד ערך יחיד של 32 סיביות. כל אחד בייט כולל את הביטים המשמעותיים ביותר מלבד הבייט הסופי שהביט המשמעותי ביותר שלו ברור. השאר שבעה ביטים מכל בייט הם מטען ייעודי (payload), כשהמשמעות היא לפחות 7 בבייט של הכמות בבייט הראשון, השבע הבא בבייט בייט וכן הלאה. במקרה של LEB128 חתום (sleb128), ביט המטען הייעודי (payload) המשמעותי ביותר בבייט הסופי ברצף הוא מותאם אישית כדי להפיק את הערך הסופי. בפנייה שאינה חתומה (uleb128), ביטים שלא מיוצגים באופן מפורש מבוטאת כ-0.

תרשים ביטי של ערך LEB128 של שני בייטים
בייט ראשון								בייט שני
`1`	ביט₆	ביט₅	ביט₄	ביט₃	ביט₂	ביט₁	ביט₀	`0`	ביט₁₃	ביט₁₂	ביט₁₁	ביט₁₀	ביט₉	ביט₈	ביט₇

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

לפניכם כמה דוגמאות לפורמטים:

רצף מקודד	בתור `sleb128`	בתור `uleb128`	בתור `uleb128p1`
00	0	0	-1
01	1	1	0
7f	-1	127	126
80 7f	-128	16256	16255

פריסת הקבצים

שם	פורמט	תיאור
כותרת	כותרת_פריט	הכותרת
string_id	string_id_item[]	רשימה של מזהי מחרוזות. המזהים האלה כוללים את כל המחרוזות שמשמש את הקובץ הזה, למתן שמות פנימיים (למשל, תיאורי סוג) או כאובייקטים קבועים שנקראים באמצעות קוד. צריך למיין את הרשימה הזו לפי תוכן המחרוזת, באמצעות ערכי נקודות קוד בתקן UTF-16 (לא תלוית לוקאל), והיא לא יכולה להכיל ערכים כפולים.
type_ids	type_id_item[]	רשימה של מזהי סוגים. אלה מזהים לכל הסוגים (מחלקות, מערכים וסוגים פרימיטיביים שהקובץ הזה מתייחס אליהם, בין שהם מוגדרים שבקובץ או לא. צריך למיין את הרשימה הזו לפי `string_id` והוא לא יכול להכיל ערכים כפולים.
מזהי_proto_id	proto_id_item[]	רשימה של מזהים של אב טיפוס. אלה המזהים של כל המשתמשים אבות טיפוס שהקובץ הזה מפנה אליהם. חובה למיין את הרשימה הזו לפי סוג החזרה (לפי אינדקס `type_id`) סדר ראשי, ולאחר מכן לפי רשימת ארגומנטים (סדר לקסיקוגרפי, ארגומנטים נפרדים מסודר לפי אינדקס `type_id`). אסור להשתמש ברשימה מכילים רשומות כפולות.
מזהי_שדות	Field_id_item[]	רשימה של מזהי שדות. אלה המזהים בכל השדות שאליו מתייחס קובץ זה, גם אם הוא מוגדר בקובץ וגם אם לא. הזה צריך למיין את הרשימה, כאשר הסוג המגדיר (על ידי `type_id`) אינדקס) הוא הסדר הראשי, שם השדה (לפי אינדקס `string_id`) הוא סדר הביניים והסוג (לפי אינדקס `type_id`) הוא הסדר המשני. אסור לכלול ברשימה ערכים כפולים.
method_id	method_id_item[]	של ה-method הזה. אלה המזהים לכל השיטות שאליו מתייחס קובץ זה, גם אם הוא מוגדר בקובץ וגם אם לא. הזה צריך למיין את הרשימה, כאשר הסוג המגדיר (על ידי `type_id`) אינדקס) הוא הסדר הראשי, שם השיטה (של `string_id`) אינדקס) הוא סדר הביניים, ואב-טיפוס של השיטה (לפי אינדקס `proto_id`) הוא הסדר המשני. אסור להשתמש ברשימה מכילים רשומות כפולות.
class_defs	class_def_item[]	רשימה של הגדרות הכיתה. צריך לסדר את המחלקות כך מחלקה-העל והממשקים המוטמעים של המחלקה מופיעים מופיעה לפני המחלקה המפנה. בנוסף, היא לא חוקית עבור הגדרה של אותה מחלקה בעלת שם זהה להופיע יותר מפעם אחת לרשימה.
call_site_ids	call_site_id_item[]	רשימה של מזהי אתרים להתקשרות. אלה המזהים של כל אתרי השיחות שאליו מתייחס קובץ זה, גם אם הוא מוגדר בקובץ וגם אם לא. הרשימה הזו חייבות להיות ממוינות בסדר עולה של `call_site_off`.
method_handles	method_handle_item[]	לרשימת כינויים של ה-methods. רשימה של כל הכינויים של ה-method שהקובץ הזה מפנה אליהם, אם הם מוגדרים בקובץ או לא. הרשימה הזו לא ממוינת ועשויה להכיל עותקים כפולים שיהיו תואמים באופן לוגי למופעים שונים של כינויי שיטות.
נתונים	ubyte[]	אזור נתונים, שמכיל את כל נתוני התמיכה מהטבלאות שצוינו למעלה. לפריטים שונים יש דרישות התאמה שונות, אנחנו מוסיפים בייטים ריקים לפני כל פריט, אם יש צורך בכך יישור נכון.
נתונים של קישור [link_data]	ubyte[]	בשימוש בקבצים שמקושרים באופן סטטי. פורמט הנתונים הקטע לא מוגדר במסמך הזה. הקטע הזה ריק בקבצים לא מקושרים ובהטמעות של סביבת זמן ריצה יכולים להשתמש בהם לפי הצורך.

Bitfield, מחרוזת והגדרות קבועות

DEX_FILE_MAGIC

מוטמע ב-header_item

המערך הקבוע/מחרוזת DEX_FILE_MAGIC הוא רשימה של בייטים שחייבים להופיע בתחילת קובץ .dex כדי שהוא יזוהה ככזה. הערך מכוון מכיל שורה חדשה ("\n" או 0x0a) ו- null בייט ("\0" או 0x00) כדי לעזור בזיהוי סוגים מסוימים של שחיתות. הערך גם שמקודד מספר גרסה בפורמט של שלוש ספרות אחרי הנקודה העשרונית, צפויה לגדול באופן מונוטוני עם הזמן ככל שהפורמט ישתנה.

ubyte[8] DEX_FILE_MAGIC = { 0x64 0x65 0x78 0x0a 0x30 0x33 0x39 0x00 }
                        = "dex\n039\0"

הערה: תמיכה בגרסה 039 של נוסף לגרסת Android 9.0, שבה הוצגו בייטקודים חדשים, const-method-handle ו const-method-type (כל המילים האלה מפורטות סיכום של קבוצת בייטים טבלה.) ב-Android 10, גרסה 039 מרחיבה את פורמט הקובץ DEX כך שיכלול תוכן מוסתר מידע על ממשק ה-API שרלוונטי רק לקובצי DEX בנתיב של קטגוריית האתחול.

הערה: תמיכה בגרסאות 038 מהפורמט נוסף ל-Android 8.0 גרסה חדשה. גרסה 038 הוסיפה בייטקודים חדשים (invoke-polymorphic ו-invoke-custom) וגם לנתוני כינויים של ה-method.

הערה: תמיכה בגרסה 037 של הפורמט נוסף בגרסת Android 7.0. לפני גרסה 037 רוב גרסאות Android משתמשות בגרסה 035 של הפורמט. היחיד ההבדל בין גרסה 035 לגרסה 037 הוא נוספות של שיטות ברירת מחדל וההתאמה של invoke.

הערה: לפחות בכמה גרסאות קודמות של הפורמט נמצאים בשימוש בגרסאות תוכנה שזמינות לציבור הרחב. לדוגמה, גרסה 009 שימשה לגרסאות M3 של בפלטפורמת Android (נובמבר עד דצמבר 2007), והגרסה 013 שימשו בגרסאות M5 של Android (פברואר-מרץ 2008). מבחינות רבות, ההגדרות האלה הגרסאות של הפורמט שונות באופן משמעותי מהגרסה שמתוארת כאן מהמסמך.

ENDIAN_CONSTANT ו-REVERSE_ENDIAN_CONSTANT

מוטמע ב-header_item

הקבוע ENDIAN_CONSTANT משמש לציון הסופיות של הקובץ שבו הוא נמצא. למרות שהמודל הפורמט .dex הוא קטן מאוד, ואפשר לבחור הטמעות כדי לבצע החלפה בין בייטים. אם הטמעה נתקלת הכותרת שהendian_tag שלה הוא REVERSE_ENDIAN_CONSTANT במקום ENDIAN_CONSTANT, הוא יודע שהקובץ הוחלפה מהפורמט הצפוי.

uint ENDIAN_CONSTANT = 0x12345678;
uint REVERSE_ENDIAN_CONSTANT = 0x78563412;

NO_INDEX

מוטמע ב-class_def_item וב-debug_info_item

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

הערה: הערך הזה לא מוגדר כך 0, כי בדרך כלל זהו אינדקס חוקי.

הערך שנבחר עבור NO_INDEX הוא כבייט יחיד בקידוד uleb128p1.

uint NO_INDEX = 0xffffffff;    // == -1 if treated as a signed int

הגדרות access_flags

מוטמעים ב-class_def_item , encoded_field , encoded_method וב- מחלקה פנימית

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

שם	ערך	לכיתות (ו-`InnerClass` הערות)	לשדות	ל-methods
ACC_PUBLIC	0x1	`public`: גלוי בכל מקום	`public`: גלוי בכל מקום	`public`: גלוי בכל מקום
ACC_private	0x2	* `private`: גלוי רק להגדרת הכיתה	`private`: גלוי רק להגדרת הכיתה	`private`: גלוי רק להגדרת הכיתה
ACC_PROTECTED	0x4	* `protected`: גלוי לחבילה ולמחלקות המשנה	`protected`: גלוי לחבילה ולמחלקות המשנה	`protected`: גלוי לחבילה ולמחלקות המשנה
ACC_ctaIC	0x8	* `static`: לא בנוי עם קצה חיצוני מסמך עזר של `this`	`static`: גלובלי להגדרת כיתה	`static`: לא מקבל ארגומנט `this`
ACC_FINAL	0x10	`final`: לא ניתן לסיווג משני	`final`: לא ניתן לשינוי אחרי עבודות הבנייה	`final`: לא ניתן לשינוי
ACC_SYNCHRONIZED	0x20			`synchronized`: הנעילה המשויכת נוצרה באופן אוטומטי קריאה לשיטה הזו. הערה:האפשרות הזו תקפה רק כאשר גם השדה `ACC_NATIVE` מוגדר.
ACC_VOLATILE	0x40		`volatile`: כללי גישה מיוחדים לעזרה בשרשור סייפטי
ACC_BRIDGE	0x40			ברידג', שנוספה באופן אוטומטי על ידי מהדר כבטוחה לסוג גשר
ACC_TRANSIENT	0x80		`transient`: לא להישמר כברירת מחדל,
ACC_VARARGS	0x80			צריך להתייחס לארגומנט האחרון בתור 'מנוחה' ארגומנט לפי מהדר
ACC_NATIVE	0x100			`native`: הוטמע בקוד מקורי
ACC_INTERFACE	0x200	`interface`: מחלקה מופשטת שאפשר להטמיע בה הכפלה
ACC_ABSTRACT (ACC_ABSTRACT)	0x400	`abstract`: לא ניתן לזיהוי באופן ישיר		`abstract`: לא הוטמע בכיתה הזו
ACC_STRICT	0x800			`strictfp`: כללים מחמירים לחשבון מסוג נקודה צפה (floating-point)
ACC_SYNTHETIC	0x1,000	לא מוגדרים ישירות בקוד המקור	לא מוגדרים ישירות בקוד המקור	לא מוגדרים ישירות בקוד המקור
ACC_ עלות	0x2,000	הוצהר כסוג הערות
ACC_ENUM	0x4,000	מוצהר כסוג של ספירה	מוצהר כערך מפוצל
(לא בשימוש)	0x8,000
ACC_CONSTRUCTOR	0x10,000			constructor (מאתחל מחלקה או מכונה)
ACC_DECLARED_ SYNCHRONIZED	0x20,000			הוצהר על ידי `synchronized`. הערה: אין לכך השפעה על לביצוע (חוץ מאשר בתיאור של הדגל הזה, כשלעצמו).

* מותר רק ב-InnerClass הערות, והיא לא יכולה לפעול אף פעם בclass_def_item.

קידוד UTF-8 שעבר שינוי

כהנחה על תמיכה קלה יותר מדור קודם, הפורמט .dex מקודד את נתוני המחרוזת בפורמט UTF-8 שעבר שינוי בפועל, כפי שמפורט בהמשך נקרא MUTF-8. הטופס הזה זהה לתקן UTF-8 הסטנדרטי, חוץ מאשר:

נעשה שימוש רק בקידוד של בייט אחד, שני ושלושה בייטים.
קוד הנקודות בטווח U+10000 ... U+10ffff מקודדים בזוג סורוגיט, כל אחד שמיוצג כערך מקודד בן שלושה בייטים.
נקודת הקוד U+0000 מקודדת בפורמט של שני בייטים.
בייט null פשוט (ערך 0) מציין את הסוף מחרוזת, כמו בפירוש השפה הרגילה של C.

אפשר לסכם את שני הפריטים הראשונים שלמעלה כך: MUTF-8 הוא פורמט קידוד ל-UTF-16, במקום להיות ישיר יותר לתווי Unicode.

שני הפריטים האחרונים שלמעלה מאפשרים לכלול בו-זמנית נקודת הקוד U+0000 במחרוזת ועדיין משפיעה אותו כמחרוזת עם סיום null בסגנון C.

אבל הקידוד המיוחד של U+0000 פירושו שבניגוד ל: בקידוד UTF-8 רגיל, התוצאה של קריאה לפונקציית C הרגילה הערך strcmp() בצמד מחרוזות MUTF-8 לא תמיד פועל מציינות את התוצאה שחתומה כראוי של השוואה בין מחרוזות לא שוות. כאשר הזמנה (לא רק שוויון) מדאיגה, הדרך הישירה ביותר הדרך שבה להשוות מחרוזות MUTF-8 היא לפענח אותן תו אחרי תו, ומשווים את הערכים המפוענחים. (עם זאת, הטמעות חכמות יותר גם אפשרית).

אפשר לקרוא מידע נוסף במסמך Unicode Standard לקבלת מידע נוסף על קידוד תווים. למעשה, MUTF-8 קרוב יותר לקידוד (פחות ידוע) CESU-8 מאשר ל-UTF-8 כשלכם.

קידוד_code_value

מוטמע ב-note_element וב-encoded_array_item

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

שם	פורמט	תיאור
(value_arg << 5) \| value_type [סוג_ערך]	בייט	בייט שמציין את הסוג של הקריאה המיידית `value` לאורך עם ארגומנט אופציונלי להבהרת שלושת הביטים בסדר הגבוה. בהמשך מוצגות ההגדרות השונות של `value`. ברוב המקרים, `value_arg` מקודד את האורך את `value` בבייטים שמופיע מיד אחריו, כפי `(size - 1)`, לדוגמה המשמעות של `0` נדרש בייט אחד, והמשמעות של `7` היא שמונה בייטים; עם זאת, יש מקרים חריגים, כפי שמתואר בהמשך.
ערך	ubyte[]	בייטים שמייצגים את הערך, באורך של משתנה באורך ובמפוענח אבל ל-`value_type` בייטים שונים קטן תמיד. אלה הגדרות הערכים השונות: פרטים.

פורמטים של ערכים

שם הסוג	`value_type`	פורמט של `value_arg`	פורמט של `value`	תיאור
VALUE_BYTE	0x00	(ללא; חייב להיות `0`)	ubyte[1]	ערך של מספר שלם חתום בבייט אחד
ערך_Shorts	0x02	size - 1 (0...1)	ubyte[size]	ערך של מספר שלם חתום בשני בייטים, סימן מורחב
VALUE_CHAR	0x03	size - 1 (0...1)	ubyte[size]	ערך לא חתום של מספר שלם בן שני בייטים, אפס מורחב
ערך_INT	0x04	size - 1 (0...3)	ubyte[size]	ערך של מספר שלם בעל 4 בייטים חתום, sign-extend
ערך_ארוך	0x06	size - 1 (0...7)	ubyte[size]	מספר שלם בעל שמונה בייטים, סימן מורחב
VALUE_FLOAT	0x10	size - 1 (0...3)	ubyte[size]	תבנית של ארבעה בייטים, אפס מורחבת ימינה, וגם מוגדר כערך IEEE754 של נקודה צפה (floating-point) של 32 ביט
מחיר_מכפלה	0x11	size - 1 (0...7)	ubyte[size]	תבנית של שמונה בייטים, אפס מורחבת ימינה, וגם מפורשות כערך IEEE754 של נקודה צפה (floating-point) של 64 ביט
VALUE_METHOD_TYPE	0x15	size - 1 (0...3)	ubyte[size]	ערך מספר שלם בן ארבעה בייטים לא חתום (zero-extended), מפורשות כאינדקס הקטע `proto_ids`, ומייצג ערך של סוג שיטה
VALUE_METHOD_HANDLE	0x16	size - 1 (0...3)	ubyte[size]	ערך מספר שלם בן ארבעה בייטים לא חתום (zero-extended), מפורשות כאינדקס הקטע `method_handles` ומייצג ערך של כינוי שיטה
ערך מוצע (VALUE_STRING)	0x17	size - 1 (0...3)	ubyte[size]	ערך מספר שלם בן ארבעה בייטים לא חתום (zero-extended), מפורשות כאינדקס הקטע `string_ids` ומייצג ערך מחרוזת
VALUE_TYPE	0x18	size - 1 (0...3)	ubyte[size]	ערך מספר שלם בן ארבעה בייטים לא חתום (zero-extended), מפורשות כאינדקס את הקטע `type_ids`, ומייצג אפקט משקף ערך סוג/סיווג
VALUE_FIELD	0x19	size - 1 (0...3)	ubyte[size]	ערך מספר שלם בן ארבעה בייטים לא חתום (zero-extended), מפורשות כאינדקס את הקטע `field_ids`, ומייצג אפקט משקף ערך השדה
VALUE_METHOD	0x1a	size - 1 (0...3)	ubyte[size]	ערך מספר שלם בן ארבעה בייטים לא חתום (zero-extended), מפורשות כאינדקס את הקטע `method_ids`, ומייצג אפקט משקף ערך method
VALUE_ENUM	0x1b	size - 1 (0...3)	ubyte[size]	ערך מספר שלם בן ארבעה בייטים לא חתום (zero-extended), מפורשות כאינדקס את הקטע `field_ids`, ומייצגים את הערך של קבוע מסוג ספירה
VALUE_ARRAY	0x1c	(ללא; חייב להיות `0`)	מערך_מקודד	מערך של ערכים, בפורמט שנקבע על ידי 'פורמט `encoded_array`' שלמטה. הגודל של `value` משתמעת מהקידוד.
VALUE_Play	0x1 ימים	(ללא; חייב להיות `0`)	קידוד_annotation	הערת משנה, בפורמט שצוין על ידי 'פורמט `encoded_annotation`' שלמטה. הגודל של `value` משתמעת מהקידוד.
VALUE_NULL	0x1e	(ללא; חייב להיות `0`)	(ללא)	ערך ההפניה של `null`
VALUE_BOOLEAN	0x1f	בוליאני (0...1)	(ללא)	ערך ביט אחד; `0` למשך `false` ו- `1` ל-`true`. הסיבית מיוצגת `value_arg`

פורמט מקודד_מערך

שם	פורמט	תיאור
מידה	uleb128	מספר הרכיבים במערך
ערכים	קידוד_value[size]	סדרה של `size` בייטים `encoded_value` בפורמט שצוין בקטע הזה, משורשרים ברצף.

פורמט קידוד_annotation

שם	פורמט	תיאור
type_idx	uleb128	סוג ההערה. זו חייבת להיות מחלקה (לא מערך או פרימיטיבי) מהסוג הזה.
מידה	uleb128	מספר המיפויים של שם-ערך בהערה הזו
רכיבים	Note_element[size]	של ההערה, שמיוצגים ישירות בשורה קיזוזים). יש למיין את הרכיבים בסדר הולך וגדל לפי אינדקס `string_id`.

פורמט Note_element

שם	פורמט	תיאור
name_idx	uleb128	שם הרכיב, שמיוצג כאינדקס קטע בנושא `string_ids`. המחרוזת צריכה להתאים לפורמט לתחביר MemberName, שמוגדר למעלה.
ערך	מקודד_value	ערך רכיב

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

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

שם פשוט

SimpleName הוא הבסיס לתחביר של השמות דברים. הפורמט .dex מאפשר מידה סבירה של רוחב (הרבה יותר משפות המקור הנפוצות ביותר). בקיצור, מורכב מתווים או ספרות בעלי תווי ASCII נמוכים, סמלים ספציפיים של ASCII, ורוב נקודות הקוד שאינן ASCII שליטה, רווח או תווים מיוחדים. החל מגרסה 040 הפורמט מאפשר גם תווי רווח (Unicode Zs) קטגוריה). הערה: נקודות קוד זמניות (בטווח U+d800 ... U+dfff) אינם נחשבים לתווי שמות חוקיים, אך ורק לתווי Unicode התווים הם חוקיים (המיוצגים על ידי התו הוא חלופה לכלל של SimpleNameChar), והוא צריך להיות מיוצגים בקובץ כזוגות של נקודות קוד ממלאכים ב-MUTF-8 באמצעות הקידוד.

SimpleName ←
	SimpleNameChar (SimpleNameChar)*
SimpleNameChar ←
	`'A'` ... `'Z'`
\|	`'a'` ... `'z'`
\|	`'0'` ... `'9'`
\|	`' '`	החל מגרסה 040 של DEX
\|	`'$'`
\|	`'-'`
\|	`'_'`
\|	`U+00a0`	החל מגרסה 040 של DEX
\|	`U+00a1` ... `U+1fff`
\|	`U+2000` ... `U+200a`	החל מגרסה 040 של DEX
\|	`U+2010` ... `U+2027`
\|	`U+202f`	החל מגרסה 040 של DEX
\|	`U+2030` ... `U+d7ff`
\|	`U+e000` ... `U+ffef`
\|	`U+10000` ... `U+10ffff`

שם חבר

בשימוש על ידי Field_id_item ו-method_id_item

MemberName הוא השם של חבר בכיתה, שהחברים בו שדות, methods ומחלקות פנימיות.

MemberName ←
	SimpleName
\|	`'<'` SimpleName `'>'`

שם מלא

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

FullClassName ←
	OptionalPackagePrefix SimpleName
OptionalPackagePrefix ←
	(SimpleName `'/'`)*

TypeDescriptor

בשימוש על ידי type_id_item

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

TypeDescriptor ←
	`'V'`
\|	FieldTypeDescriptor
FieldTypeDescriptor ←
	NonArrayFieldTypeDescriptor
\|	(`'['` * 1...255) NonArrayFieldTypeDescriptor
NonArrayFieldTypeDescriptor←
	`'Z'`
\|	`'B'`
\|	`'S'`
\|	`'C'`
\|	`'I'`
\|	`'J'`
\|	`'F'`
\|	`'D'`
\|	`'L'` FullClassName `';'`

תיאור קצר

בשימוש על ידי proto_id_item

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

ShortyDescriptor ←
	ShortyReturnType (ShortyFieldType)*
ShortyReturnType ←
	`'V'`
\|	ShortyFieldType
ShortyFieldType ←
	`'Z'`
\|	`'B'`
\|	`'S'`
\|	`'C'`
\|	`'I'`
\|	`'J'`
\|	`'F'`
\|	`'D'`
\|	`'L'`

סמנטיקה של TypeDescriptor

זוהי המשמעות של כל אחת מהווריאציות של TypeDescriptor.

תחביר	משמעות
V	`void`; תקף רק לסוגי החזרה
Z	`boolean`
B	`byte`
S	`short`
C	`char`
I	`int`
J	`long`
F	`float`
D	`double`
Lwide/certified/Name;	הכיתה `fully.qualified.Name`
[תיאור	מערך של `descriptor`, אפשר להשתמש בו באופן רקורסיבי מערכים של מערכים, למרות שהוא לא חוקי כך שיש בו יותר מ-255 מאפיינים.

פריטים ומבנים קשורים

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

כותרת_פריט

מופיעה בקטע הכותרת

יישור: 4 בייטים

שם	פורמט	תיאור
קסם	ubyte[8] = DEX_FILE_MAGIC	ערך קסום. ניתן לעיין בדיון שלמעלה בקטע "`DEX_FILE_MAGIC`" אפשר לקבל פרטים נוספים.
סיכום ביקורת (checksum)	Uint	בדיקת סיכום הביקורת (checksum) adler32 של שאר הקובץ (כל דבר מלבד `magic` והשדה הזה); משמש לזיהוי פגיעה בקובץ
חתימה	ubyte[20]	חתימת SHA-1 (גיבוב) של שאר הקובץ (כל מה מלבד `magic`, `checksum` והשדה הזה); בשימוש כדי לזהות קבצים באופן ייחודי
file_size [גודל_קובץ]	Uint	גודל הקובץ כולו (כולל הכותרת), בבייטים
title_size [גודל_כותרת]	uint = 0x70	גודל הכותרת (כל הקטע), בבייטים. המצב הזה מאפשר לפחות מידה מוגבלת של תאימות אחורה/קדימה, ביטול התוקף של הפורמט.
endian_tag	uint = ENDIAN_CONSTANT	של ה-endianness. אפשר לעיין בדיון שלמעלה, בקטע "`ENDIAN_CONSTANT`" ו-`REVERSE_ENDIAN_CONSTANT` אינץ' אפשר לקבל פרטים נוספים.
link_size [גודל_קישור]	Uint	גודל קטע הקישור, או `0` אם הקובץ הזה לא מקושר באופן סטטי
link_off [קישור]	Uint	לקזז מתחילת הקובץ לקטע הקישור, או `0` אם `link_size == 0`. הקיזוז, אם הוא לא אפס, צריכים להיות לקיזוז בקטע `link_data`. הפורמט של הנתונים שמפנים אליהם לא מוגדר במסמך הזה. את שדה הכותרת הזה (ואת השדה הקודם) נשארים כהוקים (hooks) לשימוש על ידי של סביבת זמן ריצה.
Map_off	Uint	לקזז מתחילת הקובץ לפריט במפה. את הקיזוז, שחייב לא אפס, צריך להיות קיזוז לקטע `data`, והנתונים צריכים להיות בפורמט שצוין על ידי "`map_list`" שלמטה.
string_ids_size [גודל_המחרוזת]	Uint	מספר המחרוזות ברשימה של מזהי המחרוזת
string_ids_off.	Uint	לקזז מתחילת הקובץ לרשימת מזהי המחרוזת, או `0` אם `string_ids_size == 0` ( עם קצה מוזר). הקיזוז, אם הוא לא אפס, צריך להיות בתחילת הקטע `string_ids`.
type_ids_size [גודל_המזהה]	Uint	מספר הרכיבים ברשימת מזהי הסוגים, 65535 לכל היותר
type_ids_off.	Uint	לקזז מתחילת הקובץ לרשימת מזהי הסוגים, או `0` אם `type_ids_size == 0` ( עם קצה מוזר). הקיזוז, אם הוא לא אפס, צריך להיות בתחילת `type_ids` .
proto_ids_size	Uint	מספר הרכיבים ברשימת מזהי האב טיפוס, 65535 לכל היותר
proto_ids_off	Uint	לקזז מתחילת הקובץ לרשימת המזהים של אב הטיפוס, או `0` אם `proto_ids_size == 0` ( עם קצה מוזר). הקיזוז, אם הוא לא אפס, צריך להיות בתחילת `proto_ids` .
Field_ids_size (גודל_שדה_מזהה)	Uint	מספר הרכיבים ברשימה של מזהי השדות
Field_ids_off (מזהה_שדה שדה)	Uint	לקזז מתחילת הקובץ לרשימת מזהי השדות, או `0` אם `field_ids_size == 0`. הקיזוז, אם שאינו אפס, צריך להיות בתחילת `field_ids` .
method_id_size	Uint	מספר הרכיבים ברשימה של מזהי ה-method
method_id_off	Uint	לקזז מתחילת הקובץ לרשימת מזהי ה-method, או `0` אם `method_ids_size == 0`. הקיזוז, אם שאינו אפס, צריך להיות בתחילת `method_ids` .
class_defs_size (גודל מחלקה)	Uint	מספר הרכיבים ברשימת הגדרות הכיתה
class_defs_off	Uint	לקזז מתחילת הקובץ לרשימת הגדרות הכיתה, או `0` אם `class_defs_size == 0` ( עם קצה מוזר). הקיזוז, אם הוא לא אפס, צריך להיות בתחילת הקטע `class_defs`.
גודל_נתונים	Uint	הגודל של קטע `data` בבייטים. חייב להיות שווה מכפלה של גודל(uint).
data_off (כיבוי נתונים)	Uint	מתחילת הקובץ עד להתחלה קטע בנושא `data`.

רשימת_מיפוי

מופיע בקטע הנתונים

הוזכר מ-header_item

יישור: 4 בייטים

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

שם	פורמט	תיאור
מידה	Uint	גודל הרשימה, ברשומות
רשימה	map_item[size]	רכיבים ברשימה

פורמט פרטי_מפה

שם	פורמט	תיאור
סוג	Ushort	סוג הפריטים. ראו טבלה בהמשך
unused	Ushort	(לא בשימוש)
מידה	Uint	מספר הפריטים שיימצאו בקיזוז שצוין
לקזז	Uint	לקזז מתחילת הקובץ לפריטים הרלוונטיים

הזנת קודים

סוג הפריט	קבוע	ערך	גודל הפריט בבייטים
כותרת_פריט	TYPE_ATTRIBUTE_ITEM	0x0,000	0x70
string_id_item	TYPE_STRING_ID_ITEM	0x0,001	0x04
type_id_item	TYPE_TYPE_ID_ITEM	0x0,002	0x04
proto_id_item	TYPE_PROTO_ID_ITEM	0x0,003	0x0c
Field_id_item (שדה מזהה_פריט)	TYPE_FIELD_ID_ITEM	0x0,004	0x08
method_id_item	TYPE_METHOD_ID_ITEM	0x0,005	0x08
class_def_item	TYPE_CLASS_DEF_ITEM	0x0,006	0x20
call_site_id_item	TYPE_CALL_SITE_ID_ITEM	0x0,007	0x04
method_handle_item	TYPE_METHOD_HANDLE_ITEM	0x0,008	0x08
רשימת_מיפוי	TYPE_MAP_LIST	0x1,000	4 + (item.size * 12)
type_list	TYPE_TYPE_LIST	0x1,001	4 + (item.size * 2)
Note_set_ref_list	TYPE_REVIEW_SET_REF_LIST	0x1,002	4 + (item.size * 4)
Note_set_item	TYPE_REVIEW_SET_ITEM	0x1,003	4 + (item.size * 4)
class_data_item	TYPE_CLASS_DATA_ITEM	0x2,000	implicit; חובה לנתח
פריט_קוד	TYPE_CODE_ITEM	0x2,001	implicit; חובה לנתח
string_data_item	TYPE_STRING_DATA_ITEM	0x2,002	implicit; חובה לנתח
debug_info_item	TYPE_DEBUG_INFO_ITEM	0x2,003	implicit; חובה לנתח
Note_item	TYPE_REVIEW_ITEM	0x2,004	implicit; חובה לנתח
פריט_במערך_קידוד	TYPE_ENCODED_ARRAY_ITEM	0x2,005	implicit; חובה לנתח
notes_directory_item	TYPE_REVIEWS_DIRECTORY_ITEM	0x2,006	implicit; חובה לנתח
מוסתר_class_data_item	TYPE_HIDDENAPI_CLASS_DATA_ITEM	0xF000	implicit; חובה לנתח

string_id_item

מופיע בקטע string_ids

יישור: 4 בייטים

שם	פורמט	תיאור
string_data_off	Uint	לקזז מתחילת הקובץ לנתוני המחרוזת. שימושי. ההיסט צריך להיות למיקום בקטע `data`, והנתונים צריכים להיות בקטע פורמט שצוין על ידי "`string_data_item`" שלמטה. אין דרישת התאמה לקיזוז.

string_data_item

מופיע בקטע הנתונים

יישור: ללא (יישור לבייטים)

שם	פורמט	תיאור
utf16_size	uleb128	הגודל של המחרוזת הזו, ביחידות קוד בתקן UTF-16 (המחרוזת היא length" במערכות רבות). כלומר, זה האורך המפוענח של המחרוזת. (האורך המקודד משתמע מהמיקום של בייט אחד (`0`).
נתונים	ubyte[]	סדרה של יחידות קוד MUTF-8 (שנקראות גם 8tets, בייטים) ואחריו בייט הערך `0`. צפייה "קידוד MUTF-8 (שינוי UTF-8)" למעלה לקבלת פרטים על פורמט הנתונים. הערה: מותר לכלול מחרוזת שכוללת (הצורה המקודדת של) יחידות קוד ממלאכים של UTF-16 (כלומר, `U+d800` ... `U+dfff`) מבודד או לא בסדר ביחס הרגיל מ-Unicode ל-UTF-16. מדובר בשימושים ברמה גבוהה יותר של מחרוזות לדחיית קידודים לא חוקיים כאלה, אם רלוונטי.

type_id_item

מופיע בקטע type_id

יישור: 4 בייטים

שם	פורמט	תיאור
descriptor_idx	Uint	להוסיף לאינדקס את רשימת `string_ids` של מתאר מחרוזת מהסוג הזה. המחרוזת צריכה להתאים לתחביר של TypeDescriptor, שמוגדר למעלה.

proto_id_item

מופיע בקטע proto_id

יישור: 4 בייטים

שם	פורמט	תיאור
Shorty_idx	Uint	להוסיף לאינדקס את הרשימה `string_ids` בשביל מחרוזת שמתארת את האב טיפוס הזה. המחרוזת צריכה להתאים לפורמט התחביר ShortyDescriptor, שהוגדר למעלה, וחייב להתאים לסוג ולפרמטרים של ההחזרה של הפריט הזה.
Return_type_idx	Uint	להוסיף לאינדקס את סוג ההחזרה ברשימה `type_ids` של אב הטיפוס הזה
פרמטרים_off	Uint	לקזז מתחילת הקובץ לרשימה של סוגי פרמטרים עבור אב הטיפוס הזה, או `0` אם לאב טיפוס הזה . קיזוז זה, אם אינו אפס, צריך להיות הקטע `data`, והנתונים צריכים להיות שצוין על ידי `"type_list"` למטה. בנוסף, לא אמורים לכלול הפניה לסוג `void` ברשימה.

Field_id_item (שדה מזהה_פריט)

מופיע בקטע Field_ids

יישור: 4 בייטים

שם	פורמט	תיאור
class_idx	Ushort	להוסיף לאינדקס רשימה של `type_ids` בשביל המגדיר השדה הזה. זה חייב להיות סוג מחלקה, ולא מערך או סוג פרימיטיבי.
type_idx	Ushort	להוסיף לאינדקס את הרשימה `type_ids` בשביל סוג השדה הזה
name_idx	Uint	להוסיף לאינדקס את השם הזה ברשימה `string_ids` השדה הזה. המחרוזת חייבת להתאים לתחביר של MemberName, כפי שהוגדר למעלה.

method_id_item

מופיע בקטע method_id

יישור: 4 בייטים

שם	פורמט	תיאור
class_idx	Ushort	להוסיף לאינדקס רשימה של `type_ids` בשביל המגדיר . הערך הזה חייב להיות מחלקה או סוג מערך, ולא סוג ראשוני.
proto_idx	Ushort	לרשימה של `proto_ids` בשביל אב הטיפוס של השיטה הזו
name_idx	Uint	להוסיף לאינדקס את השם הזה ברשימה `string_ids` . המחרוזת חייבת להתאים לתחביר של MemberName, כפי שהוגדר למעלה.

class_def_item

מופיע בקטע class_defs

יישור: 4 בייטים

שם	פורמט	תיאור
class_idx	Uint	להוסיף לאינדקס את רשימת ה`type_ids` של הכיתה הזו. זה חייב להיות סוג מחלקה, ולא מערך או סוג פרימיטיבי.
דגל_גישה	Uint	דגלי גישה לכיתה (`public`, `final`, וכו'). לעיון ב'הגדרות של `access_flags`' לקבלת פרטים.
Superclass_idx	Uint	להוסיף לאינדקס את מחלקה-העל `type_ids`, או את הערך הקבוע `NO_INDEX` אם לקטגוריה הזו אין סופר-מחלקה (כלומר, מחלקה של שורש כמו `Object`). אם השדה הזה קיים, הוא חייב להיות סוג מחלקה, ולא מערך או סוג פרימיטיבי.
Interfaces_off	Uint	לקזז מתחילת הקובץ לרשימת הממשקים, או `0` אם אין כאלה. ההיסט הזה צריך להיות בקטע `data`, והנתונים צריכים להיות הם צריכים להיות בפורמט שצוין `type_list` שלמטה. כל אחד מהרכיבים ברשימה חייב להיות סוג מחלקה (לא מערך או סוג פרימיטיבי), אסור שיהיו כפילויות.
source_file_idx	Uint	להוסיף לאינדקס את השם של `string_ids` שמכיל את המקור המקורי של הכיתה הזו (לפחות רובה), או הערך המיוחד `NO_INDEX` כדי לייצג חוסר מידע זה. הערך `debug_info_item` של כל שיטה נתונה עשויות לשנות את קובץ המקור, אבל אפשר לצפות לרוב המחלקות. יגיעו רק מקובץ מקור אחד.
notes_off	Uint	לקזז מתחילת הקובץ למבנה ההערות לכיתה הזו, או `0` אם אין הערות לגבי בכיתה הזו. קיזוז זה, אם אינו אפס, צריך להיות הקטע `data`, והנתונים צריכים להיות הפורמט שצוין על ידי '`annotations_directory_item`' שלמטה, עם כל הפריטים שמפנים לקטגוריה הזו בתור המגדיר.
class_data_off	Uint	לקזז מתחילת הקובץ לקובץ המשויך נתוני הכיתה של הפריט הזה, או `0` אם אין כיתה נתונים לכיתה הזו. (זה יכול להיות המצב, לדוגמה, אם הכיתה הוא ממשק של סמנים). הקיזוז, אם אינו אפס, צריך להיות הקטע `data`, והנתונים צריכים להיות פורמט שצוין על ידי "`class_data_item`" למטה, כולל כל פריטים שמתייחסים לסיווג הזה בתור כלי ההגדרה.
static_values_off	Uint	לקזז מתחילת הקובץ לרשימת לשדות `static`, או ל-`0` אם יש אין בכלל (וכל השדות `static` יאתחלו עם `0` או `null`). הקיזוז הזה צריך להיות `data`, והנתונים צריכים להיות פורמט שצוין על ידי "`encoded_array_item`" שלמטה. הגודל של המערך חייב להיות לא גדול יותר מהמספר `static` השדות שהוצהרו על ידי המחלקה הזו, והרכיבים תואמים `static` שדות באותו סדר שהוצהר ב- `field_list` התואם. הסוג של כל מערך הרכיב חייב להתאים לסוג המוצהר של השדה התואם שלו. אם יש במערך פחות רכיבים מאשר `static` שדות, ולאחר מכן השדות שנותרו מאותרים עם `0` או `null` שמתאימים לסוג.

call_site_id_item

מופיע בקטע call_site_id

יישור: 4 בייטים

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

call_site_item

מופיע בקטע הנתונים

יישור: ללא (מיושר לבייט)

ה-call_site_item הוא מערך מקודד_מערך_פריט שהרכיבים שלו תואמים לארגומנטים סופקו ל-methoder Bocker linker. שלושת הארגומנטים הראשונים הם:

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

ארגומנטים נוספים הם ערכים קבועים שמועברים ל-method Linker של אתחול האתחול. הארגומנטים האלה מועברים לפי הסדר וללא המרות מסוג כלשהו.

נקודת האחיזה ל-method שמייצגת את ה-method Linker חייבת להיות מסוג 'החזרה': java.lang.invoke.CallSite. שלושת סוגי הפרמטרים הראשונים הם:

java.lang.invoke.Lookup
java.lang.String
java.lang.invoke.MethodType

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

method_handle_item

מופיע בקטע method_handles

יישור: 4 בייטים

שם	פורמט	תיאור
method_handle_type	Ushort	הסוג של כינוי ה-method; ראו טבלה בהמשך
unused	Ushort	(לא בשימוש)
Field_or_method_id	Ushort	מזהה שדה או מזהה method, בהתאם לסוג הכינוי של השיטה הוא Accessor או method Invoker
unused	Ushort	(לא בשימוש)

קודים של סוגי הכינויים של השיטות

קבוע	ערך	תיאור
METHOD_HANDLE_TYPE_StatIC_PUT	0x00	נקודת אחיזה לשיטה היא מגדיר שדות סטטי (מגש)
METHOD_HANDLE_TYPE_StatIC_GET	0x01	נקודת אחיזה ל-method היא תו של שדה סטטי (accessor)
METHOD_HANDLE_TYPE_INSTANCE_PUT	0x02	מזהה השיטה הוא מגדיר שדות של מופע (accessor)
METHOD_HANDLE_TYPE_INSTANCE_GET	0x03	מזהה method הוא נמען של שדה מופע (accessor)
METHOD_HANDLE_TYPE_INVOKE_StatIC (שיטות)	0x04	מזהה השיטה הוא invoker של method
METHOD_HANDLE_TYPE_INVOKE_INSTANCE	0x05	מזהה השיטה הוא invoker של שיטת המכונה
METHOD_HANDLE_TYPE_INVOKE_CONSTRUCTOR	0x06	מזהה השיטה הוא מפעיל של method constructor
METHOD_HANDLE_TYPE_INVOKE_DIRECT	0x07	כינוי ה-method הוא invoker ישיר של השיטה
METHOD_HANDLE_TYPE_INVOKE_INTERFACE	0x08	כינוי ה-method הוא invoker של שיטת הממשק

class_data_item

הוזכר מתוך class_def_item

מופיע בקטע הנתונים

יישור: ללא (יישור לבייטים)

שם	פורמט	תיאור
static_fields_size	uleb128	מספר השדות הסטטיים שמוגדרים בפריט הזה
instance_fields_size	uleb128	מספר שדות המכונה שהוגדרו בפריט הזה
ישיר_methods_size	uleb128	מספר השיטות הישירות המוגדרות בפריט הזה
וירטואלית_methods_size	uleb128	מספר השיטות הווירטואליות שהוגדר בפריט הזה
static_fields	code_field[static_fields_size]	את השדות הסטטיים המוגדרים, שמיוצגים כרצף של של רכיבים מוצפנים. צריך למיין את השדות לפי `field_idx` בסדר עולה.
שדות_מופע	ated_field[instance_fields_size]	את שדות המכונה המוגדרים, שמיוצגים כרצף של של רכיבים מוצפנים. צריך למיין את השדות לפי `field_idx` בסדר עולה.
Direct_methods	code_method[direct_methods_size]	ההגדרה הישירה שהוגדרה (כל אחד מהערכים `static`, `private`, או constructor), שמיוצגים בתור רצף של של רכיבים מוצפנים. יש למיין את השיטות לפי `method_idx` בסדר עולה.
וירטואליות_methods	קידוד_method[virtual_methods_size]	הווירטואלי המוגדר (ללא `static`, `private`, או constructor), שמיוצגים בתור רצף של של רכיבים מוצפנים. הרשימה הזאת לא יכולה לכלול תכנים שעברו בירושה methods, אלא אם משנים אותן על ידי המחלקה שהפריט הזה מייצג. יש למיין את השיטות לפי `method_idx` בסדר עולה. הערך `method_idx` של שיטה וירטואלית לא יכול לא להיות זהה בכל שיטה ישירה.

הערה: field_id והקבוצה המכונות של method_id חייבות להתייחס לאותה מחלקה מגדירה.

פורמט שדה מקודד_קידוד

שם	פורמט	תיאור
Field_idx_diff	uleb128	להוסיף לאינדקס את הזהות של זה ברשימה `field_ids` שדה (כולל שם ומתאר), שמיוצג בהבדל מהאינדקס של הרכיב הקודם ברשימה. המדד שהרכיב הראשון ברשימה מיוצג באופן ישיר.
דגל_גישה	uleb128	דגלי גישה לשדה (`public`, `final`, וכו'). לעיון ב'הגדרות של `access_flags`' לקבלת פרטים.

פורמט מקודד_method

שם	פורמט	תיאור
method_idx_diff	uleb128	להוסיף לאינדקס את הזהות של זה ברשימה `method_ids` שמיוצגת בהבדל (כולל שם ומתאר) מהאינדקס של הרכיב הקודם ברשימה. המדד שהרכיב הראשון ברשימה מיוצג באופן ישיר.
דגל_גישה	uleb128	דגלי גישה ל-method (`public`, `final`, וכו'). לעיון ב'הגדרות של `access_flags`' לקבלת פרטים.
code_off [code_off]	uleb128	לקזז מתחילת הקובץ למבנה הקוד עבור method, או `0` אם השיטה הזו היא `abstract` או `native`. הסטייה צריך להיות למיקום קטע בנושא `data`. הפורמט של הנתונים מצוין באמצעות `code_item` שלמטה.

type_list

הוזכר על ידי class_def_item ו-proto_id_item

מופיע בקטע הנתונים

יישור: 4 בייטים

שם	פורמט	תיאור
מידה	Uint	גודל הרשימה, ברשומות
רשימה	type_item[size]	רכיבים ברשימה

פורמט type_item

שם	פורמט	תיאור
type_idx	Ushort	להוסיף לאינדקס את הרשימה `type_ids`

פריט_קוד

הוזכר מ-code_method

מופיע בקטע הנתונים

יישור: 4 בייטים

שם	פורמט	תיאור
גודל_רישום	Ushort	מספר הרשומות שמשמשות את הקוד הזה
ins_size [מידה]	Ushort	את מספר המילים של הארגומנטים הנכנסים לשיטה, הקוד הוא עבור
outs_size (גודל גזרה)	Ushort	מספר המילים של שטח הארגומנט היוצא שנדרש על ידי הפונקציה קוד להפעלת השיטה
גודל_ניסיונות	Ushort	מספר ה-`try_item` במופע הזה. אם הוא לא אפס, הם מופיעים בתור מערך `tries` מיד אחרי `insns` במקרה הזה.
debug_info_off.	Uint	לקזז מתחילת הקובץ ועד למידע על תוצאות ניפוי הבאגים (מספרי שורות + מידע על משתנה מקומי) עבור הקוד הזה, או `0` אם פשוט אין מידע. הקיזוז, אם אינו אפס, למיקום בקטע `data`. הפורמט של הנתונים מצוינים באמצעות '`debug_info_item`' שלמטה.
insns_size [מידה]	Uint	גודל רשימת ההוראות, ביחידות קוד של 16 ביט
פונדקי דרכים	ushort[insns_size]	בפועל של בייטקוד. הפורמט של הקוד ב`insns` מערך מצוין על ידי המסמך הנלווה Dalvik bytecode הערה למרות שהוא מוגדר כמערך של `ushort`, הם כמה מבנים פנימיים שמעדיפים יישור של ארבעה בייטים. כמו כן, אם במקרה זה קובץ שהוחלט בהדרגה, ההחלפה רק במופעים בודדים של `ushort`, ולא ב מבנים פנימיים גדולים יותר.
padding	ushort (אופציונלי) = 0	שני בייטים של מרווח פנימי כדי להפוך את `tries` לארבעה בייטים. הרכיב הזה קיים רק אם הערך של `tries_size` הוא לא אפס ו-`insns_size` הוא אי-זוגי.
מנסה	Try_item[tries_size] (אופציונלי)	מערך שמציין איפה נמצאים החריגים של הקוד. איך לטפל בהם. רכיבי המערך חייבים להיות לא חופפים בטווח ובסדר מהכתובת הנמוכה לגבוהה. הרכיב הזה הוא רק קיים אם `tries_size` הוא לא אפס.
רכיבי handler	מקודד_catch_handler_list (אופציונלי)	בייטים שמייצגים רשימה של סוגי רשימות של סוגי איסוף ושיוך של כתובות ה-handler. לכל `try_item` יש היסט בייטים במבנה הזה. הרכיב הזה קיים רק אם הערך `tries_size` הוא לא אפס.

פורמט Try_item

שם	פורמט	תיאור
start_addr	Uint	הכתובת ההתחלתית של בלוק הקוד שרשומה הזו. הכתובת הוא מספר יחידות הקוד באורך 16 ביט, שמתחילות הוראות להתאמה אישית.
nsn_count	Ushort	מספר יחידות הקוד של 16 ביט שהרשומה הזו מכסה. הקוד האחרון היחידה שכלולה (כולל) היא `start_addr + insn_count - 1`.
handler_off	Ushort	היסט בבייטים מתחילת הקובץ המשויך `encoded_catch_hander_list` ל- `encoded_catch_handler` עבור הרשומה הזו. זו חייבת להיות לקיזוז לתחילת `encoded_catch_handler`.

פורמט מקודד_catch_handler_list

שם	פורמט	תיאור
מידה	uleb128	גודל הרשימה הזו, ברשומות
רשימה	encoded_catch_handler[handlers_size]	רשימה של רשימות handler, שמיוצגות ישירות (לא בתור היסט), ומשורשרים ברצף

פורמט מקודד_catch_handler

שם	פורמט	תיאור
מידה	sleb128	מספר סוגי התפיסה ברשימה הזו. אם הוא לא חיובי, הערך מספר שלילי של סוגי התפיסות ולאחר מכן מתבצע מעקב באמצעות handler מאסף (catch-all) אחד. לדוגמה: `size` של `0` פירושו שיש קלט כולל אבל לא הוקלד באופן מפורש. המשמעות של `size` של `2` היא שיש שני סוגי תוכן "קליטה". וגם `size` מתוך `-1` פירושו שיש מלכד אחד שהוקלד יחד עם מאסף (catch-all) אחד.
רכיבי handler	קידוד_type_addr_pair[AB(size)]	רצף של `abs(size)` פריטים מקודדים, אחד לכל פריט שתועד לפי הסדר שבו יש לבדוק את הסוגים.
pull_all_addr	uleb128 (אופציונלי)	כתובת ה-bytecode של ה-handler של פרוטוקול הבא (catch-all). הרכיב הזה הוא רק קיים אם `size` הוא לא חיובי.

פורמט מקודד_type_addr_pair

שם	פורמט	תיאור
type_idx	uleb128	להוסיף לאינדקס את הרשימה `type_ids` בשביל הסוג של חריג לתפיסה
Addr	uleb128	כתובת בייטקוד של ה-handler המשויך לחריג

debug_info_item

הוזכר מ-code_item

מופיע בקטע הנתונים

יישור: ללא (יישור לבייטים)

כל debug_info_item מגדיר בייט-מקודד בהשראת DWARF3 היא מקודדת, שכאשר היא מתפרשת, היא פולטת את המיקומים טבלה וכן (אולי) את המידע על המשתנה המקומי של code_item. הרצף מתחיל באורך משתנה Title (האורך שלו תלוי במספר השיטה) ), ואחריהם מופיעים הבייטים של מכונות המצב עם בייט DBG_END_SEQUENCE.

מכונת המצב מורכבת מחמישה רישומים. רישום address מייצג את קיזוז ההוראה משויך אל insns_item ביחידות קוד של 16 ביט. רישום address מתחיל בשעה 0 בתחילת כל יום הרצף debug_info וצריך להגדיל אותו באופן מונוטוני בלבד. הרישום line מייצג את מספר שורת המקור צריך להיות משויך לערך הבא בטבלת המיקומים שנוצר על-ידי במכונת המצב. הוא מאותחל בכותרת הרצף, ויכול להיות שינוי בכיוונים חיוביים או שליליים, אבל אסור שיהיה קטן מ- 1 הרישום source_file מייצג את קובץ המקור שאליו מתייחסות הרשומות של מספר השורה. הוא מאותחל ל הערך של source_file_idx ב-class_def_item. שני המשתנים האחרים, prologue_end ו epilogue_begin, הם דגלים בוליאניים (האות שמייצגת אותו הם דגלים בוליאניים false), שמציין אם התקבל המיקום הבא צריך להתייחס לשיטה 'פרולוג' או 'אפילוג'. מכונת המצב חייב לעקוב גם אחרי השם והסוג של המשתנה המקומי האחרון הפעיל בכל רישום של הקוד DBG_RESTART_LOCAL.

הכותרת נראית כך:

שם	פורמט	תיאור
line_start	uleb128	הערך הראשוני של הרשמת `line` של המכונה של המצב. לא מייצג רשומת משרה בפועל.
פרמטרים_size	uleb128	מספר שמות הפרמטרים שמקודדים. צריכות להיות אחת לכל פרמטר שיטה, לא כולל `this` של שיטת המופע, אם בכלל.
פרמטרים_names	uleb128p1[parameters_size]	String Index של שם הפרמטר של השיטה. ערך מקודד של `NO_INDEX` מציין שאין שם זמין לפרמטר המשויך. תיאור הסוג והחתימה משתמעות ממתאר השיטה ומהחתימה.

ערכי הקוד של הבייטים הם:

שם	ערך	פורמט	ארגומנטים	תיאור
DBG_END_SEQUENCE	0x00		(ללא)	סוגר רצף מידע על ניפוי באגים עבור `code_item`
DBG_ADVANCE_PC	0x01	uleb128 addr_diff	`addr_diff`: סכום להוספה לרישום הכתובות	מקדם את רישום הכתובות מבלי להשמיט ערך של מיקום
DBG_ADVANCE_LINE	0x02	sleb128 line_diff	`line_diff`: הסכום לשינוי רישום השורה	מקדם את רישום הקו מבלי לקלוט ערך של מיקום
DBG_START_LOCAL	0x03	uleb128 register_num uleb128p1 name_idx uleb128p1 type_idx	`register_num`: רישום שיכיל מקומי `name_idx`: אינדקס המחרוזת של השם `type_idx`: אינדקס סוג מהסוג	מציג משתנה מקומי בכתובת הנוכחית. אחד משני הערכים `name_idx` או `type_idx` עשויים להיות `NO_INDEX` כדי לציין שהערך לא ידוע.
DBG_START_LOCAL_EXTENDED	0x04	uleb128 register_num uleb128p1 name_idx uleb128p1 type_idx uleb128p1 sig_idx	`register_num`: רישום שיכיל מקומי `name_idx`: אינדקס המחרוזת של השם `type_idx`: אינדקס מסוג סוג `sig_idx`: אינדקס מחרוזות של סוג החתימה	מציג חתימה מקומית עם חתימה מסוג בכתובת הנוכחית. אחד מ-`name_idx`, `type_idx`, או `sig_idx` יכול להיות `NO_INDEX` כדי לציין שהערך אינו ידוע. (אם `sig_idx` הוא עם זאת, `-1`, ניתן לייצג את אותם נתונים יותר באמצעות קוד הפעולה `DBG_START_LOCAL` באופן יעיל.) הערה: אפשר לעיין בדיון בקטע '`dalvik.annotation.Signature`' בהמשך לאזהרות הטיפול בחתימות.
DBG_END_LOCAL	0x05	uleb128 register_num	`register_num`: רישום שמכיל הודעות מקומיות	מסמן משתנה מקומי שפעיל כרגע כלא רלוונטי כתובת
DBG_RESTART_LOCAL	0x06	uleb128 register_num	`register_num`: יש לרשום כדי להפעיל מחדש	הפונקציה מחזירה משתנה מקומי בכתובת הנוכחית. השם והסוג זהים לאלה של העסק המקומי האחרון שהיה פעיל אומנם,
DBG_SET_PROLOGUE_END	0x07		(ללא)	מגדירה את רישומי המכונה של המצב `prologue_end`, שמציין שרשומת המיקום הבאה שתתווסף צריכה להיות הסוף של פרולוג דרך נקודת עצירה (breakpoint) של שיטה). ההרשמה של `prologue_end` היא נמחק באמצעות קוד opcode מיוחד (`>= 0x0a`).
DBG_SET_EPILOGUE_BEGIN	0x08		(ללא)	מגדירה את רישומי המכונה של המצב `epilogue_begin`, שמציין שרשומת המיקום הבאה שתתווסף צריכה להיות היא ההתחלה של שיטה, מקום מתאים כדי להשעות את הביצוע לפני היציאה של השיטה). הרישום `epilogue_begin` נמחק על ידי סימנים מיוחדים (`>= 0x0a`) opcode.
קובץ DBG_SET_FILE	0x09	uleb128p1 name_idx	`name_idx`: אינדקס מחרוזת של שם קובץ המקור; `NO_INDEX` אם לא ידוע	מציין שכל הרשומות הבאות של מספרי השורה מתייחסות שם קובץ המקור, במקום שם ברירת המחדל שצוין ב- `code_item`
קודי תפעול מיוחדים	0x0a...0xff		(ללא)	מקדם את ההרשמה `line` ו-`address`, פולט ערך של מיקום, ומבטל את הערך `prologue_end` ו- `epilogue_begin` התיאור מופיע בהמשך.

קודי תפעול מיוחדים

קודי פונקציות עם ערכים בין 0x0a ל-0xff (כולל) מזיזים גם את line וגם את address נרשם בכמות קטנה ואז פולט ערך חדש בטבלת המיקומים. הנוסחה לחישוב המרווחים היא:

DBG_FIRST_SPECIAL = 0x0a  // the smallest special opcode
DBG_LINE_BASE   = -4      // the smallest line number increment
DBG_LINE_RANGE  = 15      // the number of line increments represented

adjusted_opcode = opcode - DBG_FIRST_SPECIAL

line += DBG_LINE_BASE + (adjusted_opcode % DBG_LINE_RANGE)
address += (adjusted_opcode / DBG_LINE_RANGE)

notes_directory_item

הוזכר מתוך class_def_item

מופיע בקטע הנתונים

יישור: 4 בייטים

שם	פורמט	תיאור
class_annotations_off	Uint	לקזז מתחילת הקובץ להערות שנוספו ישירות בכיתה, או `0` אם אין בכיתה הערות ישירות. ההיסט, אם הוא לא אפס, צריך להיות מיקום קטע בנושא `data`. הפורמט של הנתונים צוין מאת '`annotation_set_item`' שלמטה.
Field_size (גודל שדות)	Uint	מספר השדות שהפריט הזה הוסיף להם הערות
notesd_methods_size	Uint	מספר השיטות שהפריט הזה מוסיף הערות
speechd_parameters_size	Uint	מספר רשימות הפרמטרים של השיטה שהפריט הזה מוסיף להן הערות
הערות_שדות	Field_annotation[fields_size] (אופציונלי)	רשימה של הערות רלוונטיות בשדות. רכיבי הרשימה ממוין בסדר הולך וגדל, לפי `field_idx`.
method_annotations	method_annotation[methods_size] (אופציונלי)	רשימה של הערות השיטה המשויכות. רכיבי הרשימה ממוין בסדר הולך וגדל, לפי `method_idx`.
פרמטר_annotations	parameter_annotation[parameters_size] (אופציונלי)	רשימה של הערות עם פרמטרים של שיטות משויכות. הרכיבים של צריך למיין את הרשימה בסדר הולך וגדל, לפי `method_idx`.

הערה: field_id והקבוצה המכונות של method_id חייבות להתייחס לאותה מחלקה מגדירה.

פורמט של הערת שדה

שם	פורמט	תיאור
Field_idx	Uint	להוסיף לאינדקס את הזהות של `field_ids` ברשימה שדה שמוסיף הערות
notes_off	Uint	לקזז מתחילת הקובץ לרשימת ההערות עבור בשדה. הסטייה צריך להיות למיקום ב`data` . הפורמט של הנתונים מצוין באמצעות `annotation_set_item` שלמטה.

פורמט method_annotation

שם	פורמט	תיאור
method_idx	Uint	להוסיף לאינדקס את הזהות של `method_ids` ברשימה של הוספת הערות
notes_off	Uint	לקזז מתחילת הקובץ לרשימת ההערות עבור השיטה. הסטייה צריך להיות למיקום קטע בנושא `data`. הפורמט של הנתונים מצוין באמצעות `annotation_set_item` שלמטה.

פורמט הפרמטר parameter_annotation

שם	פורמט	תיאור
method_idx	Uint	להוסיף לאינדקס את הזהות של `method_ids` ברשימה שיטה להוספת הערות לפרמטרים שלה
notes_off	Uint	לקזז מתחילת הקובץ לרשימת ההערות עבור את הפרמטרים של ה-method. הסטייה צריך להיות למיקום קטע בנושא `data`. הפורמט של הנתונים מצוין באמצעות `annotation_set_ref_list` שלמטה.

Note_set_ref_list

הוזכר מתוך פרמטר_annotations_item

מופיע בקטע הנתונים

יישור: 4 בייטים

שם	פורמט	תיאור
מידה	Uint	גודל הרשימה, ברשומות
רשימה	substitute_set_ref_item[size]	רכיבים ברשימה

פורמט Notebook_set_ref_item

שם	פורמט	תיאור
notes_off	Uint	לקזז מתחילת הקובץ ועד לקבוצת ההערות שאליה מפנה או `0` אם אין הערות לרכיב הזה. ההיסט, אם הוא לא אפס, צריך להיות למיקום ב-`data` . הפורמט של הנתונים מצוין באמצעות `annotation_set_item` שלמטה.

Note_set_item

הפניה מ-Notes_directory_item, field_annotations_item, method_annotations_item ו-note_set_ref_item

מופיע בקטע הנתונים

יישור: 4 בייטים

שם	פורמט	תיאור
מידה	Uint	גודל הקבוצה, ברשומות
ערכים	substitute_off_item[size]	של הקבוצה. יש למיין את הרכיבים בסדר הולך וגדל, מאת `type_idx`.

פורמט note_off_item

שם	פורמט	תיאור
Note_off	Uint	לקזז מתחילת הקובץ להערה. הסטייה צריך להיות למיקום בקטע `data`. והפורמט של הנתונים באותו מיקום מצוין `annotation_item` שלמטה.

Note_item

הוזכר מתוך Note_set_item

מופיע בקטע הנתונים

יישור: ללא (יישור לבייטים)

שם	פורמט	תיאור
חשיפה	בייט	החשיפה הרצויה של ההערה (ראו בהמשך)
הערה	קידוד_annotation	תוכן מקודד של הערות, בפורמט שמתואר על ידי 'פורמט `encoded_annotation`' מתחת 'קידוד `encoded_value`' למעלה.

ערכי חשיפה

אלה האפשרויות לשדה visibility ב- annotation_item:

שם	ערך	תיאור
VISIBILITY_BUILD	0x00	אמורים להיות גלויים רק בזמן ה-build (למשל, במהלך הידור (compilation) של קוד אחר)
VISIBILITY_RUNTIME	0x01	אמור להיות גלוי בזמן ריצה
VISIBILITY_SYSTEM	0x02	גלויים בזמן הריצה, אבל רק למערכת הבסיסית (ולא לקוד משתמש רגיל)

פריט_במערך_קידוד

הוזכר מתוך class_def_item

מופיע בקטע הנתונים

יישור: ללא (יישור לבייטים)

שם	פורמט	תיאור
ערך	מערך_מקודד	בייטים שמייצגים את ערך המערך המקודד, בפורמט שצוין לפי 'פורמט `encoded_array`' מתחת ל'`encoded_value`' קידוד" למעלה.

מוסתר_class_data_item

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

הערה: תכונת ה-API המוסתרת הושקה ב-Android 10.0 והוא רלוונטי רק לקובצי ה-DEX של מחלקות בנתיב מחלקת האתחול. יכול להיות שרשימת הדגלים שמתוארת בהמשך תורחב בגרסאות הבאות של Android. מידע נוסף זמין במאמר הבא: הגבלות על ממשקים שאינם SDK.

שם	פורמט	תיאור
מידה	Uint	הגודל הכולל של הקטע
היסט	uint[]	מערך של היסט ההיסטים שנוספו לאינדקס על ידי `class_idx`. ערך אפס של מערך באינדקס `class_idx` פירושו אין נתונים עבור `class_idx` הזה, או עבור כל ממשק ה-API המוסתר הם אפס. אחרת, ערך המערך אינו אפס ומכיל היסט תחילת הקטע למערך של דגלי API מוסתרים ל`class_idx` הזה.
דגלים	uleb128[]	מערכים משורשרים של דגלי API מוסתרים לכל מחלקה. הערכים האפשריים של הסימון מתוארים בטבלה שלמטה. הדגלים מקודדים באותו סדר כמו השדות והשיטות שמקודדים בנתוני הכיתה.

סוגי סימונים של הגבלה:

שם	ערך	תיאור
להוסיף לרשימת ההיתרים	0	ממשקים שאפשר להשתמש בהם בחינם ונתמכים כחלק מ המסגרת של Android שמתועדת באופן רשמי אינדקס חבילות.
רשימה אפורה	1	ממשקים שאינם SDK שניתן להשתמש בהם ללא קשר רמת ה-API המטורגטת.
הוסף לרשימה השחורה	2	ממשקים שאינם SDK שלא ניתן להשתמש בהם, ללא קשר לאופן שבו האפליקציה רמת ה-API המטורגטת. גישה לאחד מהממשקים האלה גורמת שגיאת זמן ריצה.
Grelist‐max‐o	3	ממשקים שאינם SDK שאפשר להשתמש בהם ב-Android מגרסה 8.x ומטה אלא אם הם מוגבלים.
רשימה אפורה-max‐p	4	ממשקים שאינם SDK שאפשר להשתמש בהם ב-Android 9.x אלא אם הם מוגבלים.
רשימה אפורה-max‐q	5	ממשקים שאינם SDK שאפשר להשתמש בהם ב-Android 10.x אלא אם הם מוגבלים.
grelist-max-r	6	ממשקים שאינם SDK שאפשר להשתמש בהם ב-Android 11.x אלא אם הם מוגבלים.

הערות מערכת

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

הערות מערכת מיוצגות בקבצים של .dex בתור הערות שהחשיפה שלהן מוגדרת ל-VISIBILITY_SYSTEM.

dalvik.annotation.AnnotationDefault

מופיע ב-methods בממשקים של הערות

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

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

dalvik.annotation.EnclosingClass

מופיע בכיתות

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

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

dalvik.annotation.EnclosingMethod

מופיע בכיתות

לכל כיתה מצורפת הערה מסוג EnclosingMethod שמוגדר בגוף השיטה. בכל כיתה שיש לה הערה חייבת לכלול גם הערה מסוג InnerClass. בנוסף, אסור שיהיו בכיתה גם EnclosingClass ו-EnclosingMethod הערה.

שם	פורמט	תיאור
ערך	שיטה	את השיטה ההיקפית המילונית ביותר

dalvik.annotation.InnerClass

מופיע בכיתות

לכל כיתה מצורפת הערה מסוג InnerClass שמוגדר בהיקף המילוני בהגדרה של מחלקה אחרת. כל סיווג עם ההערה הזו חייב לכלול גם או הערה EnclosingClass או הערה EnclosingMethod.

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

dalvik.annotation.MemberClasses

מופיע בכיתות

לכל כיתה מצורפת הערה מסוג MemberClasses שמצהירות על הכיתות של החברים. (כיתה של חבר היא כיתה פנימית ישירה שיש לו שם.)

שם	פורמט	תיאור
ערך	כיתה[]	מערך של מחלקות החברים

dalvik.annotation.MethodParameters

מופיע בשיטות

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

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

ניתן להשמיט את ההערה מ-method או מ-constructor באופן בטוח כאשר אין צורך במטא-נתונים של פרמטר בזמן הריצה. אפשר להשתמש באפליקציה java.lang.reflect.Parameter.isNamePresent() כדי לבדוק האם קיימים מטא-נתונים לפרמטר, ומה ההשתקפות המשויכת שיטות כמו java.lang.reflect.Parameter.getName() ייפלו חזרה להתנהגות ברירת המחדל בזמן הריצה אם המידע לא קיים.

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

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

המערכים המתועדים למטה חייבים להיות בגודל זהה לזה של מבנה דקס method_id_item המשויך לשיטה, אחרת זריקת java.lang.reflect.MalformedParametersException אל בסביבת זמן ריצה.

כלומר: method_id_item.proto_idx -> proto_id_item.parameters_off -> type_list.size חייב להיות זהה ל-names().length ו- accessFlags().length

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

שם	פורמט	תיאור
שמות	String[]	שמות הפרמטרים הרשמיים לשיטה המשויכת. המערך לא יכולה להיות null אבל חייבת להיות ריקה אם אין פרמטרים רשמיים. ערך ב- המערך חייב להיות null אם לפרמטר הרשמי עם האינדקס הזה אין שם. אם המחרוזות של שם הפרמטר ריקות או מכילות '.', ';', '[' או '/' ואז זריקת `java.lang.reflect.MalformedParametersException` של בסביבת זמן ריצה.
דגלי גישה	int[]	סימוני הגישה של הפרמטרים הרשמיים ל-method המשויך. מערך לא יכול להיות ריק אבל חייב להיות ריק אם אין פרמטרים רשמיים. הערך הוא קצת מסכה עם הערכים הבאים: 0x0010 : סופי, הפרמטר הוכרז כסופי 0x1000 : סינתטי, הפרמטר הוצג על ידי המהדר 0x8000 : נדרש, הפרמטר הוא סינתטי אבל משתמע גם מהשפה מפרט אם הוגדרו ביטים מחוץ לקבוצה הזו, המערכת תעיף את `java.lang.reflect.MalformedParametersException` בזמן הריצה.

dalvik.annotation.חתימה

מופיע בכיתות, בשדות ובשיטות

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

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

שם	פורמט	תיאור
ערך	String[]	החתימה של המחלקה או החבר, כמערך מחרוזות צריך להיות משורשרים

dalvik.annotation.Throws

מופיע בשיטות

הערת Throws מצורפת לכל שיטה ש מוצהר כגורם חריג אחד או יותר מסוג חריג.

שם	פורמט	תיאור
ערך	כיתה[]	מערך סוגי החריגים שנפסלו