<activity>

תחביר:

<activity android:allowEmbedded=["true" | "false"]
          android:allowTaskReparenting=["true" | "false"]
          android:alwaysRetainTaskState=["true" | "false"]
          android:autoRemoveFromRecents=["true" | "false"]
          android:banner="drawable resource"
          android:canDisplayOnRemoteDevices=["true" | "false"]
          android:clearTaskOnLaunch=["true" | "false"]
          android:colorMode=[ "hdr" | "wideColorGamut"]
          android:configChanges=["colorMode", "density",
                                 "fontScale", "fontWeightAdjustment",
                                 "grammaticalGender", "keyboard",
                                 "keyboardHidden", "layoutDirection", "locale",
                                 "mcc", "mnc", "navigation", "orientation",
                                 "screenLayout", "screenSize",
                                 "smallestScreenSize", "touchscreen", "uiMode"]
          android:directBootAware=["true" | "false"]
          android:documentLaunchMode=["intoExisting" | "always" |
                                  "none" | "never"]
          android:enabled=["true" | "false"]
          android:enabledOnBackInvokedCallback=["true" | "false"]
          android:excludeFromRecents=["true" | "false"]
          android:exported=["true" | "false"]
          android:finishOnTaskLaunch=["true" | "false"]
          android:hardwareAccelerated=["true" | "false"]
          android:icon="drawable resource"
          android:immersive=["true" | "false"]
          android:label="string resource"
          android:launchMode=["standard" | "singleTop" |
                              "singleTask" | "singleInstance" | "singleInstancePerTask"]
          android:lockTaskMode=["normal" | "never" |
                              "if_whitelisted" | "always"]
          android:maxRecents="integer"
          android:maxAspectRatio="float"
          android:multiprocess=["true" | "false"]
          android:name="string"
          android:noHistory=["true" | "false"]  
          android:parentActivityName="string" 
          android:persistableMode=["persistRootOnly" | 
                                   "persistAcrossReboots" | "persistNever"]
          android:permission="string"
          android:process="string"
          android:relinquishTaskIdentity=["true" | "false"]
          android:requireContentUriPermissionFromCaller=["none" | "read" | "readAndWrite" |
                                                         "readOrWrite" | "write"] 
          android:resizeableActivity=["true" | "false"]
          android:screenOrientation=["unspecified" | "behind" |
                                     "landscape" | "portrait" |
                                     "reverseLandscape" | "reversePortrait" |
                                     "sensorLandscape" | "sensorPortrait" |
                                     "userLandscape" | "userPortrait" |
                                     "sensor" | "fullSensor" | "nosensor" |
                                     "user" | "fullUser" | "locked"]
          android:showForAllUsers=["true" | "false"]
          android:stateNotNeeded=["true" | "false"]
          android:supportsPictureInPicture=["true" | "false"]
          android:taskAffinity="string"
          android:theme="resource or theme"
          android:uiOptions=["none" | "splitActionBarWhenNarrow"]
          android:windowSoftInputMode=["stateUnspecified",
                                       "stateUnchanged", "stateHidden",
                                       "stateAlwaysHidden", "stateVisible",
                                       "stateAlwaysVisible", "adjustUnspecified",
                                       "adjustResize", "adjustPan"] >   
    ...
</activity>

נכללים ב:

<application>

יכול להכיל:

<intent-filter>
<meta-data>
<layout>

description:

מגדיר פעילות (תת-סוג של Activity) שמטמיעה חלק מממשק המשתמש החזותי של האפליקציה. כל הפעילויות חייבות להיות מיוצגות על ידי רכיבי <activity> בקובץ המניפסט. כל מודעה שלא תוצהר שם לא תהיה גלויה למערכת ולא תוצג אף פעם.

מאפיינים:

android:allowEmbedded

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

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

android:allowTaskReparenting

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

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

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

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

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

android:alwaysRetainTaskState

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

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

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

android:autoRemoveFromRecents

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

android:banner

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

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

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

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

android:canDisplayOnRemoteDevices

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

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

android:clearTaskOnLaunch

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

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

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

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

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

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

תרחישים לדוגמה	מצב הפעלה	כמה מופעים?	תגובות
השקות רגילות לרוב הפעילויות	"standard"	כן	ברירת מחדל. המערכת תמיד יוצרת מופע חדש של הפעילות במשימה היעד ומנתבת אליה את הכוונה.
	"singleTop"	באופן מותנה	אם כבר יש מופע של הפעילות בחלק העליון של המשימה היעד, המערכת תנתב את הכוונה למופע הזה באמצעות קריאה ל-method‏ onNewIntent() שלו, במקום ליצור מופע חדש של הפעילות.
השקות מיוחדות (לא מומלצות לשימוש כללי)	"singleTask"	באופן מותנה	המערכת יוצרת את הפעילות ברמה הבסיסית של משימה חדשה או מאתרת את הפעילות במשימה קיימת עם אותו קשר. אם כבר יש מופע של הפעילות והוא נמצא ברמה הבסיסית של המשימה, המערכת מפנה את הכוונה למופע הקיים באמצעות קריאה ל-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"	משימות שמקורן בפעילות הזו תמיד מופעלות במצב משימות נעולות. אם המערכת כבר נמצאת במצב נעילה של משימה כשהמשימה הזו מופעלת, המשימה החדשה מופעלת מעל המשימה הנוכחית. משימות שהופעלו במצב הזה יכולות לצאת ממצב משימות נעולות (lock task mode) על ידי קריאה ל-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

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

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

android:noHistory

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

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

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

android:parentActivityName

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

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

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

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

למידע נוסף על הצהרת הפעילות ההורה על תמיכה בניווט למעלה, קראו את המאמר הוספת תמיכה בניווט למעלה.

המאפיין הזה הוצג ב-API ברמה 16.

android:persistableMode

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

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

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

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

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

android:permission

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

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

יכול להיות ערך מחרוזת, באמצעות '‎\\;' כדי להימלט מתווים כמו '‎\\n' או ‎'\\uxxxx' עבור תו Unicode.

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

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

android:resizeableActivity

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

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

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

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

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

• מסכים גדולים (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

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

ההתאמה קובעת שני דברים: את המשימה שאליה הפעילות מועברת שוב (ראו את המאפיין 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>