/**@class android.content.pm.ActivityInfo
 implements android.os.Parcelable

@extends android.content.pm.ComponentInfo

 Information you can retrieve about a particular application
 activity or receiver. This corresponds to information collected
 from the AndroidManifest.xml's <activity> and
 <receiver> tags.
*/
var ActivityInfo = {

/** A style resource identifier (in the package's resources) of this
 activity's theme.  From the "theme" attribute or, if not set, 0.
*/
theme : "null",
/** Constant corresponding to <code>standard</code> in
 the {@link android.R.attr#launchMode} attribute.
*/
LAUNCH_MULTIPLE : "0",
/** Constant corresponding to <code>singleTop</code> in
 the {@link android.R.attr#launchMode} attribute.
*/
LAUNCH_SINGLE_TOP : "1",
/** Constant corresponding to <code>singleTask</code> in
 the {@link android.R.attr#launchMode} attribute.
*/
LAUNCH_SINGLE_TASK : "2",
/** Constant corresponding to <code>singleInstance</code> in
 the {@link android.R.attr#launchMode} attribute.
*/
LAUNCH_SINGLE_INSTANCE : "3",
/** The launch mode style requested by the activity.  From the
 {@link android.R.attr#launchMode} attribute, one of
 {@link #LAUNCH_MULTIPLE},
 {@link #LAUNCH_SINGLE_TOP}, {@link #LAUNCH_SINGLE_TASK}, or
 {@link #LAUNCH_SINGLE_INSTANCE}.
*/
launchMode : "null",
/** Constant corresponding to <code>none</code> in
 the {@link android.R.attr#documentLaunchMode} attribute.
*/
DOCUMENT_LAUNCH_NONE : "0",
/** Constant corresponding to <code>intoExisting</code> in
 the {@link android.R.attr#documentLaunchMode} attribute.
*/
DOCUMENT_LAUNCH_INTO_EXISTING : "1",
/** Constant corresponding to <code>always</code> in
 the {@link android.R.attr#documentLaunchMode} attribute.
*/
DOCUMENT_LAUNCH_ALWAYS : "2",
/** Constant corresponding to <code>never</code> in
 the {@link android.R.attr#documentLaunchMode} attribute.
*/
DOCUMENT_LAUNCH_NEVER : "3",
/** The document launch mode style requested by the activity. From the
 {@link android.R.attr#documentLaunchMode} attribute, one of
 {@link #DOCUMENT_LAUNCH_NONE}, {@link #DOCUMENT_LAUNCH_INTO_EXISTING},
 {@link #DOCUMENT_LAUNCH_ALWAYS}.

 <p>Modes DOCUMENT_LAUNCH_ALWAYS
 and DOCUMENT_LAUNCH_INTO_EXISTING are equivalent to {@link android.content.Intent#FLAG_ACTIVITY_NEW_DOCUMENT
 Intent.FLAG_ACTIVITY_NEW_DOCUMENT} with and without {@link android.content.Intent#FLAG_ACTIVITY_MULTIPLE_TASK
 Intent.FLAG_ACTIVITY_MULTIPLE_TASK} respectively.
*/
documentLaunchMode : "null",
/** Constant corresponding to <code>persistRootOnly</code> in
 the {@link android.R.attr#persistableMode} attribute.
*/
PERSIST_ROOT_ONLY : "0",
/** Constant corresponding to <code>doNotPersist</code> in
 the {@link android.R.attr#persistableMode} attribute.
*/
PERSIST_NEVER : "1",
/** Constant corresponding to <code>persistAcrossReboots</code> in
 the {@link android.R.attr#persistableMode} attribute.
*/
PERSIST_ACROSS_REBOOTS : "2",
/** Value indicating how this activity is to be persisted across
 reboots for restoring in the Recents list.
 {@link android.R.attr#persistableMode}
*/
persistableMode : "null",
/** The maximum number of tasks rooted at this activity that can be in the recent task list.
 Refer to {@link android.R.attr#maxRecents}.
*/
maxRecents : "null",
/** Optional name of a permission required to be able to access this
 Activity.  From the "permission" attribute.
*/
permission : "null",
/** The affinity this activity has for another task in the system.  The
 string here is the name of the task, often the package name of the
 overall package.  If null, the activity has no affinity.  Set from the
 {@link android.R.attr#taskAffinity} attribute.
*/
taskAffinity : "null",
/** If this is an activity alias, this is the real activity class to run
 for it.  Otherwise, this is null.
*/
targetActivity : "null",
/** Token used to string together multiple events within a single launch action.
 @hide
*/
launchToken : "null",
/** Activity can not be resized and always occupies the fullscreen area with all windows fully
 visible.
 @hide
*/
RESIZE_MODE_UNRESIZEABLE : "0",
/** Activity didn't explicitly request to be resizeable, but we are making it resizeable because
 of the SDK version it targets. Only affects apps with target SDK >= N where the app is
 implied to be resizeable if it doesn't explicitly set the attribute to any value.
 @hide
*/
RESIZE_MODE_RESIZEABLE_VIA_SDK_VERSION : "1",
/** Activity explicitly requested to be resizeable.
 @hide
*/
RESIZE_MODE_RESIZEABLE : "2",
/** Activity is resizeable and supported picture-in-picture mode.  This flag is now deprecated
 since activities do not need to be resizeable to support picture-in-picture.
 See {@link #FLAG_SUPPORTS_PICTURE_IN_PICTURE}.

 @hide
 @deprecated
*/
RESIZE_MODE_RESIZEABLE_AND_PIPABLE_DEPRECATED : "3",
/** Activity does not support resizing, but we are forcing it to be resizeable. Only affects
 certain pre-N apps where we force them to be resizeable.
 @hide
*/
RESIZE_MODE_FORCE_RESIZEABLE : "4",
/** Activity does not support resizing, but we are forcing it to be resizeable as long
 as the size remains landscape.
 @hide
*/
RESIZE_MODE_FORCE_RESIZABLE_LANDSCAPE_ONLY : "5",
/** Activity does not support resizing, but we are forcing it to be resizeable as long
 as the size remains portrait.
 @hide
*/
RESIZE_MODE_FORCE_RESIZABLE_PORTRAIT_ONLY : "6",
/** Activity does not support resizing, but we are forcing it to be resizeable as long
 as the bounds remain in the same orientation as they are.
 @hide
*/
RESIZE_MODE_FORCE_RESIZABLE_PRESERVE_ORIENTATION : "7",
/** Value indicating if the resizing mode the activity supports.
 See {@link android.R.attr#resizeableActivity}.
 @hide
*/
resizeMode : "null",
/** Value indicating the maximum aspect ratio the activity supports.
 <p>
 0 means unset.
 @See {@link android.R.attr#maxAspectRatio}.
 @hide
*/
maxAspectRatio : "null",
/** Value indicating the minimum aspect ratio the activity supports.
 <p>
 0 means unset.
 @See {@link android.R.attr#minAspectRatio}.
 @hide
*/
minAspectRatio : "null",
/** Name of the VrListenerService component to run for this activity.
 @see android.R.attr#enableVrMode
 @hide
*/
requestedVrComponent : "null",
/** Value for {@link #colorMode} indicating that the activity should use the
 default color mode (sRGB, low dynamic range).

 @see android.R.attr#colorMode
*/
COLOR_MODE_DEFAULT : "0",
/** Value of {@link #colorMode} indicating that the activity should use a
 wide color gamut if the presentation display supports it.

 @see android.R.attr#colorMode
*/
COLOR_MODE_WIDE_COLOR_GAMUT : "1",
/** Value of {@link #colorMode} indicating that the activity should use a
 high dynamic range if the presentation display supports it.

 @see android.R.attr#colorMode
*/
COLOR_MODE_HDR : "2",
/** The color mode requested by this activity. The target display may not be
 able to honor the request.
*/
colorMode : "null",
/** Bit in {@link #flags} indicating whether this activity is able to
 run in multiple processes.  If
 true, the system may instantiate it in the some process as the
 process starting it in order to conserve resources.  If false, the
 default, it always runs in {@link #processName}.  Set from the
 {@link android.R.attr#multiprocess} attribute.
*/
FLAG_MULTIPROCESS : "1",
/** Bit in {@link #flags} indicating that, when the activity's task is
 relaunched from home, this activity should be finished.
 Set from the
 {@link android.R.attr#finishOnTaskLaunch} attribute.
*/
FLAG_FINISH_ON_TASK_LAUNCH : "2",
/** Bit in {@link #flags} indicating that, when the activity is the root
 of a task, that task's stack should be cleared each time the user
 re-launches it from home.  As a result, the user will always
 return to the original activity at the top of the task.
 This flag only applies to activities that
 are used to start the root of a new task.  Set from the
 {@link android.R.attr#clearTaskOnLaunch} attribute.
*/
FLAG_CLEAR_TASK_ON_LAUNCH : "4",
/** Bit in {@link #flags} indicating that, when the activity is the root
 of a task, that task's stack should never be cleared when it is
 relaunched from home.  Set from the
 {@link android.R.attr#alwaysRetainTaskState} attribute.
*/
FLAG_ALWAYS_RETAIN_TASK_STATE : "8",
/** Bit in {@link #flags} indicating that the activity's state
 is not required to be saved, so that if there is a failure the
 activity will not be removed from the activity stack.  Set from the
 {@link android.R.attr#stateNotNeeded} attribute.
*/
FLAG_STATE_NOT_NEEDED : "16",
/** Bit in {@link #flags} that indicates that the activity should not
 appear in the list of recently launched activities.  Set from the
 {@link android.R.attr#excludeFromRecents} attribute.
*/
FLAG_EXCLUDE_FROM_RECENTS : "32",
/** Bit in {@link #flags} that indicates that the activity can be moved
 between tasks based on its task affinity.  Set from the
 {@link android.R.attr#allowTaskReparenting} attribute.
*/
FLAG_ALLOW_TASK_REPARENTING : "64",
/** Bit in {@link #flags} indicating that, when the user navigates away
 from an activity, it should be finished.
 Set from the
 {@link android.R.attr#noHistory} attribute.
*/
FLAG_NO_HISTORY : "128",
/** Bit in {@link #flags} indicating that, when a request to close system
 windows happens, this activity is finished.
 Set from the
 {@link android.R.attr#finishOnCloseSystemDialogs} attribute.
*/
FLAG_FINISH_ON_CLOSE_SYSTEM_DIALOGS : "256",
/** Value for {@link #flags}: true when the application's rendering should
 be hardware accelerated.
*/
FLAG_HARDWARE_ACCELERATED : "512",
/** Value for {@link #flags}: true when the application can be displayed for all users
 regardless of if the user of the application is the current user. Set from the
 {@link android.R.attr#showForAllUsers} attribute.
 @hide
*/
FLAG_SHOW_FOR_ALL_USERS : "1024",
/** Bit in {@link #flags} corresponding to an immersive activity
 that wishes not to be interrupted by notifications.
 Applications that hide the system notification bar with
 {@link android.view.WindowManager.LayoutParams#FLAG_FULLSCREEN}
 may still be interrupted by high-priority notifications; for example, an
 incoming phone call may use
 {@link android.app.Notification#fullScreenIntent fullScreenIntent}
 to present a full-screen in-call activity to the user, pausing the
 current activity as a side-effect. An activity with
 {@link #FLAG_IMMERSIVE} set, however, will not be interrupted; the
 notification may be shown in some other way (such as a small floating
 "toast" window).

 Note that this flag will always reflect the Activity's
 <code>android:immersive</code> manifest definition, even if the Activity's
 immersive state is changed at runtime via
 {@link android.app.Activity#setImmersive(boolean)}.

 @see android.app.Notification#FLAG_HIGH_PRIORITY
 @see android.app.Activity#setImmersive(boolean)
*/
FLAG_IMMERSIVE : "2048",
/** Bit in {@link #flags}: If set, a task rooted at this activity will have its
 baseIntent replaced by the activity immediately above this. Each activity may further
 relinquish its identity to the activity above it using this flag. Set from the
 {@link android.R.attr#relinquishTaskIdentity} attribute.
*/
FLAG_RELINQUISH_TASK_IDENTITY : "4096",
/** Bit in {@link #flags} indicating that tasks started with this activity are to be
 removed from the recent list of tasks when the last activity in the task is finished.
 Corresponds to {@link android.R.attr#autoRemoveFromRecents}
*/
FLAG_AUTO_REMOVE_FROM_RECENTS : "8192",
/** Bit in {@link #flags} indicating that this activity can start is creation/resume
 while the previous activity is still pausing.  Corresponds to
 {@link android.R.attr#resumeWhilePausing}
*/
FLAG_RESUME_WHILE_PAUSING : "16384",
/** Bit in {@link #flags} indicating that this activity should be run with VR mode enabled.

 @see android.app.Activity#setVrModeEnabled(boolean, ComponentName)
*/
FLAG_ENABLE_VR_MODE : "32768",
/** Bit in {@link #flags} indicating if the activity is always focusable regardless of if it is
 in a task/stack whose activities are normally not focusable.
 See android.R.attr#alwaysFocusable.
 @hide
*/
FLAG_ALWAYS_FOCUSABLE : "262144",
/** Bit in {@link #flags} indicating if the activity is visible to instant
 applications. The activity is visible if it's either implicitly or
 explicitly exposed.
 @hide
*/
FLAG_VISIBLE_TO_INSTANT_APP : "1048576",
/** Bit in {@link #flags} indicating if the activity is implicitly visible
 to instant applications. Implicitly visible activities are those that
 implement certain intent-filters:
 <ul>
 <li>action {@link Intent#CATEGORY_BROWSABLE}</li>
 <li>action {@link Intent#ACTION_SEND}</li>
 <li>action {@link Intent#ACTION_SENDTO}</li>
 <li>action {@link Intent#ACTION_SEND_MULTIPLE}</li>
 </ul>
 @hide
*/
FLAG_IMPLICITLY_VISIBLE_TO_INSTANT_APP : "2097152",
/** Bit in {@link #flags} indicating if the activity supports picture-in-picture mode.
 See {@link android.R.attr#supportsPictureInPicture}.
 @hide
*/
FLAG_SUPPORTS_PICTURE_IN_PICTURE : "4194304",
/** Bit in {@link #flags} indicating if the activity should be shown when locked.
 See {@link android.R.attr#showWhenLocked}
 @hide
*/
FLAG_SHOW_WHEN_LOCKED : "8388608",
/** Bit in {@link #flags} indicating if the screen should turn on when starting the activity.
 See {@link android.R.attr#turnScreenOn}
 @hide
*/
FLAG_TURN_SCREEN_ON : "16777216",
/** @hide Bit in {@link #flags}: If set, this component will only be seen
 by the system user.  Only works with broadcast receivers.  Set from the
 android.R.attr#systemUserOnly attribute.
*/
FLAG_SYSTEM_USER_ONLY : "536870912",
/** Bit in {@link #flags}: If set, a single instance of the receiver will
 run for all users on the device.  Set from the
 {@link android.R.attr#singleUser} attribute.  Note that this flag is
 only relevant for ActivityInfo structures that are describing receiver
 components; it is not applied to activities.
*/
FLAG_SINGLE_USER : "1073741824",
/** @hide Bit in {@link #flags}: If set, this activity may be launched into an
 owned ActivityContainer such as that within an ActivityView. If not set and
 this activity is launched into such a container a SecurityException will be
 thrown. Set from the {@link android.R.attr#allowEmbedded} attribute.
*/
FLAG_ALLOW_EMBEDDED : "-2147483648",
/** Options that have been set in the activity declaration in the
 manifest.
 These include:
 {@link #FLAG_MULTIPROCESS},
 {@link #FLAG_FINISH_ON_TASK_LAUNCH}, {@link #FLAG_CLEAR_TASK_ON_LAUNCH},
 {@link #FLAG_ALWAYS_RETAIN_TASK_STATE},
 {@link #FLAG_STATE_NOT_NEEDED}, {@link #FLAG_EXCLUDE_FROM_RECENTS},
 {@link #FLAG_ALLOW_TASK_REPARENTING}, {@link #FLAG_NO_HISTORY},
 {@link #FLAG_FINISH_ON_CLOSE_SYSTEM_DIALOGS},
 {@link #FLAG_HARDWARE_ACCELERATED}, {@link #FLAG_SINGLE_USER}.
*/
flags : "null",
/** Bit in {@link #privateFlags} indicating if the activity should be shown when locked in case
 an activity behind this can also be shown when locked.
 See {@link android.R.attr#inheritShowWhenLocked}.
 @hide
*/
FLAG_INHERIT_SHOW_WHEN_LOCKED : "1",
/** Options that have been set in the activity declaration in the manifest.
 These include:
 {@link #FLAG_INHERIT_SHOW_WHEN_LOCKED}.
 @hide
*/
privateFlags : "null",
/** Internal constant used to indicate that the app didn't set a specific orientation value.
 Different from {@link #SCREEN_ORIENTATION_UNSPECIFIED} below as the app can set its
 orientation to {@link #SCREEN_ORIENTATION_UNSPECIFIED} while this means that the app didn't
 set anything. The system will mostly treat this similar to
 {@link #SCREEN_ORIENTATION_UNSPECIFIED}.
 @hide
*/
SCREEN_ORIENTATION_UNSET : "-2",
/** Constant corresponding to <code>unspecified</code> in
 the {@link android.R.attr#screenOrientation} attribute.
*/
SCREEN_ORIENTATION_UNSPECIFIED : "-1",
/** Constant corresponding to <code>landscape</code> in
 the {@link android.R.attr#screenOrientation} attribute.
*/
SCREEN_ORIENTATION_LANDSCAPE : "0",
/** Constant corresponding to <code>portrait</code> in
 the {@link android.R.attr#screenOrientation} attribute.
*/
SCREEN_ORIENTATION_PORTRAIT : "1",
/** Constant corresponding to <code>user</code> in
 the {@link android.R.attr#screenOrientation} attribute.
*/
SCREEN_ORIENTATION_USER : "2",
/** Constant corresponding to <code>behind</code> in
 the {@link android.R.attr#screenOrientation} attribute.
*/
SCREEN_ORIENTATION_BEHIND : "3",
/** Constant corresponding to <code>sensor</code> in
 the {@link android.R.attr#screenOrientation} attribute.
*/
SCREEN_ORIENTATION_SENSOR : "4",
/** Constant corresponding to <code>nosensor</code> in
 the {@link android.R.attr#screenOrientation} attribute.
*/
SCREEN_ORIENTATION_NOSENSOR : "5",
/** Constant corresponding to <code>sensorLandscape</code> in
 the {@link android.R.attr#screenOrientation} attribute.
*/
SCREEN_ORIENTATION_SENSOR_LANDSCAPE : "6",
/** Constant corresponding to <code>sensorPortrait</code> in
 the {@link android.R.attr#screenOrientation} attribute.
*/
SCREEN_ORIENTATION_SENSOR_PORTRAIT : "7",
/** Constant corresponding to <code>reverseLandscape</code> in
 the {@link android.R.attr#screenOrientation} attribute.
*/
SCREEN_ORIENTATION_REVERSE_LANDSCAPE : "8",
/** Constant corresponding to <code>reversePortrait</code> in
 the {@link android.R.attr#screenOrientation} attribute.
*/
SCREEN_ORIENTATION_REVERSE_PORTRAIT : "9",
/** Constant corresponding to <code>fullSensor</code> in
 the {@link android.R.attr#screenOrientation} attribute.
*/
SCREEN_ORIENTATION_FULL_SENSOR : "10",
/** Constant corresponding to <code>userLandscape</code> in
 the {@link android.R.attr#screenOrientation} attribute.
*/
SCREEN_ORIENTATION_USER_LANDSCAPE : "11",
/** Constant corresponding to <code>userPortrait</code> in
 the {@link android.R.attr#screenOrientation} attribute.
*/
SCREEN_ORIENTATION_USER_PORTRAIT : "12",
/** Constant corresponding to <code>fullUser</code> in
 the {@link android.R.attr#screenOrientation} attribute.
*/
SCREEN_ORIENTATION_FULL_USER : "13",
/** Constant corresponding to <code>locked</code> in
 the {@link android.R.attr#screenOrientation} attribute.
*/
SCREEN_ORIENTATION_LOCKED : "14",
/** The preferred screen orientation this activity would like to run in.
 From the {@link android.R.attr#screenOrientation} attribute, one of
 {@link #SCREEN_ORIENTATION_UNSPECIFIED},
 {@link #SCREEN_ORIENTATION_LANDSCAPE},
 {@link #SCREEN_ORIENTATION_PORTRAIT},
 {@link #SCREEN_ORIENTATION_USER},
 {@link #SCREEN_ORIENTATION_BEHIND},
 {@link #SCREEN_ORIENTATION_SENSOR},
 {@link #SCREEN_ORIENTATION_NOSENSOR},
 {@link #SCREEN_ORIENTATION_SENSOR_LANDSCAPE},
 {@link #SCREEN_ORIENTATION_SENSOR_PORTRAIT},
 {@link #SCREEN_ORIENTATION_REVERSE_LANDSCAPE},
 {@link #SCREEN_ORIENTATION_REVERSE_PORTRAIT},
 {@link #SCREEN_ORIENTATION_FULL_SENSOR},
 {@link #SCREEN_ORIENTATION_USER_LANDSCAPE},
 {@link #SCREEN_ORIENTATION_USER_PORTRAIT},
 {@link #SCREEN_ORIENTATION_FULL_USER},
 {@link #SCREEN_ORIENTATION_LOCKED},
*/
screenOrientation : "null",
/** Bit in {@link #configChanges} that indicates that the activity
 can itself handle changes to the IMSI MCC.  Set from the
 {@link android.R.attr#configChanges} attribute.
*/
CONFIG_MCC : "1",
/** Bit in {@link #configChanges} that indicates that the activity
 can itself handle changes to the IMSI MNC.  Set from the
 {@link android.R.attr#configChanges} attribute.
*/
CONFIG_MNC : "2",
/** Bit in {@link #configChanges} that indicates that the activity
 can itself handle changes to the locale.  Set from the
 {@link android.R.attr#configChanges} attribute.
*/
CONFIG_LOCALE : "4",
/** Bit in {@link #configChanges} that indicates that the activity
 can itself handle changes to the touchscreen type.  Set from the
 {@link android.R.attr#configChanges} attribute.
*/
CONFIG_TOUCHSCREEN : "8",
/** Bit in {@link #configChanges} that indicates that the activity
 can itself handle changes to the keyboard type.  Set from the
 {@link android.R.attr#configChanges} attribute.
*/
CONFIG_KEYBOARD : "16",
/** Bit in {@link #configChanges} that indicates that the activity
 can itself handle changes to the keyboard or navigation being hidden/exposed.
 Note that inspite of the name, this applies to the changes to any
 hidden states: keyboard or navigation.
 Set from the {@link android.R.attr#configChanges} attribute.
*/
CONFIG_KEYBOARD_HIDDEN : "32",
/** Bit in {@link #configChanges} that indicates that the activity
 can itself handle changes to the navigation type.  Set from the
 {@link android.R.attr#configChanges} attribute.
*/
CONFIG_NAVIGATION : "64",
/** Bit in {@link #configChanges} that indicates that the activity
 can itself handle changes to the screen orientation.  Set from the
 {@link android.R.attr#configChanges} attribute.
*/
CONFIG_ORIENTATION : "128",
/** Bit in {@link #configChanges} that indicates that the activity
 can itself handle changes to the screen layout.  Set from the
 {@link android.R.attr#configChanges} attribute.
*/
CONFIG_SCREEN_LAYOUT : "256",
/** Bit in {@link #configChanges} that indicates that the activity
 can itself handle the ui mode. Set from the
 {@link android.R.attr#configChanges} attribute.
*/
CONFIG_UI_MODE : "512",
/** Bit in {@link #configChanges} that indicates that the activity
 can itself handle the screen size. Set from the
 {@link android.R.attr#configChanges} attribute.  This will be
 set by default for applications that target an earlier version
 than {@link android.os.Build.VERSION_CODES#HONEYCOMB_MR2}...
 <b>however</b>, you will not see the bit set here becomes some
 applications incorrectly compare {@link #configChanges} against
 an absolute value rather than correctly masking out the bits
 they are interested in.  Please don't do that, thanks.
*/
CONFIG_SCREEN_SIZE : "1024",
/** Bit in {@link #configChanges} that indicates that the activity
 can itself handle the smallest screen size. Set from the
 {@link android.R.attr#configChanges} attribute.  This will be
 set by default for applications that target an earlier version
 than {@link android.os.Build.VERSION_CODES#HONEYCOMB_MR2}...
 <b>however</b>, you will not see the bit set here becomes some
 applications incorrectly compare {@link #configChanges} against
 an absolute value rather than correctly masking out the bits
 they are interested in.  Please don't do that, thanks.
*/
CONFIG_SMALLEST_SCREEN_SIZE : "2048",
/** Bit in {@link #configChanges} that indicates that the activity
 can itself handle density changes. Set from the
 {@link android.R.attr#configChanges} attribute.
*/
CONFIG_DENSITY : "4096",
/** Bit in {@link #configChanges} that indicates that the activity
 can itself handle the change to layout direction. Set from the
 {@link android.R.attr#configChanges} attribute.
*/
CONFIG_LAYOUT_DIRECTION : "8192",
/** Bit in {@link #configChanges} that indicates that the activity
 can itself handle the change to the display color gamut or dynamic
 range. Set from the {@link android.R.attr#configChanges} attribute.
*/
CONFIG_COLOR_MODE : "16384",
/** Bit in {@link #configChanges} that indicates that the activity
 can itself handle asset path changes.  Set from the {@link android.R.attr#configChanges}
 attribute. This is not a core resource configuration, but a higher-level value, so its
 constant starts at the high bits.
 @hide We do not want apps handling this yet, but we do need some kind of bit for diffs.
*/
CONFIG_ASSETS_PATHS : "-2147483648",
/** Bit in {@link #configChanges} that indicates that the activity
 can itself handle changes to the font scaling factor.  Set from the
 {@link android.R.attr#configChanges} attribute.  This is
 not a core resource configuration, but a higher-level value, so its
 constant starts at the high bits.
*/
CONFIG_FONT_SCALE : "1073741824",
/** Bit indicating changes to window configuration that isn't exposed to apps.
 This is for internal use only and apps don't handle it.
 @hide
 {@link android.content.pm.ActivityInfo.Configuration}.
*/
CONFIG_WINDOW_CONFIGURATION : "536870912",
/**@hide
 Unfortunately the constants for config changes in native code are
 different from ActivityInfo. :(  Here are the values we should use for the
 native side given the bit we have assigned in ActivityInfo.
*/
CONFIG_NATIVE_BITS : "null",
/** Bit mask of kinds of configuration changes that this activity
 can handle itself (without being restarted by the system).
 Contains any combination of {@link #CONFIG_FONT_SCALE},
 {@link #CONFIG_MCC}, {@link #CONFIG_MNC},
 {@link #CONFIG_LOCALE}, {@link #CONFIG_TOUCHSCREEN},
 {@link #CONFIG_KEYBOARD}, {@link #CONFIG_NAVIGATION},
 {@link #CONFIG_ORIENTATION}, {@link #CONFIG_SCREEN_LAYOUT},
 {@link #CONFIG_DENSITY}, {@link #CONFIG_LAYOUT_DIRECTION} and
 {@link #CONFIG_COLOR_MODE}.
 Set from the {@link android.R.attr#configChanges} attribute.
*/
configChanges : "null",
/** The desired soft input mode for this activity's main window.
 Set from the {@link android.R.attr#windowSoftInputMode} attribute
 in the activity's manifest.  May be any of the same values allowed
 for {@link android.view.WindowManager.LayoutParams#softInputMode
 WindowManager.LayoutParams.softInputMode}.  If 0 (unspecified),
 the mode from the theme will be used.
*/
softInputMode : "null",
/** The desired extra UI options for this activity and its main window.
 Set from the {@link android.R.attr#uiOptions} attribute in the
 activity's manifest.
*/
uiOptions : "null",
/** Flag for use with {@link #uiOptions}.
 Indicates that the action bar should put all action items in a separate bar when
 the screen is narrow.
 <p>This value corresponds to "splitActionBarWhenNarrow" for the {@link #uiOptions} XML
 attribute.
*/
UIOPTION_SPLIT_ACTION_BAR_WHEN_NARROW : "1",
/** If defined, the activity named here is the logical parent of this activity.
*/
parentActivityName : "null",
/** Screen rotation animation desired by the activity, with values as defined
 for {@link android.view.WindowManager.LayoutParams#rotationAnimation}.

 -1 means to use the system default.

 @hide
*/
rotationAnimation : "null",
/**@hide */
LOCK_TASK_LAUNCH_MODE_DEFAULT : "0",
/**@hide */
LOCK_TASK_LAUNCH_MODE_NEVER : "1",
/**@hide */
LOCK_TASK_LAUNCH_MODE_ALWAYS : "2",
/**@hide */
LOCK_TASK_LAUNCH_MODE_IF_WHITELISTED : "3",
/** Value indicating if the activity is to be locked at startup. Takes on the values from
 {@link android.R.attr#lockTaskMode}.
 @hide
*/
lockTaskLaunchMode : "null",
/** Information about desired position and size of activity on the display when
 it is first started.
*/
windowLayout : "null",
/***/
CREATOR : "null",
/**Convert Java change bits to native.
@hide 
*/
activityInfoConfigJavaToNative : function(  ) {},

/**Convert native change bits to Java.
@hide 
*/
activityInfoConfigNativeToJava : function(  ) {},

/**
@hide Unfortunately some developers (OpenFeint I am looking at you) have
 compared the configChanges bit field against absolute values, so if we
 introduce a new bit they break.  To deal with that, we will make sure
 the public field will not have a value that breaks them, and let the
 framework call here to get the real value.
*/
getRealConfigChanged : function(  ) {},

/**
@hide 
*/
lockTaskLaunchModeToString : function(  ) {},

/**Return the theme resource identifier to use for this activity.  If
 the activity defines a theme, that is used; else, the application
 theme is used.
@return {Number} The theme associated with this activity.
*/
getThemeResource : function(  ) {},

/**Returns true if the activity has maximum or minimum aspect ratio.
@hide 
*/
hasFixedAspectRatio : function(  ) {},

/**Returns true if the activity's orientation is fixed.
@hide 
*/
isFixedOrientation : function(  ) {},

/**Returns true if the activity's orientation is fixed to landscape.
@hide 
*/
isFixedOrientationLandscape : function(  ) {},

/**Returns true if the activity's orientation is fixed to portrait.
@hide 
*/
isFixedOrientationPortrait : function(  ) {},

/**Returns true if the activity supports picture-in-picture.
@hide 
*/
supportsPictureInPicture : function(  ) {},

/**
@hide 
*/
isResizeableMode : function(  ) {},

/**
@hide 
*/
isPreserveOrientationMode : function(  ) {},

/**
@hide 
*/
resizeModeToString : function(  ) {},

/**
*/
dump : function(  ) {},

/**
@hide 
*/
dump : function(  ) {},

/**
*/
toString : function(  ) {},

/**
*/
describeContents : function(  ) {},

/**
*/
writeToParcel : function(  ) {},

/**Determines whether the {@link android.content.pm.PackageParser.Activity} is considered translucent or floating.
@hide 
*/
isTranslucentOrFloating : function(  ) {},

/**Convert the screen orientation constant to a human readable format.
@hide 
*/
screenOrientationToString : function(  ) {},

/**
@hide 
*/
colorModeToString : function(  ) {},


};