<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>

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), הפעילות ההורה מועברת לראש הסטאק והמצב שלה נשמר.

הכוונה לניווט מתקבלת על ידי השיטה 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

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

אזהרה: כדי לשפר את הפריסה של אפליקציות בגורמי צורה עם רוחב קטן ביותר של 600dp לפחות, המערכת מתעלמת מהמאפיין הזה באפליקציות שמטרגטות את Android 16 (רמת API 36). אפשר לבטל את ההסכמה של האפליקציה להתנהגות ב-Android 16, אבל האפשרות הזו תבוטל בגרסה עתידית. מצב תאימות למכשיר

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

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

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

הערה:

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

מצב תאימות למכשיר

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

android:minAspectRatio

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

אזהרה: כדי לשפר את הפריסה של אפליקציות בגורמי צורה עם רוחב קטן ביותר של 600dp לפחות, המערכת מתעלמת מהמאפיין הזה באפליקציות שמטרגטות את Android 16 (רמת API 36). אפשר לבטל את ההסכמה של האפליקציה להתנהגות ב-Android 16, אבל האפשרות הזו תבוטל בגרסה עתידית. מצב תאימות למכשיר

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

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

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

הערה:

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

מצב תאימות למכשיר

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

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. הערה: ערך המאפיין הזה משפיע על ההתנהגות של האפליקציה גם אם הוא מוגדר בפעילות שאינה הפעילות ברמה הבסיסית (root) של האפליקציה.
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	אכיפה של הרשאת כתיבה למזהי ה-URI של התוכן שהועברו למפעיל.

android:resizeableActivity

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

אזהרה: כדי לשפר את הפריסה של אפליקציות בגורמי צורה עם רוחב קטן ביותר של 600dp לפחות, המערכת מתעלמת מהמאפיין הזה באפליקציות שמטרגטות את Android 16 (רמת API 36). אפשר לבטל את ההסכמה של האפליקציה להתנהגות ב-Android 16, אבל האפשרות הזו תבוטל בגרסה עתידית. מצב תאימות למכשיר

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

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

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

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

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

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

הערה:

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

מצב תאימות למכשיר

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

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

android:screenOrientation

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

אזהרה: כדי לשפר את הפריסה של אפליקציות בפורמטים עם רוחב קטן ביותר של 600dp ומעלה, המערכת מתעלמת מהערכים הבאים של המאפיין הזה באפליקציות שמטרגטות את Android 16 (רמת API 36):

• portrait
• landscape
• reversePortrait
• reverseLandscape
• sensorPortrait
• sensorLandscape
• userPortrait
• userLandscape

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

הערה:

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

מצב תאימות למכשיר

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

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

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