<activity>

תחביר:
<activity android:allowEmbedded=["true" | "false"]
          android:allowTaskReparenting=["true" | "false"]
          android:alwaysRetainTaskState=["true" | "false"]
          android:autoRemoveFromRecents=["true" | "false"]
          android:banner="drawable resource"
          android:canDisplayOnRemoteDevices=["true" | "false"]
          android:clearTaskOnLaunch=["true" | "false"]
          android:colorMode=[ "hdr" | "wideColorGamut"]
          android:configChanges=["colorMode", "density",
                                 "fontScale", "fontWeightAdjustment",
                                 "grammaticalGender", "keyboard",
                                 "keyboardHidden", "layoutDirection", "locale",
                                 "mcc", "mnc", "navigation", "orientation",
                                 "screenLayout", "screenSize",
                                 "smallestScreenSize", "touchscreen", "uiMode"]
          android:directBootAware=["true" | "false"]
          android:documentLaunchMode=["intoExisting" | "always" |
                                  "none" | "never"]
          android:enabled=["true" | "false"]
          android:enableOnBackInvokedCallback=["true" | "false"]
          android:excludeFromRecents=["true" | "false"]
          android:exported=["true" | "false"]
          android:finishOnTaskLaunch=["true" | "false"]
          android:hardwareAccelerated=["true" | "false"]
          android:icon="drawable resource"
          android:immersive=["true" | "false"]
          android:label="string resource"
          android:launchMode=["standard" | "singleTop" |
                              "singleTask" | "singleInstance" | "singleInstancePerTask"]
          android:lockTaskMode=["normal" | "never" |
                              "if_whitelisted" | "always"]
          android:maxRecents="integer"
          android:maxAspectRatio="float"
          android:minAspectRatio="float"
          android:multiprocess=["true" | "false"]
          android:name="string"
          android:noHistory=["true" | "false"]  
          android:parentActivityName="string" 
          android:persistableMode=["persistRootOnly" | 
                                   "persistAcrossReboots" | "persistNever"]
          android:permission="string"
          android:process="string"
          android:relinquishTaskIdentity=["true" | "false"]
          android:requireContentUriPermissionFromCaller=["none" | "read" | "readAndWrite" |
                                                         "readOrWrite" | "write"] 
          android:resizeableActivity=["true" | "false"]
          android:screenOrientation=["unspecified" | "behind" |
                                     "landscape" | "portrait" |
                                     "reverseLandscape" | "reversePortrait" |
                                     "sensorLandscape" | "sensorPortrait" |
                                     "userLandscape" | "userPortrait" |
                                     "sensor" | "fullSensor" | "nosensor" |
                                     "user" | "fullUser" | "locked"]
          android:showForAllUsers=["true" | "false"]
          android:stateNotNeeded=["true" | "false"]
          android:supportsPictureInPicture=["true" | "false"]
          android:taskAffinity="string"
          android:theme="resource or theme"
          android:uiOptions=["none" | "splitActionBarWhenNarrow"]
          android:windowSoftInputMode=["stateUnspecified",
                                       "stateUnchanged", "stateHidden",
                                       "stateAlwaysHidden", "stateVisible",
                                       "stateAlwaysVisible", "adjustUnspecified",
                                       "adjustResize", "adjustPan"] >   
    ...
</activity>
מוכל ב:
<application>
יכולים לכלול:
<intent-filter>
<meta-data>
<layout>
<property>
תיאור:
מצהיר על פעילות (מחלקת משנה של Activity) שמטמיעה חלק מממשק המשתמש החזותי של האפליקציה. כל הפעילויות צריכות להיות מיוצגות על ידי רכיבי <activity> בקובץ המניפסט. מודעות שלא מוצהרות שם לא נראות למערכת ולא יוצגו אף פעם.
מאפיינים:
android:allowEmbedded

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

ערך ברירת המחדל של המאפיין הזה הוא false.

android:allowTaskReparenting
האם הפעילות יכולה לעבור מהמשימה שהתחילה אותה למשימה שהיא קשורה אליה, כשהמשימה הזו תועבר לחזית. הוא "true" אם אפשר להזיז אותו, ו-"false" אם הוא נשאר עם המשימה שבה הוא התחיל.

אם לא מגדירים את המאפיין הזה, הערך שמוגדר במאפיין allowTaskReparenting המתאים של רכיב <application> חל על הפעילות. ערך ברירת המחדל הוא "false".

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

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

הזיקה של פעילות מוגדרת על ידי המאפיין taskAffinity. הזיקה של משימה נקבעת על ידי קריאת הזיקה של פעילות הבסיס שלה. לכן, בהגדרה, פעילות בסיסית תמיד נמצאת במשימה עם אותה שייכות. מכיוון שפעילויות עם מצבי הפעלה "singleTask" או "singleInstance" יכולות להיות רק ברמת הבסיס של משימה, אפשר לשנות את ההורה רק במצבים "standard" ו-"singleTop". (כדאי לעיין גם במאפיין launchMode).

android:alwaysRetainTaskState
האם המערכת תמיד שומרת את מצב המשימה שבה הפעילות מתבצעת. "true" אם כן, ו"false" אם המערכת יכולה לאפס את המשימה למצב ההתחלתי שלה במצבים מסוימים. ערך ברירת המחדל הוא "false". המאפיין הזה רלוונטי רק לפעילות הבסיסית של משימה. המערכת מתעלמת ממנו בכל הפעילויות האחרות.

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

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

