<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:enabledOnBackInvokedCallback=["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: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>

description:

הצהרה על פעילות (תת-סוג של 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. מכיוון שהבאנר מוצג רק במסך הבית, הוא מצוין רק באפליקציות עם פעילות שמטפלת בכוונה CATEGORY_LEANBACK_LAUNCHER.

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

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

android:canDisplayOnRemoteDevices

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

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

android:clearTaskOnLaunch

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

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

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

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

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

android:colorMode

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

אם הערך הוא hdr, המערכת מבקשת להציג את הפעילות ב-high dynamic range אם המכשיר תומך בכך.

הערה: מטעמי ביצועים, לא מומלץ להפעיל HDR במניפסט. במקום זאת, אם האפליקציה מציגה תמונות HDR, צריך להפעיל את setColorMode() כדי להעביר את הפעילות באופן דינמי למצב HDR בזמן הריצה. למידע נוסף, ראו הצגת תמונות באיכות Ultra 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"	בודקים אם חל שינוי בסוג הניווט (כדורית מעקב או לחצני חיצים). בדרך כלל זה לא קורה.
"orientation"	שינוי בכיוון המסך, למשל כשהמשתמש מסובב את המכשיר. הערה: אם האפליקציה שלכם מטרגטת ל-Android 3.2 (רמת API 13) ואילך, צריך להצהיר גם על ההגדרות "screenLayout" ו-"screenSize", כי הפריסה של המסך וגודל המסך עשויים להשתנות כשהמכשיר עובר בין כיוון לאורך לכיוון לרוחב.
"screenLayout"	שינוי בפריסה של המסך, למשל כשתצוגה אחרת הופכת לפעילה.
"screenSize"	שינוי בגודל המסך הזמין הנוכחי. המדד הזה מייצג שינוי בגודל הזמין כרגע, ביחס ליחס הגובה-רוחב הנוכחי, ולכן הוא משתנה כשהמשתמש עובר בין פורמט לרוחב לפורמט לאורך. נוסף ברמת API 13.
"smallestScreenSize"	שינוי בגודל המסך הפיזי. הוא מייצג שינוי בגודל ללא קשר לכיוון, ולכן הוא משתנה רק כשגודל המסך הפיזי בפועל משתנה, למשל כשעוברים למסך חיצוני. שינוי בתצורה הזו תואם לשינוי בתצורה של smallestWidth. נוסף ברמת API 13.
"touchscreen"	שינוי במסך המגע. בדרך כלל זה לא קורה.
"uiMode"	שינוי במצב של ממשק המשתמש, למשל כאשר המשתמש מציב את המכשיר במטען שולחני או ברכב, או כשמצב הלילה משתנה. מידע נוסף על המצבים השונים של ממשק המשתמש זמין במאמר UiModeManager. נוסף ברמת API 8.

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

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

android:directBootAware

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

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

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

android:documentLaunchMode

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

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

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

android:icon

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

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

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

android:immersive

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

android:label

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

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

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

android:launchMode

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

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

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

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

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

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

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

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

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

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

android:lockTaskMode

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

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

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

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

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

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

android:maxRecents

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

android:maxAspectRatio

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

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

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

הערה: אם הערך של resizeableActivity בפעילות מוגדר כ-true, המערכת מתעלמת מהמאפיין הזה כי המשמעות היא שהפעילות תומכת בכל גודל.

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

android:multiprocess

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

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

android:name

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

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

android:noHistory

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

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

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

android:parentActivityName

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

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

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

ערך	תיאור
persistRootOnly	ערך ברירת המחדל. כשהמערכת מופעלת מחדש, המשימה של הפעילות נשמרת, אבל המערכת משתמשת רק בכוונה ההפעלה של פעילות הבסיס. כשכוונת ההפעלה של האפליקציה טוענת את פעילות הבסיס של האפליקציה, הפעילות לא מקבלת אובייקט PersistableBundle. לכן, אל תשתמשו ב-onSaveInstanceState() כדי לשמור את המצב של פעילות הבסיס של האפליקציה אחרי הפעלה מחדש של המכשיר. הערה: ערך המאפיין הזה משפיע על ההתנהגות של האפליקציה רק אם הוא מוגדר בפעילות הבסיסית של האפליקציה.
persistAcrossReboots	המצב של הפעילות הזו נשמר, יחד עם המצב של כל פעילות שנמצאת בחלק העליון של מקבץ הבקשות, שיש לה מאפיין persistableMode משלה שמוגדר לערך persistAcrossReboots. אם לפעילות אין מאפיין persistableMode שמוגדר לערך persistAcrossReboots, או שהיא מופעלת באמצעות הדגל Intent.FLAG_ACTIVITY_NEW_DOCUMENT, הפעילות הזו, יחד עם כל הפעילויות שמעליה ב-back stack, לא נשמרות. כשכוונת הפעולה טוענת פעילות שהמאפיין persistableMode שלה מוגדר ל-persistAcrossReboots באפליקציה, הפעילות מקבלת אובייקט PersistableBundle בשיטה onCreate() שלה. לכן, אפשר להשתמש ב-onSaveInstanceState() כדי לשמור את המצב של פעילות במהלך הפעלה מחדש של המכשיר, כל עוד המאפיין persistableMode מוגדר לערך persistAcrossReboots. הערה: ערך המאפיין הזה משפיע על ההתנהגות של האפליקציה גם אם הוא מוגדר בפעילות שאינה הפעילות ברמה הבסיסית של האפליקציה.
persistNever	המצב של הפעילות לא נשמר. הערה: ערך המאפיין הזה משפיע על ההתנהגות של האפליקציה רק אם הוא מוגדר בפעילות הבסיסית של האפליקציה.

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

android:permission

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

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

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

android:process

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

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

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

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

android:relinquishTaskIdentity

אם הפעילות מעבירה את מזהי המשימות שלה לפעילות שמעליה ב-task stack. במשימה שבפעילות הבסיס שלה המאפיין הזה מוגדר לערך "true", הערך של Intent הבסיסי מוחלף בערך של הפעילות הבאה במשימה.

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

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

android:requireContentUriPermissionFromCaller

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

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

יכול להיות ערך מחרוזת, באמצעות '‎\\;' כדי לסמן תווים לבריחה (escape), כמו '‎\\n' או ‎'\\uxxxx' עבור תו unicode.

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

קבוע	ערך	תיאור
ללא	0	ברירת המחדל היא שאין צורך בהרשאות ספציפיות.
קריאה	1	אכיפת הדרישה של מבצע הקריאה שיש לו הרשאת קריאה למזהי ה-URI של התוכן שהועברו.
readAndWrite	4	לאכוף על מבצע הקריאה שיש לו גם הרשאת קריאה וגם הרשאת כתיבה לכתובות ה-URI של התוכן שהועברו.
readOrWrite	3	אכיפת הדרישה של מבצע הקריאה להשתמש בגישה לקריאה או לכתיבה לכתובות ה-URI של התוכן שהועברו.
לכתוב	2	האילוץ מחייב את מבצע הקריאה להפעיל (invoker) לקבל הרשאת כתיבה למזהי ה-URI של התוכן שהועברו.

android:resizeableActivity

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

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

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

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

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

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

הערה: יצרני המכשירים יכולים לשנות את ההתנהגות של API ברמה 31.

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

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

android:screenOrientation

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

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

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

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

"unspecified"	ערך ברירת המחדל. המערכת בוחרת את הכיוון. המדיניות שבה הוא משתמש, ולכן הבחירות שהוא מבצע בהקשרים ספציפיים, עשויות להשתנות ממכשיר למכשיר.
"behind"	באותה כיוון כמו הפעילות שמתחתיה בערימה של הפעילויות.
"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".

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

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

android:supportsPictureInPicture

מציין אם הפעילות תומכת בתצוגת תמונה בתוך תמונה.

android:taskAffinity

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

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

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

אם לא מגדירים את המאפיין הזה, הפעילות יורשת את ההתאמה (affinity) שמוגדרת לאפליקציה. במאפיין 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>