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

android:allowEmbedded

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

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

android:allowTaskReparenting

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

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

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

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

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

android:alwaysRetainTaskState

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

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

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

android:autoRemoveFromRecents

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

android:banner

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

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

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

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

android:canDisplayOnRemoteDevices

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

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

android:clearTaskOnLaunch

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

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

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

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

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

android:colorMode

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

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

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

android:configChanges

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

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

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

ערך	תיאור
"colorMode"	היכולות של מצב הצבעים במסך (לוח צבעים או טווח דינמי) השתנו. הערה: מצב הצבע שעליו הפעילות מבקשת באמצעות המאפיין colorMode או בזמן הריצה שונה מהיכולת של מצבי הצבע השונים. פעילות שמשנה את מצב הצבע שבו היא משתמשת לא גורמת לשינוי הגדרה, כי יכולות הצבעים של המסך לא השתנו.
"density"	שינוי בצפיפות התצוגה, למשל כאשר המשתמש מציין סולם תצוגה שונה או מסך אחר פעילים עכשיו. נוספה ברמת API 24.
"fontScale"	שינוי בגורם לשינוי גודל הגופן, למשל בזמן שהמשתמש בוחר גודל גופן גלובלי חדש.
"fontWeightAdjustment"	הגדלת עובי הגופן השתנתה.
"grammaticalGender"	המגדר הדקדוקי של השפה השתנה. צפייה GrammaticalInflectionManager נוסף ברמת API 34.
"keyboard"	שינוי בסוג המקלדת, למשל בזמן שהמשתמש מחבר מקלדת חיצונית.
"keyboardHidden"	שינוי בנגישות המקלדת, למשל בזמן משתמש חושף את מקלדת החומרה.
"layoutDirection"	שינוי בכיוון הפריסה, למשל, מ- מימין לשמאל (LTR) מימין לשמאל (RTL). נוסף ברמת API 17.
"locale"	שינוי במיקום, למשל כשמשתמש בוחר מיקום חדש השפה שבה הטקסט מוצג.
"mcc"	שינוי בקוד המדינה של IMSI לניידים (MCC) כאשר כשזוהה כרטיס SIM שמעדכן את חשבון הניהול (MCC).
"mnc"	שינוי בקוד הרשת הסלולרית של IMSI (MNC) כאשר זוהה כרטיס SIM שמעדכנים את ה-MNC.
"navigation"	שינוי TA בסוג הניווט (כדור עקיבה או לחצני החיצים). בדרך כלל זה לא קורה.
"orientation"	שינוי בכיוון המסך, למשל כשהמשתמש מסובב את המכשיר. הערה: אם האפליקציה שלכם מטרגטת גם ב-Android מגרסה 3.2 (רמת API 13) ואילך יש הצהרה על ההגדרות של "screenLayout" ו-"screenSize", כי פריסת המסך וגודל המסך יכול להשתנות כאשר המכשיר עובר בין כיוון לאורך לבין כיוון לרוחב.
"screenLayout"	שינוי בפריסת המסך, למשל מצב שבו מסך אחר הופך לפעיל.
"screenSize"	שינוי בגודל המסך הזמין הנוכחי. הדבר מייצג שינוי בגודל הזמין כרגע, ביחס ביחס הגובה-רוחב הנוכחי, ולכן הוא משתנה כשהמשתמש עובר לתצוגה לרוחב ולאורך. נוסף ברמת API 13.
"smallestScreenSize"	שינוי בגודל המסך הפיזי. הדבר מייצג שינוי בגודל ללא קשר לכיוון, כלומר משתנה כשגודל המסך הפיזי בפועל משתנה, למשל מעבר מסך חיצוני. שינוי בתצורה הזו תואם לשינוי ב smallestWidth הגדרה אישית. נוסף ברמת API 13.
"touchscreen"	שינוי במסך המגע. בדרך כלל זה לא קורה.
"uiMode"	שינוי במצב ממשק המשתמש, כגון במצב שבו המשתמש ממקם את המכשיר למחשב שולחני או לאביזר עגינה לרכב, או שמצב הלילה משתנה. לקבלת מידע נוסף על המצבים השונים של ממשק המשתמש: UiModeManager נוסף ברמת API 8.

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

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

android:directBootAware

אם לפעילות יש מוּדעוּת ל-Direct-Boot – כלומר, האם היא יכולה לפעול לפני שהמשתמש מבטל את נעילת המכשיר.

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

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

android:documentLaunchMode

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

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

ערך	תיאור
"intoExisting"	המערכת תחפש משימה שה-ComponentName של ה-Intent הבסיסי שלה וה-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.

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

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

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

android:icon

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

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

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

android:immersive

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

android:label

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

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

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

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" נמצא תמיד ברמה הבסיסית (root) של משימת הפעילות. כמו כן, המכשיר יכול להכיל רק מופע אחד של פעילות של "singleInstance" בבת אחת, בזמן אפשר ליצור מופע של פעילות "singleInstancePerTask מספר פעמים במשימות שונות, FLAG_ACTIVITY_MULTIPLE_TASK או FLAG_ACTIVITY_NEW_DOCUMENT מוגדרת.

פעילות עם מצב ההפעלה "singleTask" משלבת של "singleInstance" "singleInstancePerTask": ניתן ליצור אובייקטים מרובים של הפעילות זמנים והם יכולים להיות ממוקמים בכל מקום במשימה של אותו taskAffinity. עם זאת, המכשיר יכול להכיל רק משימה אחת לאיתור פעילות "singleTask" ברמה הבסיסית (root) של משימת הפעילות.

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

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

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

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

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

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

תרחישים לדוגמה	מצב הפעלה	כמה מופעים?	תגובות
השקות רגילות לרוב הפעילויות	"standard"	כן	ברירת מחדל. המערכת תמיד יוצרת מופע חדש של הפעילות ותנתב את הכוונה אליה.
	"singleTop"	באופן מותנה	אם מופע של הפעילות כבר קיים בחלק העליון של משימת היעד, המערכת מנתבת את הכוונה למכונה הזו באמצעות קריאה ל-method onNewIntent() שלה, במקום ליצור מופע חדש של הפעילות.
השקות מיוחדות (לא מומלץ לשימוש כללי)	"singleTask"	באופן מותנה	המערכת יוצרת את הפעילות ברמה הבסיסית (root) של משימה חדשה או מאתרת את הפעילות במשימה קיימת עם אותו תחום עניין משותף. אם מופע של הפעילות כבר קיים ונמצא בשורש המשימה, המערכת מנתבת את הכוונה למכונה קיימת באמצעות קריאה ל-method 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"	משימות שעברו תהליך רוט (Root) בפעילות הזו תמיד מופעלות במצב 'נעילת משימה'. אם המערכת כבר נעילת מצב המשימה כאשר המשימה הזו מופעלת, המשימה החדשה תופעל מעל המשימה הנוכחית. משימות שמופעלות במצב הזה יכולות לצאת ממצב הנעילה של המשימה באמצעות התקשרות 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

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

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

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

android:parentActivityName

שם הכיתה של ההורה הלוגי של הפעילות. השם כאן חייב להיות זהה לשם של הכיתה השם שניתן לרכיב ה-<activity> התואם android:name.

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

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

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

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

android:permission

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

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

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

android:process

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

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

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

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

android:relinquishTaskIdentity

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

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

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

android:supportsPictureInPicture

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

android:taskAffinity

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

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

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

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

android:theme

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

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

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

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