android:autoRemoveFromRecents
האם משימות שהופעלו על ידי הפעילות עם המאפיין הזה יישארו במסך הפריטים האחרונים עד שהפעילות האחרונה במשימה תושלם. אם true, המשימה מוסרת אוטומטית מהמסך 'פריטים אחרונים'. הפעולה הזו מבטלת את השימוש של המתקשר ב-FLAG_ACTIVITY_RETAIN_IN_RECENTS. הערך חייב להיות בוליאני, כלומר "true" או "false".
android:banner
משאב גרפי וקטורי שניתן לשרטוט שמספק באנר גרפי מורחב לפריט המשויך. אפשר להשתמש בתג <activity> כדי לספק באנר ברירת מחדל לפעילות ספציפית, או בתג <application> כדי לספק באנר לכל הפעילויות באפליקציה.

המערכת משתמשת בבאנר כדי לייצג אפליקציה במסך הבית של Android TV. הבאנר מוצג רק במסך הבית, ולכן הוא מצוין רק על ידי אפליקציות עם פעילות שמטפלת ב-intent‏ CATEGORY_LEANBACK_LAUNCHER.

המאפיין הזה מוגדר כהפניה לפריט גרפי שניתן להזזה שמכיל את התמונה, כמו "@drawable/banner". אין באנר שמוגדר כברירת מחדל.

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

android:canDisplayOnRemoteDevices

ההגדרה מציינת אם אפשר להציג את הפעילות במכשיר מרוחק שפועלת בו מערכת Android או לא. הערך חייב להיות בוליאני, כלומר "true" או "false".

ערך ברירת המחדל של המאפיין הזה הוא "true".

android:clearTaskOnLaunch
אם כל הפעילויות מוסרות מהמשימה, למעט פעילות הבסיס, כשהיא מופעלת מחדש ממסך הבית. ‫"true" אם המשימה תמיד מצומצמת לפעילות הבסיסית שלה, ו- ‫"false" אם לא. ערך ברירת המחדל הוא "false". המאפיין הזה רלוונטי רק לפעילויות שמתחילות משימה חדשה – פעילות הבסיס. המערכת מתעלמת ממנו בכל הפעילויות האחרות במשימה.

אם הערך הוא "true", בכל פעם שהמשתמשים מתחילים את המשימה, הם מועברים לפעילות הבסיסית שלה, בלי קשר לפעולה האחרונה שהם ביצעו במשימה ובלי קשר ללחצן 'הקודם' או 'הבית' שבו הם השתמשו כדי לצאת ממנה. אם הערך הוא "false", במקרים מסוימים אפשר לנקות את המשימה מפעילויות, אבל לא תמיד. מידע נוסף זמין במאמר בנושא מאפיין alwaysRetainTaskState.

נניח שהמשתמש מפעיל את הפעילות P ממסך הבית, ומשם עובר לפעילות Q. אחר כך המשתמש מקיש על סמל דף הבית וחוזר לפעילות P. בדרך כלל, המשתמש רואה את הפעילות Q, כי זאת הפעולה האחרונה שהוא ביצע במשימה של P. עם זאת, אם P מגדיר את הדגל הזה ל-"true", כל הפעילויות שמעליו – במקרה הזה, Q – מוסרות כשהמשתמש מפעיל את הפעילות P ממסך הבית. לכן, כשהמשתמש חוזר למשימה, הוא רואה רק את P.

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

המערכת מתעלמת מהמאפיין הזה אם לא מוגדר FLAG_ACTIVITY_RESET_TASK_IF_NEEDED.

android:colorMode

מציין את מצב הצבע של הפעילות. אם מציינים ערך, הוא יכול להיות hdr או wideColorGamut.

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

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

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

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

המחרוזות הבאות הן ערכים תקינים למאפיין הזה. אם יש כמה ערכים, צריך להפריד ביניהם באמצעות |, למשל "locale|navigation|orientation".

ערך תיאור
"colorMode"

יכולות מצב הצבע של המסך (סולם צבעים או טווח דינמי) השתנו.

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

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

נוסף ברמת API‏ 24.
"fontScale" שינוי בפקטור של שינוי הגודל של הגופן, למשל כשהמשתמש בוחר גודל גופן גלובלי חדש.
"fontWeightAdjustment" השתנה סכום העלייה במשקל הגופן.
"grammaticalGender" המגדר הדקדוקי של השפה השתנה. מידע נוסף זמין במאמר בנושא GrammaticalInflectionManager.

נוסף ברמת API‏ 34.
"keyboard" שינוי בסוג המקלדת, למשל כשמשתמש מחבר מקלדת חיצונית.
"keyboardHidden" שינוי בנגישות של המקלדת, למשל כשהמשתמש חושף את מקלדת החומרה.
"layoutDirection"

שינוי כיוון הפריסה, למשל משמאל לימין (LTR) לימין לשמאל (RTL).

נוסף ברמת API‏ 17.
"locale" שינוי הלוקאל, למשל כשמשתמש בוחר שפה חדשה שבה הטקסט יוצג.
"mcc" שינוי בקוד מדינה של רשת סלולרית (MCC) של ה-IMSI לנייד כשמזוהה כרטיס SIM שמעדכן את ה-MCC.
"mnc" שינוי בקוד הרשת הסלולרית (MNC) של IMSI כשמזוהה כרטיס SIM שמעדכן את ה-MNC.
"navigation" שינוי סוג הניווט (כדור עקיבה או כפתורי החיצים (D-pad)). בדרך כלל זה לא קורה.
"orientation"

שינוי בכיוון המסך, למשל כשהמשתמש מסובב את המכשיר.

