/**@class android.app.ActivityManagerInternal
@extends java.lang.Object

 Activity manager local system service interface.

 @hide Only for use within the system server.
*/
var ActivityManagerInternal = {

/***/
ALLOW_NON_FULL : "0",
/***/
ALLOW_NON_FULL_IN_PROFILE : "1",
/***/
ALLOW_FULL_ONLY : "2",
/**Verify that calling app has access to the given provider.
*/
checkContentProviderAccess : function(  ) {},

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

/**
@return {Boolean} {@code true} if process start is successful, {@code false} otherwise.
*/
startIsolatedProcess : function(  ) {},

/**Kill foreground apps from the specified user.
*/
killForegroundAppsForUser : function(  ) {},

/**Sets how long a {@link android.app.PendingIntent} can be temporarily whitelist to by bypass restrictions
  such as Power Save mode.
*/
setPendingIntentWhitelistDuration : function(  ) {},

/**Allows for a {@link android.app.PendingIntent} to be whitelisted to start activities from background.
*/
setPendingIntentAllowBgActivityStarts : function(  ) {},

/**Voids {@link android.app.PendingIntent}'s privilege to be whitelisted to start activities from
 background.
*/
clearPendingIntentAllowBgActivityStarts : function(  ) {},

/**Allow DeviceIdleController to tell us about what apps are whitelisted.
*/
setDeviceIdleWhitelist : function(  ) {},

/**Update information about which app IDs are on the temp whitelist.
*/
updateDeviceIdleTempWhitelist : function(  ) {},

/**Get the procstate for the UID.  The return value will be between
 {@link android.app.ActivityManager#MIN_PROCESS_STATE} and {@link android.app.ActivityManager#MAX_PROCESS_STATE}.
 Note if the UID doesn't exist, it'll return {@link android.app.ActivityManager#PROCESS_STATE_NONEXISTENT}
 (-1).
*/
getUidProcessState : function(  ) {},

/**
@return {Boolean} {@code true} if system is ready, {@code false} otherwise.
*/
isSystemReady : function(  ) {},

/**Sets if the given pid has an overlay UI or not.
@param {Number} pid The pid we are setting overlay UI for.
@param {Boolean} hasOverlayUi True if the process has overlay UI.
@see android.view.WindowManager.LayoutParams#TYPE_APPLICATION_OVERLAY
*/
setHasOverlayUi : function(  ) {},

/**Sets if the given pid is currently running a remote animation, which is taken a signal for
 determining oom adjustment and scheduling behavior.
@param {Number} pid The pid we are setting overlay UI for.
@param {Boolean} runningRemoteAnimation True if the process is running a remote animation, false
                               otherwise.
@see RemoteAnimationAdapter
*/
setRunningRemoteAnimation : function(  ) {},

/**Called after the network policy rules are updated by
 {@link com.android.server.net.NetworkPolicyManagerService} for a specific {@param uid} and
 {@param procStateSeq}.
*/
notifyNetworkPolicyRulesUpdated : function(  ) {},

/**
@return {Boolean} true if runtime was restarted, false if it's normal boot
*/
isRuntimeRestarted : function(  ) {},

/**Returns if more users can be started without stopping currently running users.
*/
canStartMoreUsers : function(  ) {},

/**Sets the user switcher message for switching from {@link android.os.UserHandle#SYSTEM}.
*/
setSwitchingFromSystemUserMessage : function(  ) {},

/**Sets the user switcher message for switching to {@link android.os.UserHandle#SYSTEM}.
*/
setSwitchingToSystemUserMessage : function(  ) {},

/**Returns maximum number of users that can run simultaneously.
*/
getMaxRunningUsers : function(  ) {},

/**Whether an UID is active or idle.
*/
isUidActive : function(  ) {},

/**Returns a list of running processes along with corresponding uids, pids and their oom score.

 Only processes managed by ActivityManagerService are included.
*/
getMemoryStateForProcesses : function(  ) {},

/**Checks to see if the calling pid is allowed to handle the user. Returns adjusted user id as
 needed.
*/
handleIncomingUser : function(  ) {},

/**Checks if the calling binder pid as the permission.
*/
enforceCallingPermission : function(  ) {},

/**Returns the current user id.
*/
getCurrentUserId : function(  ) {},

/**Returns true if the user is running.
*/
isUserRunning : function(  ) {},

/**Trims memory usage in the system by removing/stopping unused application processes.
*/
trimApplications : function(  ) {},

/**Kill the processes in the list due to their tasks been removed.
*/
killProcessesForRemovedTask : function(  ) {},

/**Kill the process immediately.
*/
killProcess : function(  ) {},

/**Returns {@code true} if {@code uid} is running an activity from {@code packageName}.
*/
hasRunningActivity : function(  ) {},

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

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

/**Update battery stats on activity usage.
@param {Object {ComponentName}} activity
@param {Number} uid
@param {Number} userId
@param {Boolean} started
*/
updateBatteryStats : function(  ) {},

/**Update UsageStats of the activity.
@param {Object {ComponentName}} activity
@param {Number} userId
@param {Number} event
@param {Object {IBinder}} appToken ActivityRecord's appToken.
@param {Object {ComponentName}} taskRoot TaskRecord's root
*/
updateActivityUsageStats : function(  ) {},

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

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

/**Returns whether the given user requires credential entry at this time. This is used to
 intercept activity launches for work apps when the Work Challenge is present.
*/
shouldConfirmCredentials : function(  ) {},

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

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

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

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

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

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

/**Schedule the execution of all pending app GCs.
*/
scheduleAppGcs : function(  ) {},

/**Gets the task id for a given activity.
*/
getTaskIdForActivity : function(  ) {},

/**Gets the basic info for a given activity.
*/
getActivityPresentationInfo : function(  ) {},

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**Returns true if the background activity starts is enabled.
*/
isBackgroundActivityStartsEnabled : function(  ) {},

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

/**Input dispatch timeout to a window, start the ANR process.
*/
inputDispatchingTimedOut : function(  ) {},

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

/**Sends {@link android.content.Intent#ACTION_CONFIGURATION_CHANGED} with all the appropriate
 flags.
*/
broadcastGlobalConfigurationChanged : function(  ) {},

/**Sends {@link android.content.Intent#ACTION_CLOSE_SYSTEM_DIALOGS} with all the appropriate
 flags.
*/
broadcastCloseSystemDialogs : function(  ) {},

/**Kills all background processes, except those matching any of the specified properties.
@param {Number} minTargetSdk the target SDK version at or above which to preserve processes,
                     or {@code -1} to ignore the target SDK
@param {Number} maxProcState the process state at or below which to preserve processes,
                     or {@code -1} to ignore the process state
*/
killAllBackgroundProcessesExcept : function(  ) {},

/**Starts a given process.
*/
startProcess : function(  ) {},

/**Starts up the starting activity process for debugging if needed.
 This function needs to be called synchronously from WindowManager context so the caller
 passes a lock {@code wmLock} and waits to be notified.
@param {Object {ActivityInfo}} wmLock calls {@code notify} on the object to wake up the caller.
*/
setDebugFlagsForStartingActivity : function(  ) {},

/**Returns mount mode for process running with given pid
*/
getStorageMountMode : function(  ) {},

/**Returns true if the given uid is the app in the foreground.
*/
isAppForeground : function(  ) {},

/**Returns true if the given uid is currently marked 'bad'
*/
isAppBad : function(  ) {},

/**Remove pending backup for the given userId.
*/
clearPendingBackup : function(  ) {},

/**When power button is very long pressed, call this interface to do some pre-shutdown work
 like persisting database etc.
*/
prepareForPossibleShutdown : function(  ) {},

/**Returns {@code true} if {@code uid} is running a foreground service of a specific
 {@code foregroundServiceType}.
*/
hasRunningForegroundService : function(  ) {},

/**Registers the specified {@code processObserver} to be notified of future changes to
 process state.
*/
registerProcessObserver : function(  ) {},

/**Unregisters the specified {@code processObserver}.
*/
unregisterProcessObserver : function(  ) {},


};