הערה: אם האפליקציה מיועדת ל-Android 3.2 (רמת API 13) ומעלה, צריך להצהיר גם על ההגדרות "screenLayout" ו-"screenSize", כי פריסת המסך וגודל המסך יכולים להשתנות כשמכשיר עובר בין מצב לאורך למצב לרוחב.
"screenLayout" שינוי בפריסת המסך, למשל כשמסך אחר הופך לפעיל.
"screenSize"

שינוי בגודל המסך הנוכחי שזמין.

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

נוסף ברמת API‏ 13.
"smallestScreenSize"

שינוי בגודל המסך הפיזי.

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

נוסף ברמת API‏ 13.
"touchscreen" שינוי במצב מסך המגע, למשל כשמשתמש מחבר או מנתק ציוד היקפי לקלט או מעביר את האפליקציה בין מסכים שונים.
"uiMode" שינוי במצב ממשק המשתמש, למשל כשמשתמש מניח את המכשיר במעמד שולחני או במעמד לרכב, או כשמצב הלילה משתנה. מידע נוסף על מצבי ממשק המשתמש השונים זמין במאמר UiModeManager.

נוספה ברמת API‏ 8.

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

הערה: כדי לטפל בשינויים בהגדרות שקשורים לריבוי חלונות, צריך להשתמש גם ב-"screenLayout" וגם ב-"smallestScreenSize". ריבוי חלונות נתמך ב-Android מגרסה 7.0 (רמת API‏ 24) ואילך.

android:directBootAware

האם הפעילות מודעת להפעלה ישירה – כלומר, האם היא יכולה לפעול לפני שהמשתמש פותח את נעילת המכשיר.

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

ערך ברירת המחדל הוא "false".

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

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

ערך תיאור
"intoExisting" המערכת מחפשת משימה ש-Base Intent שלה ComponentName ו-Data URI תואמים לאלה של ה-Intent שמופעל. אם המערכת מוצאת משימה כזו, היא מנקה את המשימה ומפעילה מחדש את המכשיר, והפעילות הבסיסית מקבלת קריאה ל-onNewIntent(android.content.Intent). אם המערכת לא מוצאת משימה כזו, היא יוצרת משימה חדשה.
"always" הפעילות יוצרת משימה חדשה למסמך, גם אם המסמך כבר פתוח. ההגדרה הזו זהה להגדרת הדגלים FLAG_ACTIVITY_NEW_DOCUMENT ו-FLAG_ACTIVITY_MULTIPLE_TASK.
"none" הפעילות לא יוצרת משימה חדשה לפעילות. זהו ערך ברירת המחדל, שיוצר משימה חדשה רק אם הערך FLAG_ACTIVITY_NEW_TASK מוגדר. במסך 'אחרונים' הפעילות מוצגת כמו שהיא מוצגת כברירת מחדל: משימה אחת מוצגת עבור האפליקציה, והיא ממשיכה מכל פעילות שהמשתמש הפעיל לאחרונה.
"never" הפעילות לא מופעלת במסמך חדש גם אם הכוונה מכילה את FLAG_ACTIVITY_NEW_DOCUMENT. ההגדרה הזו מבטלת את ההתנהגות של הדגלים FLAG_ACTIVITY_NEW_DOCUMENT ו-FLAG_ACTIVITY_MULTIPLE_TASK, אם אחד מהם מוגדר בפעילות, ובמסך הפריטים האחרונים מוצגת משימה אחת לאפליקציה, שממשיכה מכל פעילות שהמשתמש הפעיל לאחרונה.

הערה: אם הערכים שמוזנים שונים מ-"none" ומ-"never", הפעילות מוגדרת באמצעות launchMode="standard". אם לא מציינים את המאפיין הזה, המערכת משתמשת בערך documentLaunchMode="none".

android:enabled
האם המערכת יכולה ליצור מופע של הפעילות. אם אפשר, כותבים "true". אם אי אפשר, כותבים "false". ערך ברירת המחדל הוא "true".

לרכיב <application> יש מאפיין משלו enabled שחל על כל רכיבי האפליקציה, כולל פעילויות. כדי שהמערכת תוכל ליצור מופע של הפעילות, שני המאפיינים <application> ו-<activity> חייבים להיות "true", כמו שהם כברירת מחדל. אם אחד מהם הוא "false", אי אפשר ליצור מופע שלו.

android:enableOnBackInvokedCallback

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

מגדירים את android:enableOnBackInvokedCallback=false כדי להשבית את האנימציות של חיזוי החזרה ברמת הפעילות, ומנחים את המערכת להתעלם מקריאות ל-API של פלטפורמת OnBackInvokedCallback.

android:excludeFromRecents

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

android:exported

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

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

אם פעילות באפליקציה שלכם כוללת מסנני Intent, צריך להגדיר את הרכיב הזה לערך "true" כדי לאפשר לאפליקציות אחרות להפעיל אותה. לדוגמה, אם הפעילות היא הפעילות הראשית של האפליקציה וכוללת את category android.intent.category.LAUNCHER.

אם הרכיב הזה מוגדר ל-"false" ואפליקציה מנסה להפעיל את הפעילות, המערכת מציגה ActivityNotFoundException.

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

android:finishOnTaskLaunch
האם מופסקת פעילות קיימת של המשימה, למעט פעילות השורש, כשהמשתמש מפעיל מחדש את המשימה על ידי בחירת המשימה במסך הבית. אם המכשיר כבוי, כותבים "true". אם הוא לא כבוי, כותבים "false". ערך ברירת המחדל הוא "false".

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

המערכת מתעלמת מהמאפיין הזה אם לא מוגדר FLAG_ACTIVITY_RESET_TASK_IF_NEEDED.

android:hardwareAccelerated
האם העיבוד מואץ באמצעות חומרה בפעילות הזו. ‫"true" אם היא מופעלת, ו-"false" אם לא. ערך ברירת המחדל הוא "false".

ב-Android מגרסה 3.0 ואילך, יש אפשרות להשתמש במעבד OpenGL עם האצת חומרה באפליקציות כדי לשפר את הביצועים של פעולות גרפיקה דו-ממדיות נפוצות רבות. כשמעבד התצוגה שמואץ על ידי חומרה מופעל, רוב הפעולות ב-Canvas,‏ Paint,‏ Xfermode,‏ ColorFilter,‏ Shader ו-Camera מואצות.

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

לא כל הפעולות של OpenGL 2D מואצות. אם מפעילים את רכיב ה-Renderer עם האצת חומרה, צריך לבדוק אם האפליקציה יכולה להשתמש ברכיב ה-Renderer בלי שגיאות.

android:icon

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

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

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

android:immersive
מגדיר את ההגדרה של מצב ההפעלה המלאה לפעילות הנוכחית. אם הערך הוא "true", הביט ActivityInfo.flags של החבר תמיד מוגדר, גם אם מצב התצוגה התלת-ממדית משתנה בזמן הריצה באמצעות השיטה setImmersive().FLAG_IMMERSIVE
android:label

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

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

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

android:launchMode

הוראה להפעלת הפעילות. יש חמישה מצבים, שפועלים בשילוב עם דגלי פעילות (קבועים של FLAG_ACTIVITY_*) באובייקטים של Intent כדי לקבוע מה קורה כשקוראים לפעילות לטפל ב-Intent:

"standard"
"singleTop"
"singleTask"
"singleInstance"
"singleInstancePerTask"

מצב ברירת המחדל הוא "standard".

כפי שמוצג בטבלה הבאה, המצבים מחולקים לשתי קבוצות עיקריות: פעילויות ב-"standard" וב-"singleTop" מצד אחד, ופעילויות ב-"singleTask", ב-"singleInstance" וב-"singleInstancePerTask" מצד שני. אפשר ליצור כמה מופעים של פעילות עם מצב ההפעלה "standard" או "singleTop".

המופעים יכולים להשתייך לכל משימה, ויכולים להיות ממוקמים בכל מקום במשימת הפעילות. בדרך כלל, הם מופעלים במשימה שקראה ל-startActivity(), אלא אם האובייקט Intent מכיל הוראה FLAG_ACTIVITY_NEW_TASK, ובמקרה כזה נבחרת משימה אחרת. מידע נוסף זמין במאמר בנושא מאפיין taskAffinity.

לעומת זאת, הפעילויות ב-"singleTask", ב-"singleInstance" וב-"singleInstancePerTask" מתנהלות בצורה שונה. "singleInstancePerTask" תמיד נמצא בשורש של משימת הפעילות. בנוסף, במכשיר יכולה להיות רק פעילות אחת מסוג "singleInstance" בכל פעם, אבל אפשר ליצור כמה מופעים של פעילות מסוג "singleInstancePerTask במשימות שונות אם מוגדר FLAG_ACTIVITY_MULTIPLE_TASK או FLAG_ACTIVITY_NEW_DOCUMENT.

פעילות עם "singleTask" מצב ההפעלה משלבת את ההתנהגויות של "singleInstance" ושל "singleInstancePerTask": אפשר ליצור מופעים של הפעילות מספר פעמים, והיא יכולה להיות ממוקמת בכל מקום במשימה של אותו taskAffinity. אבל המכשיר יכול להכיל רק משימה אחת לאיתור הפעילות "singleTask" בשורש של משימת הפעילות.

יש הבדל אחד בין מצב "standard" לבין מצב "singleTop": בכל פעם שיש כוונה חדשה לפעילות "standard", נוצר מופע חדש של המחלקה כדי להגיב לכוונה הזו. כל מופע מטפל בכוונה אחת. באופן דומה, אפשר ליצור מופע חדש של פעילות "singleTop" כדי לטפל ב-Intent חדש.

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

באופן דומה, אם המשתמש עובר למעלה לפעילות במחסנית הנוכחית, ההתנהגות נקבעת לפי מצב ההפעלה של פעילות האב. אם לפעילות ההורה יש מצב הפעלה singleTop (או שה-intent up מכיל FLAG_ACTIVITY_CLEAR_TOP), ההורה מועבר לראש המחסנית והמצב שלו נשמר.

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

מצב "singleInstance" שונה ממצבי ההפעלה "singleTask" ו-"singleInstancePerTask" רק בהיבט אחד: פעילות עם מצב הפעלה "singleTask" או "singleInstancePerTask" מאפשרת לפעילויות אחרות, בהכרח פעילויות "standard" ו-"singleTop", להיות חלק מהמשימה שלה.

לעומת זאת, פעילות מסוג A "singleInstance" לא מאפשרת לפעילויות אחרות להיות חלק מהמשימה שלה. זו חייבת להיות הפעילות היחידה במשימה. אם הוא מתחיל פעילות אחרת, הפעילות הזו משויכת למשימה אחרת, כאילו FLAG_ACTIVITY_NEW_TASK היה בכוונת המשתמש.

תרחישים לדוגמה מצב הפעלה כמה מקרים? תגובות
השקות רגילות לרוב הפעילויות "standard" כן ברירת מחדל. המערכת תמיד יוצרת מופע חדש של הפעילות במשימת היעד ומנתבת אליו את הכוונה.
"singleTop" באופן מותנה אם מופע של הפעילות כבר קיים בראש משימת היעד, המערכת מעבירה את ה-intent למופע הזה באמצעות קריאה לשיטה onNewIntent() שלו, במקום ליצור מופע חדש של הפעילות.
השקות מיוחדות
(לא מומלץ לשימוש כללי)		 "singleTask" באופן מותנה המערכת יוצרת את הפעילות בשורש של משימה חדשה או מאתרת את הפעילות במשימה קיימת עם אותה קרבה. אם מופע של הפעילות כבר קיים והוא נמצא ברמת הבסיס של המשימה, המערכת מעבירה את הכוונה למופע הקיים באמצעות קריאה לשיטה onNewIntent() שלו, במקום ליצור מופע חדש.
"singleInstance" לא זהה ל-"singleTask", אלא שהמערכת לא מפעילה פעילויות אחרות במשימה שמכילה את המופע. הפעילות היא תמיד החברה היחידה במשימה.
"singleInstancePerTask" באופן מותנה הפעילות יכולה לפעול רק כפעילות הבסיס של המשימה, הפעילות הראשונה שיצרה את המשימה, ולכן יש רק מופע אחד של הפעילות הזו במשימה. עם זאת, אפשר ליצור מופעים של הפעילות כמה פעמים במשימות שונות.

כפי שמוצג בטבלה הקודמת, "standard" הוא מצב ברירת המחדל והוא מתאים לרוב סוגי הפעילויות. ‫"singleTop" הוא גם מצב הפעלה נפוץ ושימושי עבור סוגים רבים של פעילויות. המצבים האחרים, "singleTask", "singleInstance" ו-"singleInstancePerTask", לא מתאימים לרוב האפליקציות. הן יוצרות מודל אינטראקציה שסביר להניח שיהיה לא מוכר למשתמשים ושונה מאוד מרוב האפליקציות האחרות.

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

מידע נוסף על מצבי הפעלה ועל האינטראקציה שלהם עם Intent flags זמין במאמר משימות ומקבץ הפעילויות הקודמות (back stack).

android:lockTaskMode
ההגדרה הזו קובעת איך המערכת מציגה את ה-Activity הזו כשהמכשיר פועל במצב משימות נעולות (lock task mode).

ב-Android אפשר להריץ משימות במצב אימרסיבי שדומה לקיוסק, שנקרא מצב משימות נעולות (lock task mode). כשהמערכת פועלת במצב משימות נעולות (lock task mode), בדרך כלל משתמשי המכשיר לא יכולים לראות התראות, לגשת לאפליקציות שלא נוספו לרשימת ההיתרים או לחזור למסך הבית, אלא אם אפליקציית Home נוספה לרשימת ההיתרים.

רק אפליקציות שנכללות ברשימת ההיתרים של בקר מדיניות המכשיר (DPC) יכולות לפעול כשהמערכת נמצאת במצב משימות נעולות (lock task mode). אבל אפליקציות מערכת ואפליקציות בעלות הרשאות יכולות לפעול במצב משימות נעולות (lock task mode) בלי להיכלל ברשימת ההיתרים.

הערך יכול להיות כל אחת מהמחרוזות הבאות: R.attr.lockTaskMode

ערך תיאור
"normal" ערך ברירת מחדל. זה ערך ברירת המחדל. המשימות לא מופעלות במצב משימות נעולות (lock task mode), אבל אפשר להעביר אותן לשם באמצעות הקריאה startLockTask().
"never"

אי אפשר להפעיל את Tasks במצב lockTask, והמשתמש במכשיר לא יכול להצמיד את המשימות האלה ממסך הפעולות האחרונות.

הערה: המצב הזה זמין רק לאפליקציות מערכת ולאפליקציות עם הרשאות מיוחדות. אפליקציות ללא הרשאות עם הערך הזה נחשבות כnormal.
"if_whitelisted" אם ה-DPC מאשר את החבילה הזו באמצעות DevicePolicyManager.setLockTaskPackages(), המצב הזה זהה למצב always, אלא שהפעילות צריכה לקרוא ל-stopLockTask() לפני שהיא יכולה להסתיים אם היא המשימה הנעולה האחרונה. אם ה-DPC לא מאשר את החבילה הזו, המצב הזה זהה לnormal.
"always"

משימות שמתחילות בפעילות הזו תמיד מופעלות במצב משימות נעולות (lock task mode). אם המערכת כבר במצב נעילת משימות כשהמשימה הזו מופעלת, המשימה החדשה מופעלת מעל המשימה הנוכחית. משימות שהושקו במצב זה יכולות לצאת ממצב משימות נעולות (lock task mode) באמצעות קריאה ל-finish().

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

המאפיין הזה נוסף ברמת API‏ 23.

android:maxRecents
מספר המשימות המקסימלי שמתחילות בפעילות הזו ב מסך הפריטים האחרונים. כשמגיעים למספר הזה של רשומות, המערכת מסירה מהמסך 'פריטים אחרונים' את המופע שהשימוש בו היה הכי מזמן. הערכים התקינים הם מספרים שלמים מ-1 עד 50, או מ-1 עד 25 במכשירים עם זיכרון נמוך. הערך אפס לא תקין. ערך ברירת המחדל הוא 16.
android:maxAspectRatio

יחס הגובה-רוחב המקסימלי שהפעילות תומכת בו.

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

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

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

מידע נוסף על המאפיין הזה זמין במאמר בנושא R.attr.maxAspectRatio.

android:minAspectRatio

יחס הגובה-רוחב המינימלי שהפעילות תומכת בו.

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

יחס הגובה-רוחב המינימלי מבוטא כערך העשרוני של מנת המידה הארוכה ביותר של המכשיר חלקי המידה הקצרה ביותר שלו. לדוגמה, אם יחס הגובה-רוחב של המסך הוא 4:3, צריך להגדיר את הערך המינימלי של יחס הגובה-רוחב ל-1.33.

הערך חייב להיות גדול מ-1.0 או שווה לו, אחרת המערכת מתעלמת מהערך שהוגדר.

מידע נוסף על המאפיין הזה זמין במאמר בנושא R.attr.minAspectRatio.

android:multiprocess
אם אפשר להפעיל מופע של הפעילות בתהליך של הרכיב שהפעיל אותה. אם אפשר, כותבים "true". אם אי אפשר, כותבים "false". ערך ברירת המחדל הוא "false".

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

android:name
השם של המחלקה שמטמיעה את הפעילות, מחלקת משנה של Activity. ערך המאפיין הוא בדרך כלל שם מחלקה מלא, כמו "com.example.project.ExtracurricularActivity". עם זאת, אם התו הראשון בשם הוא נקודה, כמו ".ExtracurricularActivity", הוא מתווסף למרחב השמות שצוין בקובץ build.gradle.

אחרי שמפרסמים את האפליקציה, לא משנים את השם הזה, אלא אם מגדירים את android:exported="false". אין ברירת מחדל. חובה לציין את השם.

android:noHistory
האם הפעילות מוסרת ממערך הפעילויות ומסתיימת על ידי קריאה לשיטת finish() שלה, כשהמשתמש עובר ממנה והיא כבר לא מוצגת במסך. הערך הוא"true" אם הפעולה הסתיימה, ו-"false" אם לא. ערך ברירת המחדל הוא "false".

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

המאפיין הזה נוסף ברמת API‏ 3.

android:parentActivityName
השם של המחלקה הלוגית הראשית של הפעילות. השם שמופיע כאן צריך להיות זהה לשם המחלקה שמופיע במאפיין android:name של רכיב <activity> התואם.

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

כדי לתמוך ברמות API‏ 4 עד 16, אפשר גם להצהיר על פעילות האב באמצעות אלמנט <meta-data> שמציין ערך ל-"android.support.PARENT_ACTIVITY":

<activity
    android:name="com.example.app.ChildActivity"
    android:label="@string/title_child_activity"
    android:parentActivityName="com.example.app.MainActivity" >
    <!-- Parent activity meta-data to support API level 4+ -->
    <meta-data
        android:name="android.support.PARENT_ACTIVITY"
        android:value="com.example.app.MainActivity" />
</activity>

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

המאפיין הזה נוסף ברמת API‏ 16.

android:persistableMode

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

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

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

ערך תיאור
persistRootOnly

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

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

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

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

כש-Intent טוען פעילות שהמאפיין persistableMode שלה מוגדר ל-persistAcrossReboots באפליקציה, הפעילות מקבלת אובייקט PersistableBundle בשיטה onCreate() שלה. לכן, אפשר להשתמש ב-onSaveInstanceState() כדי לשמור את מצב הפעילות גם אחרי הפעלה מחדש של המכשיר, כל עוד המאפיין persistableMode מוגדר לערך persistAcrossReboots.

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

מצב הפעילות לא נשמר.

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

המאפיין הזה הוצג ברמת API‏ 21.

android:permission
שם ההרשאה שהלקוחות צריכים לקבל כדי להפעיל את הפעילות או כדי לגרום לה להגיב ל-Intent. אם למתקשר של startActivity() או של startActivityForResult() לא ניתנת ההרשאה שצוינה, ה-Intent שלו לא מועבר לפעילות.

אם לא מגדירים את המאפיין הזה, ההרשאה שמוגדרת במאפיין permission של רכיב <application> חלה על הפעילות. אם לא מוגדר אף אחד מהמאפיינים, הפעילות לא מוגנת על ידי הרשאה.

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

android:process

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

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

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

במאפיין process של הרכיב <application> אפשר להגדיר שם תהליך שונה כברירת מחדל לכל הרכיבים.

android:relinquishTaskIdentity

האם הפעילות מוותרת על מזהי המשימות שלה לטובת פעילות שמעליה במחסנית המשימות. משימה שפעילות הבסיס שלה כוללת את המאפיין הזה עם הערך "true" מחליפה את פעילות הבסיס Intent בפעילות הבאה במשימה.

אם הפעילות הבאה כוללת גם את המאפיין הזה עם הערך "true", היא מחזירה את הבסיס Intent לכל פעילות שהיא מפעילה באותה משימה. התהליך הזה נמשך לכל פעילות עד שמגיעים לפעילות שבה המאפיין הזה מוגדר לערך "false". ערך ברירת המחדל הוא "false".

המאפיין הזה מוגדר כ-"true", והוא גם מאפשר להשתמש בActivityManager.TaskDescription בפעילות כדי לשנות תוויות, צבעים וסמלים במסך הפריטים האחרונים.

android:requireContentUriPermissionFromCaller

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

שימו לב שהאכיפה פועלת לגבי כתובות URI של תוכן בתוך Intent.getData(), Intent.EXTRA_STREAM, ו- Intent.getClipData().

יכול להיות ערך מחרוזת, עם '\\;' לסימון תווי בריחה כמו '\\n' או '\\uxxxx' לתו unicode;

חייב להיות אחד מהערכים הקבועים הבאים.

קבוע ערך תיאור
ללא 0 כברירת מחדל, לא נדרשות הרשאות ספציפיות.
קריאה 1 הפעולה הזו מחייבת את המפעיל לקבל גישת קריאה למזהי ה-URI של התוכן שהועבר.
readAndWrite 4 הפונקציה מחייבת שלמפעיל תהיה הרשאת קריאה והרשאת כתיבה לכתובות ה-URI של התוכן שמועבר.
readOrWrite 3 ההרשאה מחייבת את המפעיל לקבל גישת קריאה או כתיבה לכתובות ה-URI של התוכן שהועבר.
לכתוב 2 ההרשאה הזו מחייבת את המפעיל לקבל הרשאת כתיבה למזהי ה-URI של התוכן שהועבר.
android:resizeableActivity

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

אפשר להגדיר את המאפיין הזה ברכיב <activity> או ברכיב <application>.

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

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

אם האפליקציה מטרגטת רמת API‏ 24 ומעלה ולא מציינים ערך למאפיין הזה, ערך ברירת המחדל של המאפיין הוא "true".

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

  • מסכים גדולים (רוחב >= 600dp): כל האפליקציות תומכות במצב ריבוי חלונות. המאפיין מציין אם אפשר לשנות את גודל האפליקציה, ולא אם האפליקציה תומכת במצב ריבוי חלונות. אם resizeableActivity="false", האפליקציה עוברת למצב תאימות כשצריך כדי להתאים למידות המסך.
  • מסכים קטנים (sw < 600dp): אם הערך של resizeableActivity="true" והרוחב המינימלי והגובה המינימלי של הפעילות עומדים בדרישות של מצב ריבוי חלונות, האפליקציה תומכת במצב ריבוי חלונות. אם הערך הוא resizeableActivity="false", האפליקציה לא תומכת במצב מרובה חלונות, ללא קשר לרוחב ולגובה המינימליים של הפעילות.

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

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

android:screenOrientation

הכיוון המבוקש של הפעילות.

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

במצב מרובה חלונות, הכיוון המבוקש לא משמש כהצעה לכיוון הכללי. אם הפעילות בפורמט letterbox, האוריינטציה המבוקשת משפיעה על ה-letterboxing שמוחל על הפעילות.

הערך יכול להיות אחת מהמחרוזות הבאות:

"unspecified" ערך ברירת המחדל. המערכת בוחרת את הכיוון. המדיניות שבה הוא משתמש, ולכן הבחירות שנעשות בהקשרים ספציפיים, עשויות להיות שונות ממכשיר למכשיר.
"behind" אותו כיוון כמו הפעילות שנמצאת מיד מתחתיה ברשימת הפעילויות (activity stack).
"landscape" כיוון לרוחב (התצוגה רחבה יותר מאשר גבוהה).
"portrait" כיוון לאורך (התצוגה גבוהה יותר מאשר רחבה).
"reverseLandscape" כיוון לרוחב בכיוון ההפוך מהכיוון הרגיל לרוחב. נוסף ברמת API‏ 9.
"reversePortrait" כיוון לאורך בכיוון ההפוך מכיוון לאורך רגיל. נוסף ברמת API‏ 9.
"sensorLandscape" כיוון לרוחב, אבל יכול להיות רגיל או הפוך לרוחב בהתאם לחיישן המכשיר. החיישן נמצא בשימוש גם אם המשתמש נעל את הסיבוב שמבוסס על חיישן. נוסף ברמת API‏ 9.
"sensorPortrait" פורמט לאורך, אבל יכול להיות פורמט רגיל או הפוך לאורך בהתאם לחיישן המכשיר. החיישן נמצא בשימוש גם אם המשתמש נעל את הסיבוב שמבוסס על חיישן. עם זאת, יכול להיות שסיבוב הפוך לא יתאפשר בהתאם לתצורת המכשיר. נוסף ברמת API‏ 9.
"userLandscape" הכיוון הוא לרוחב, אבל יכול להיות לרוחב רגיל או לרוחב הפוך בהתאם לחיישן המכשיר ולהעדפת המשתמש. נוסף ברמת API‏ 18.
"userPortrait" תצוגה לאורך, אבל יכולה להיות רגילה או הפוכה בהתאם לחיישן המכשיר ולהעדפת המשתמש. עם זאת, יכול להיות שסיבוב הפוך לא יתאפשר, בהתאם להגדרות המכשיר. נוסף ברמת API‏ 18.
"sensor" הכיוון נקבע על ידי חיישן הכיוון של המכשיר. הכיוון של התצוגה תלוי באופן שבו המשתמש מחזיק את המכשיר. הוא משתנה כשהמשתמש מסובב את המכשיר. עם זאת, בחלק מהמכשירים, כברירת מחדל, המסך לא מסתובב לכל ארבעת הכיוונים האפשריים. כדי להשתמש בכל ארבעת הכיוונים, צריך להשתמש ב-"fullSensor". החיישן נמצא בשימוש גם אם המשתמש נעל את הסיבוב שמבוסס על החיישן.
"fullSensor" חיישן הכיוון של המכשיר קובע את הכיוון מתוך ארבעת הכיוונים האפשריים. התכונה הזו דומה ל-"sensor", אבל היא מאפשרת להשתמש בכל אחד מארבעת כיווני המסך האפשריים, בלי קשר למה שהמכשיר תומך בו בדרך כלל. לדוגמה, במכשירים מסוימים לא נעשה בדרך כלל שימוש בהצגה הפוכה של מצב אנכי או אופקי, אבל ההגדרה הזו מאפשרת את כיווני המסך האלה. נוסף ברמת API‏ 9.
"nosensor" הכיוון נקבע בלי להתייחס לחיישן כיוון פיזי. המערכת מתעלמת מהחיישן, ולכן המסך לא מסתובב בהתאם לאופן שבו המשתמש מזיז את המכשיר.
"user" ההתמצאות המועדפת הנוכחית של המשתמש.
"fullUser" אם המשתמש נעל את הסיבוב שמבוסס על חיישן, ההתנהגות זהה ל-user, אחרת ההתנהגות זהה ל-fullSensor ומאפשרת כל אחת מארבע האפשרויות של כיוון המסך. נוסף ברמת API‏ 18.
"locked" הכיוון ננעל לסיבוב הנוכחי, לא משנה מהו. נוסף ברמת API‏ 18.

הערה: כשמצהירים על אחד מהערכים של מצב אופקי או אנכי, הוא נחשב לדרישה מחייבת לגבי האוריינטציה שבה הפעילות מופעלת. הערך שאתם מציינים מאפשר סינון לפי שירותים כמו Google Play, כך שהאפליקציה שלכם זמינה רק למכשירים שתומכים בכיוון שנדרש לפעילויות שלכם. לדוגמה, אם מצהירים על "landscape",‏ "reverseLandscape" או "sensorLandscape", האפליקציה זמינה רק למכשירים שתומכים בכיוון לרוחב.

בנוסף, צריך להצהיר באופן מפורש שהאפליקציה דורשת כיוון לאורך או לרוחב באמצעות רכיב <uses-feature>, כמו <uses-feature android:name="android.hardware.screen.portrait"/>. זהו אופן סינון שמוגדר על ידי Google Play ושירותים אחרים שתומכים בו, והפלטפורמה עצמה לא קובעת אם אפשר להתקין את האפליקציה כשמכשיר תומך רק בכיוונים מסוימים.

android:showForAllUsers

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

המאפיין הזה נוסף ברמת API ‏23.

android:stateNotNeeded
האם אפשר להפסיק את הפעילות ולהפעיל אותה מחדש בהצלחה בלי לשמור את המצב שלה. הערך הוא "true" אם אפשר להפעיל מחדש את המכונה בלי להתייחס למצב הקודם שלה, ו-"false" אם נדרש המצב הקודם שלה. ערך ברירת המחדל הוא "false".

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

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

android:supportsPictureInPicture

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

android:taskAffinity

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

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

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

אם לא מגדירים את המאפיין הזה, הפעילות מקבלת בירושה את הקשר שמוגדר לאפליקציה. אפשר לעיין במאפיין taskAffinity של רכיב <application>. השם של ההעדפה שמוגדרת כברירת מחדל לשיוך אפליקציה הוא מרחב השמות שמוגדר בקובץ build.gradle.

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

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

android:uiOptions

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

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

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

המאפיין הזה נוסף ברמת API‏ 14.

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

ההגדרה צריכה להיות אחד מהערכים שמפורטים בטבלה הבאה או שילוב של ערך "state..." אחד וערך "adjust..." אחד. הגדרת כמה ערכים בכל אחת מהקבוצות, כמו כמה ערכי "state...", תניב תוצאות לא מוגדרות. הערכים הנפרדים מופרדים באמצעות קו אנכי (|), כמו בדוגמה הבאה: 

<activity android:windowSoftInputMode="stateVisible|adjustResize" ... >

ערכים שמוגדרים כאן (חוץ מ-"stateUnspecified" ומ-"adjustUnspecified") מבטלים את הערכים שמוגדרים בערכת הנושא.

ערך תיאור
"stateUnspecified" לא מצוין אם המקלדת הווירטואלית מוסתרת או גלויה. המערכת בוחרת מצב מתאים או מסתמכת על ההגדרה בעיצוב.

זוהי הגדרת ברירת המחדל להתנהגות של המקלדת הווירטואלית.

"stateUnchanged" המקלדת הווירטואלית נשארת במצב האחרון שלה, גלויה או מוסתרת, כשהפעילות עוברת לחזית.
"stateHidden" המקלדת הווירטואלית מוסתרת כשהמשתמש בוחר את הפעילות – כלומר, כשהמשתמש מנווט קדימה אל הפעילות, ולא כשהוא חוזר אליה כשיוצאים מפעילות אחרת.
"stateAlwaysHidden" המקלדת הווירטואלית תמיד מוסתרת כשהחלון הראשי של הפעילות כולל פוקוס קלט.
"stateVisible" המקלדת הווירטואלית מוצגת כשהמשתמש בוחר את הפעילות – כלומר, כשהמשתמש מנווט קדימה אל הפעילות, ולא כשהוא חוזר אליה אחרי שעזב פעילות אחרת.
"stateAlwaysVisible" המקלדת הווירטואלית מוצגת כשהחלון מקבל את מיקוד הקלט.
"adjustUnspecified" לא מצוין אם הגודל של החלון הראשי של הפעילות משתנה כדי לפנות מקום למקלדת הווירטואלית, או שהתוכן של החלון מוזז כדי שהמיקום הנוכחי של הפוקוס יהיה גלוי על המסך. המערכת בוחרת אוטומטית באחד מהמצבים האלה, בהתאם לשאלה אם יש בחלון תצוגות פריסה שאפשר לגלול את התוכן שלהן. אם יש תצוגה כזו, גודל החלון ישתנה, מתוך הנחה שגלילה יכולה להפוך את כל התוכן של החלון לגלוי באזור קטן יותר.

זוהי הגדרת ברירת המחדל להתנהגות של החלון הראשי.

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

המאפיין הזה נוסף ברמת API‏ 3.

הושק ב:
רמת API‏ 1 לכל המאפיינים חוץ מnoHistory ומ-windowSoftInputMode, שנוספו ברמת API‏ 3.
ראו גם:
<application>
<activity-alias>