core/java/android/app/IActivityManager.java

   1 /*
   2  * Copyright (C) 2006 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package android.app;
  18
  19 import android.annotation.UserIdInt;
  20 import android.app.ActivityManager.RunningServiceInfo;
  21 import android.app.ActivityManager.RunningTaskInfo;
  22 import android.app.ActivityManager.StackInfo;
  23 import android.app.assist.AssistContent;
  24 import android.app.assist.AssistStructure;
  25 import android.content.ComponentName;
  26 import android.content.ContentProviderNative;
  27 import android.content.IContentProvider;
  28 import android.content.IIntentReceiver;
  29 import android.content.IIntentSender;
  30 import android.content.Intent;
  31 import android.content.IntentFilter;
  32 import android.content.IntentSender;
  33 import android.content.UriPermission;
  34 import android.content.pm.ApplicationInfo;
  35 import android.content.pm.ConfigurationInfo;
  36 import android.content.pm.IPackageDataObserver;
  37 import android.content.pm.PackageManager.NameNotFoundException;
  38 import android.content.pm.ParceledListSlice;
  39 import android.content.pm.ProviderInfo;
  40 import android.content.pm.UserInfo;
  41 import android.content.res.Configuration;
  42 import android.graphics.Bitmap;
  43 import android.graphics.Point;
  44 import android.graphics.Rect;
  45 import android.net.Uri;
  46 import android.os.Bundle;
  47 import android.os.Debug;
  48 import android.os.IBinder;
  49 import android.os.IInterface;
  50 import android.os.IProgressListener;
  51 import android.os.Parcel;
  52 import android.os.ParcelFileDescriptor;
  53 import android.os.Parcelable;
  54 import android.os.PersistableBundle;
  55 import android.os.RemoteException;
  56 import android.os.StrictMode;
  57 import android.service.voice.IVoiceInteractionSession;
  58 import com.android.internal.app.IVoiceInteractor;
  59 import com.android.internal.os.IResultReceiver;
  60
  61 import java.util.List;
  62
  63 /**
  64  * System private API for talking with the activity manager service.  This
  65  * provides calls from the application back to the activity manager.
  66  *
  67  * {@hide}
  68  */
  69 public interface IActivityManager extends IInterface {
  70     public int startActivity(IApplicationThread caller, String callingPackage, Intent intent,
  71             String resolvedType, IBinder resultTo, String resultWho, int requestCode, int flags,
  72             ProfilerInfo profilerInfo, Bundle options) throws RemoteException;
  73     public int startActivityAsUser(IApplicationThread caller, String callingPackage, Intent intent,
  74             String resolvedType, IBinder resultTo, String resultWho, int requestCode, int flags,
  75             ProfilerInfo profilerInfo, Bundle options, int userId) throws RemoteException;
  76     public int startActivityAsCaller(IApplicationThread caller, String callingPackage,
  77             Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
  78             int flags, ProfilerInfo profilerInfo, Bundle options, boolean ignoreTargetSecurity,
  79             int userId) throws RemoteException;
  80     public WaitResult startActivityAndWait(IApplicationThread caller, String callingPackage,
  81             Intent intent, String resolvedType, IBinder resultTo, String resultWho,
  82             int requestCode, int flags, ProfilerInfo profilerInfo, Bundle options,
  83             int userId) throws RemoteException;
  84     public int startActivityWithConfig(IApplicationThread caller, String callingPackage,
  85             Intent intent, String resolvedType, IBinder resultTo, String resultWho,
  86             int requestCode, int startFlags, Configuration newConfig,
  87             Bundle options, int userId) throws RemoteException;
  88     public int startActivityIntentSender(IApplicationThread caller,
  89             IntentSender intent, Intent fillInIntent, String resolvedType,
  90             IBinder resultTo, String resultWho, int requestCode,
  91             int flagsMask, int flagsValues, Bundle options) throws RemoteException;
  92     public int startVoiceActivity(String callingPackage, int callingPid, int callingUid,
  93             Intent intent, String resolvedType, IVoiceInteractionSession session,
  94             IVoiceInteractor interactor, int flags, ProfilerInfo profilerInfo, Bundle options,
  95             int userId) throws RemoteException;
  96     public boolean startNextMatchingActivity(IBinder callingActivity,
  97             Intent intent, Bundle options) throws RemoteException;
  98     public int startActivityFromRecents(int taskId, Bundle options)
  99             throws RemoteException;
 100     public boolean finishActivity(IBinder token, int code, Intent data, int finishTask)
 101             throws RemoteException;
 102     public void finishSubActivity(IBinder token, String resultWho, int requestCode) throws RemoteException;
 103     public boolean finishActivityAffinity(IBinder token) throws RemoteException;
 104     public void finishVoiceTask(IVoiceInteractionSession session) throws RemoteException;
 105     public boolean releaseActivityInstance(IBinder token) throws RemoteException;
 106     public void releaseSomeActivities(IApplicationThread app) throws RemoteException;
 107     public boolean willActivityBeVisible(IBinder token) throws RemoteException;
 108     public Intent registerReceiver(IApplicationThread caller, String callerPackage,
 109             IIntentReceiver receiver, IntentFilter filter,
 110             String requiredPermission, int userId) throws RemoteException;
 111     public void unregisterReceiver(IIntentReceiver receiver) throws RemoteException;
 112     public int broadcastIntent(IApplicationThread caller, Intent intent,
 113             String resolvedType, IIntentReceiver resultTo, int resultCode,
 114             String resultData, Bundle map, String[] requiredPermissions,
 115             int appOp, Bundle options, boolean serialized, boolean sticky, int userId) throws RemoteException;
 116     public void unbroadcastIntent(IApplicationThread caller, Intent intent, int userId) throws RemoteException;
 117     public void finishReceiver(IBinder who, int resultCode, String resultData, Bundle map,
 118             boolean abortBroadcast, int flags) throws RemoteException;
 119     public void attachApplication(IApplicationThread app) throws RemoteException;
 120     public void activityResumed(IBinder token) throws RemoteException;
 121     public void activityIdle(IBinder token, Configuration config,
 122             boolean stopProfiling) throws RemoteException;
 123     public void activityPaused(IBinder token) throws RemoteException;
 124     public void activityStopped(IBinder token, Bundle state,
 125             PersistableBundle persistentState, CharSequence description) throws RemoteException;
 126     public void activitySlept(IBinder token) throws RemoteException;
 127     public void activityDestroyed(IBinder token) throws RemoteException;
 128     public void activityRelaunched(IBinder token) throws RemoteException;
 129     public void reportSizeConfigurations(IBinder token, int[] horizontalSizeConfiguration,
 130             int[] verticalSizeConfigurations, int[] smallestWidthConfigurations)
 131             throws RemoteException;
 132     public String getCallingPackage(IBinder token) throws RemoteException;
 133     public ComponentName getCallingActivity(IBinder token) throws RemoteException;
 134     public List<IAppTask> getAppTasks(String callingPackage) throws RemoteException;
 135     public int addAppTask(IBinder activityToken, Intent intent,
 136             ActivityManager.TaskDescription description, Bitmap thumbnail) throws RemoteException;
 137     public Point getAppTaskThumbnailSize() throws RemoteException;
 138     public List<RunningTaskInfo> getTasks(int maxNum, int flags) throws RemoteException;
 139     public ParceledListSlice<ActivityManager.RecentTaskInfo> getRecentTasks(int maxNum,
 140             int flags, int userId) throws RemoteException;
 141     public ActivityManager.TaskThumbnail getTaskThumbnail(int taskId) throws RemoteException;
 142     public List<RunningServiceInfo> getServices(int maxNum, int flags) throws RemoteException;
 143     public List<ActivityManager.ProcessErrorStateInfo> getProcessesInErrorState()
 144             throws RemoteException;
 145     public void moveTaskToFront(int task, int flags, Bundle options) throws RemoteException;
 146     public boolean moveActivityTaskToBack(IBinder token, boolean nonRoot) throws RemoteException;
 147     public void moveTaskBackwards(int task) throws RemoteException;
 148     public void moveTaskToStack(int taskId, int stackId, boolean toTop) throws RemoteException;
 149     public boolean moveTaskToDockedStack(int taskId, int createMode, boolean toTop, boolean animate,
 150             Rect initialBounds, boolean moveHomeStackFront) throws RemoteException;
 151     public boolean moveTopActivityToPinnedStack(int stackId, Rect bounds) throws RemoteException;
 152
 153     /**
 154      * Resizes the input stack id to the given bounds.
 155      *
 156      * @param stackId Id of the stack to resize.
 157      * @param bounds Bounds to resize the stack to or {@code null} for fullscreen.
 158      * @param allowResizeInDockedMode True if the resize should be allowed when the docked stack is
 159      *                                active.
 160      * @param preserveWindows True if the windows of activities contained in the stack should be
 161      *                        preserved.
 162      * @param animate True if the stack resize should be animated.
 163      * @param animationDuration The duration of the resize animation in milliseconds or -1 if the
 164      *                          default animation duration should be used.
 165      * @throws RemoteException
 166      */
 167     public void resizeStack(int stackId, Rect bounds, boolean allowResizeInDockedMode,
 168             boolean preserveWindows, boolean animate, int animationDuration) throws RemoteException;
 169
 170     /**
 171      * Moves all tasks from the docked stack in the fullscreen stack and puts the top task of the
 172      * fullscreen stack into the docked stack.
 173      */
 174     public void swapDockedAndFullscreenStack() throws RemoteException;
 175
 176     /**
 177      * Resizes the docked stack, and all other stacks as the result of the dock stack bounds change.
 178      *
 179      * @param dockedBounds The bounds for the docked stack.
 180      * @param tempDockedTaskBounds The temporary bounds for the tasks in the docked stack, which
 181      *                             might be different from the stack bounds to allow more
 182      *                             flexibility while resizing, or {@code null} if they should be the
 183      *                             same as the stack bounds.
 184      * @param tempDockedTaskInsetBounds The temporary bounds for the tasks to calculate the insets.
 185      *                                  When resizing, we usually "freeze" the layout of a task. To
 186      *                                  achieve that, we also need to "freeze" the insets, which
 187      *                                  gets achieved by changing task bounds but not bounds used
 188      *                                  to calculate the insets in this transient state
 189      * @param tempOtherTaskBounds The temporary bounds for the tasks in all other stacks, or
 190      *                            {@code null} if they should be the same as the stack bounds.
 191      * @param tempOtherTaskInsetBounds Like {@code tempDockedTaskInsetBounds}, but for the other
 192      *                                 stacks.
 193      * @throws RemoteException
 194      */
 195     public void resizeDockedStack(Rect dockedBounds, Rect tempDockedTaskBounds,
 196             Rect tempDockedTaskInsetBounds,
 197             Rect tempOtherTaskBounds, Rect tempOtherTaskInsetBounds) throws RemoteException;
 198     /**
 199      * Resizes the pinned stack.
 200      *
 201      * @param pinnedBounds The bounds for the pinned stack.
 202      * @param tempPinnedTaskBounds The temporary bounds for the tasks in the pinned stack, which
 203      *                             might be different from the stack bounds to allow more
 204      *                             flexibility while resizing, or {@code null} if they should be the
 205      *                             same as the stack bounds.
 206      */
 207     public void resizePinnedStack(Rect pinnedBounds, Rect tempPinnedTaskBounds) throws RemoteException;
 208     public void positionTaskInStack(int taskId, int stackId, int position) throws RemoteException;
 209     public List<StackInfo> getAllStackInfos() throws RemoteException;
 210     public StackInfo getStackInfo(int stackId) throws RemoteException;
 211     public boolean isInHomeStack(int taskId) throws RemoteException;
 212     public void setFocusedStack(int stackId) throws RemoteException;
 213     public int getFocusedStackId() throws RemoteException;
 214     public void setFocusedTask(int taskId) throws RemoteException;
 215     public void registerTaskStackListener(ITaskStackListener listener) throws RemoteException;
 216     public int getTaskForActivity(IBinder token, boolean onlyRoot) throws RemoteException;
 217     public ContentProviderHolder getContentProvider(IApplicationThread caller,
 218             String name, int userId, boolean stable) throws RemoteException;
 219     public ContentProviderHolder getContentProviderExternal(String name, int userId, IBinder token)
 220             throws RemoteException;
 221     public void removeContentProvider(IBinder connection, boolean stable) throws RemoteException;
 222     public void removeContentProviderExternal(String name, IBinder token) throws RemoteException;
 223     public void publishContentProviders(IApplicationThread caller,
 224             List<ContentProviderHolder> providers) throws RemoteException;
 225     public boolean refContentProvider(IBinder connection, int stableDelta, int unstableDelta)
 226             throws RemoteException;
 227     public void unstableProviderDied(IBinder connection) throws RemoteException;
 228     public void appNotRespondingViaProvider(IBinder connection) throws RemoteException;
 229     public PendingIntent getRunningServiceControlPanel(ComponentName service)
 230             throws RemoteException;
 231     public ComponentName startService(IApplicationThread caller, Intent service,
 232             String resolvedType, String callingPackage, int userId) throws RemoteException;
 233     public int stopService(IApplicationThread caller, Intent service,
 234             String resolvedType, int userId) throws RemoteException;
 235     public boolean stopServiceToken(ComponentName className, IBinder token,
 236             int startId) throws RemoteException;
 237     public void setServiceForeground(ComponentName className, IBinder token,
 238             int id, Notification notification, int flags) throws RemoteException;
 239     public int bindService(IApplicationThread caller, IBinder token, Intent service,
 240             String resolvedType, IServiceConnection connection, int flags,
 241             String callingPackage, int userId) throws RemoteException;
 242     public boolean unbindService(IServiceConnection connection) throws RemoteException;
 243     public void publishService(IBinder token,
 244             Intent intent, IBinder service) throws RemoteException;
 245     public void unbindFinished(IBinder token, Intent service,
 246             boolean doRebind) throws RemoteException;
 247     /* oneway */
 248     public void serviceDoneExecuting(IBinder token, int type, int startId,
 249             int res) throws RemoteException;
 250     public IBinder peekService(Intent service, String resolvedType, String callingPackage)
 251             throws RemoteException;
 252
 253     public boolean bindBackupAgent(String packageName, int backupRestoreMode, int userId)
 254             throws RemoteException;
 255     public void clearPendingBackup() throws RemoteException;
 256     public void backupAgentCreated(String packageName, IBinder agent) throws RemoteException;
 257     public void unbindBackupAgent(ApplicationInfo appInfo) throws RemoteException;
 258     public void killApplicationProcess(String processName, int uid) throws RemoteException;
 259
 260     public boolean startInstrumentation(ComponentName className, String profileFile,
 261             int flags, Bundle arguments, IInstrumentationWatcher watcher,
 262             IUiAutomationConnection connection, int userId,
 263             String abiOverride) throws RemoteException;
 264     public void finishInstrumentation(IApplicationThread target,
 265             int resultCode, Bundle results) throws RemoteException;
 266
 267     public Configuration getConfiguration() throws RemoteException;
 268     public void updateConfiguration(Configuration values) throws RemoteException;
 269     public void setRequestedOrientation(IBinder token,
 270             int requestedOrientation) throws RemoteException;
 271     public int getRequestedOrientation(IBinder token) throws RemoteException;
 272
 273     public ComponentName getActivityClassForToken(IBinder token) throws RemoteException;
 274     public String getPackageForToken(IBinder token) throws RemoteException;
 275
 276     public IIntentSender getIntentSender(int type,
 277             String packageName, IBinder token, String resultWho,
 278             int requestCode, Intent[] intents, String[] resolvedTypes,
 279             int flags, Bundle options, int userId) throws RemoteException;
 280     public void cancelIntentSender(IIntentSender sender) throws RemoteException;
 281     public boolean clearApplicationUserData(final String packageName,
 282             final IPackageDataObserver observer, int userId) throws RemoteException;
 283     public String getPackageForIntentSender(IIntentSender sender) throws RemoteException;
 284     public int getUidForIntentSender(IIntentSender sender) throws RemoteException;
 285
 286     public int handleIncomingUser(int callingPid, int callingUid, int userId, boolean allowAll,
 287             boolean requireFull, String name, String callerPackage) throws RemoteException;
 288
 289     public void setProcessLimit(int max) throws RemoteException;
 290     public int getProcessLimit() throws RemoteException;
 291
 292     public void setProcessForeground(IBinder token, int pid,
 293             boolean isForeground) throws RemoteException;
 294
 295     public int checkPermission(String permission, int pid, int uid)
 296             throws RemoteException;
 297     public int checkPermissionWithToken(String permission, int pid, int uid, IBinder callerToken)
 298             throws RemoteException;
 299
 300     public int checkUriPermission(Uri uri, int pid, int uid, int mode, int userId,
 301             IBinder callerToken) throws RemoteException;
 302     public void grantUriPermission(IApplicationThread caller, String targetPkg, Uri uri,
 303             int mode, int userId) throws RemoteException;
 304     public void revokeUriPermission(IApplicationThread caller, Uri uri, int mode, int userId)
 305             throws RemoteException;
 306     public void takePersistableUriPermission(Uri uri, int modeFlags, int userId)
 307             throws RemoteException;
 308     public void releasePersistableUriPermission(Uri uri, int modeFlags, int userId)
 309             throws RemoteException;
 310     public ParceledListSlice<UriPermission> getPersistedUriPermissions(
 311             String packageName, boolean incoming) throws RemoteException;
 312
 313     // Gets the URI permissions granted to an arbitrary package.
 314     // NOTE: this is different from getPersistedUriPermissions(), which returns the URIs the package
 315     // granted to another packages (instead of those granted to it).
 316     public ParceledListSlice<UriPermission> getGrantedUriPermissions(String packageName, int userId)
 317             throws RemoteException;
 318
 319     // Clears the URI permissions granted to an arbitrary package.
 320     public void clearGrantedUriPermissions(String packageName, int userId) throws RemoteException;
 321
 322     public void showWaitingForDebugger(IApplicationThread who, boolean waiting)
 323             throws RemoteException;
 324
 325     public void getMemoryInfo(ActivityManager.MemoryInfo outInfo) throws RemoteException;
 326
 327     public void killBackgroundProcesses(final String packageName, int userId)
 328             throws RemoteException;
 329     public void killAllBackgroundProcesses() throws RemoteException;
 330     public void killPackageDependents(final String packageName, int userId) throws RemoteException;
 331     public void forceStopPackage(final String packageName, int userId) throws RemoteException;
 332
 333     // Note: probably don't want to allow applications access to these.
 334     public void setLockScreenShown(boolean showing, boolean occluded) throws RemoteException;
 335
 336     public void unhandledBack() throws RemoteException;
 337     public ParcelFileDescriptor openContentUri(Uri uri) throws RemoteException;
 338     public void setDebugApp(
 339         String packageName, boolean waitForDebugger, boolean persistent)
 340         throws RemoteException;
 341     public void setAlwaysFinish(boolean enabled) throws RemoteException;
 342     public void setActivityController(IActivityController watcher, boolean imAMonkey)
 343         throws RemoteException;
 344     public void setLenientBackgroundCheck(boolean enabled) throws RemoteException;
 345     public int getMemoryTrimLevel() throws RemoteException;
 346
 347     public void enterSafeMode() throws RemoteException;
 348
 349     public void noteWakeupAlarm(IIntentSender sender, int sourceUid, String sourcePkg, String tag)
 350             throws RemoteException;
 351     public void noteAlarmStart(IIntentSender sender, int sourceUid, String tag)
 352             throws RemoteException;
 353     public void noteAlarmFinish(IIntentSender sender, int sourceUid, String tag)
 354             throws RemoteException;
 355
 356     public boolean killPids(int[] pids, String reason, boolean secure) throws RemoteException;
 357     public boolean killProcessesBelowForeground(String reason) throws RemoteException;
 358
 359     // Special low-level communication with activity manager.
 360     public void handleApplicationCrash(IBinder app,
 361             ApplicationErrorReport.CrashInfo crashInfo) throws RemoteException;
 362     public boolean handleApplicationWtf(IBinder app, String tag, boolean system,
 363             ApplicationErrorReport.CrashInfo crashInfo) throws RemoteException;
 364
 365     // A StrictMode violation to be handled.  The violationMask is a
 366     // subset of the original StrictMode policy bitmask, with only the
 367     // bit violated and penalty bits to be executed by the
 368     // ActivityManagerService remaining set.
 369     public void handleApplicationStrictModeViolation(IBinder app, int violationMask,
 370             StrictMode.ViolationInfo crashInfo) throws RemoteException;
 371
 372     /*
 373      * This will deliver the specified signal to all the persistent processes. Currently only
 374      * SIGUSR1 is delivered. All others are ignored.
 375      */
 376     public void signalPersistentProcesses(int signal) throws RemoteException;
 377     // Retrieve running application processes in the system
 378     public List<ActivityManager.RunningAppProcessInfo> getRunningAppProcesses()
 379             throws RemoteException;
 380     // Retrieve info of applications installed on external media that are currently
 381     // running.
 382     public List<ApplicationInfo> getRunningExternalApplications()
 383             throws RemoteException;
 384     // Get memory information about the calling process.
 385     public void getMyMemoryState(ActivityManager.RunningAppProcessInfo outInfo)
 386             throws RemoteException;
 387     // Get device configuration
 388     public ConfigurationInfo getDeviceConfigurationInfo() throws RemoteException;
 389
 390     // Turn on/off profiling in a particular process.
 391     public boolean profileControl(String process, int userId, boolean start,
 392             ProfilerInfo profilerInfo, int profileType) throws RemoteException;
 393
 394     public boolean shutdown(int timeout) throws RemoteException;
 395
 396     public void stopAppSwitches() throws RemoteException;
 397     public void resumeAppSwitches() throws RemoteException;
 398
 399     public void addPackageDependency(String packageName) throws RemoteException;
 400
 401     public void killApplication(String pkg, int appId, int userId, String reason)
 402             throws RemoteException;
 403
 404     public void closeSystemDialogs(String reason) throws RemoteException;
 405
 406     public Debug.MemoryInfo[] getProcessMemoryInfo(int[] pids)
 407             throws RemoteException;
 408
 409     public void overridePendingTransition(IBinder token, String packageName,
 410             int enterAnim, int exitAnim) throws RemoteException;
 411
 412     public boolean isUserAMonkey() throws RemoteException;
 413
 414     public void setUserIsMonkey(boolean monkey) throws RemoteException;
 415
 416     public void finishHeavyWeightApp() throws RemoteException;
 417
 418     public boolean convertFromTranslucent(IBinder token) throws RemoteException;
 419     public boolean convertToTranslucent(IBinder token, ActivityOptions options) throws RemoteException;
 420     public void notifyActivityDrawn(IBinder token) throws RemoteException;
 421     public ActivityOptions getActivityOptions(IBinder token) throws RemoteException;
 422
 423     public void bootAnimationComplete() throws RemoteException;
 424
 425     public void setImmersive(IBinder token, boolean immersive) throws RemoteException;
 426     public boolean isImmersive(IBinder token) throws RemoteException;
 427     public boolean isTopActivityImmersive() throws RemoteException;
 428     public boolean isTopOfTask(IBinder token) throws RemoteException;
 429
 430     public void crashApplication(int uid, int initialPid, String packageName,
 431             String message) throws RemoteException;
 432
 433     public String getProviderMimeType(Uri uri, int userId) throws RemoteException;
 434
 435     public IBinder newUriPermissionOwner(String name) throws RemoteException;
 436     public IBinder getUriPermissionOwnerForActivity(IBinder activityToken) throws RemoteException;
 437     public void grantUriPermissionFromOwner(IBinder owner, int fromUid, String targetPkg,
 438             Uri uri, int mode, int sourceUserId, int targetUserId) throws RemoteException;
 439     public void revokeUriPermissionFromOwner(IBinder owner, Uri uri,
 440             int mode, int userId) throws RemoteException;
 441
 442     public int checkGrantUriPermission(int callingUid, String targetPkg, Uri uri,
 443             int modeFlags, int userId) throws RemoteException;
 444
 445     // Cause the specified process to dump the specified heap.
 446     public boolean dumpHeap(String process, int userId, boolean managed, String path,
 447         ParcelFileDescriptor fd) throws RemoteException;
 448
 449     public int startActivities(IApplicationThread caller, String callingPackage,
 450             Intent[] intents, String[] resolvedTypes, IBinder resultTo,
 451             Bundle options, int userId) throws RemoteException;
 452
 453     public int getFrontActivityScreenCompatMode() throws RemoteException;
 454     public void setFrontActivityScreenCompatMode(int mode) throws RemoteException;
 455     public int getPackageScreenCompatMode(String packageName) throws RemoteException;
 456     public void setPackageScreenCompatMode(String packageName, int mode)
 457             throws RemoteException;
 458     public boolean getPackageAskScreenCompat(String packageName) throws RemoteException;
 459     public void setPackageAskScreenCompat(String packageName, boolean ask)
 460             throws RemoteException;
 461
 462     // Multi-user APIs
 463     public boolean switchUser(int userid) throws RemoteException;
 464     public boolean startUserInBackground(int userid) throws RemoteException;
 465     public boolean unlockUser(int userid, byte[] token, byte[] secret, IProgressListener listener)
 466             throws RemoteException;
 467     public int stopUser(int userid, boolean force, IStopUserCallback callback) throws RemoteException;
 468     public UserInfo getCurrentUser() throws RemoteException;
 469     public boolean isUserRunning(int userid, int flags) throws RemoteException;
 470     public int[] getRunningUserIds() throws RemoteException;
 471
 472     public boolean removeTask(int taskId) throws RemoteException;
 473
 474     public void registerProcessObserver(IProcessObserver observer) throws RemoteException;
 475     public void unregisterProcessObserver(IProcessObserver observer) throws RemoteException;
 476
 477     public void registerUidObserver(IUidObserver observer, int which) throws RemoteException;
 478     public void unregisterUidObserver(IUidObserver observer) throws RemoteException;
 479
 480     public boolean isIntentSenderTargetedToPackage(IIntentSender sender) throws RemoteException;
 481
 482     public boolean isIntentSenderAnActivity(IIntentSender sender) throws RemoteException;
 483
 484     public Intent getIntentForIntentSender(IIntentSender sender) throws RemoteException;
 485
 486     public String getTagForIntentSender(IIntentSender sender, String prefix) throws RemoteException;
 487
 488     public void updatePersistentConfiguration(Configuration values) throws RemoteException;
 489
 490     public long[] getProcessPss(int[] pids) throws RemoteException;
 491
 492     public void showBootMessage(CharSequence msg, boolean always) throws RemoteException;
 493
 494     public void keyguardWaitingForActivityDrawn() throws RemoteException;
 495
 496     /**
 497      * Notify the system that the keyguard is going away.
 498      *
 499      * @param flags See {@link android.view.WindowManagerPolicy#KEYGUARD_GOING_AWAY_FLAG_TO_SHADE}
 500      *              etc.
 501      */
 502     public void keyguardGoingAway(int flags) throws RemoteException;
 503
 504     public boolean shouldUpRecreateTask(IBinder token, String destAffinity)
 505             throws RemoteException;
 506
 507     public boolean navigateUpTo(IBinder token, Intent target, int resultCode, Intent resultData)
 508             throws RemoteException;
 509
 510     // These are not public because you need to be very careful in how you
 511     // manage your activity to make sure it is always the uid you expect.
 512     public int getLaunchedFromUid(IBinder activityToken) throws RemoteException;
 513     public String getLaunchedFromPackage(IBinder activityToken) throws RemoteException;
 514
 515     public void registerUserSwitchObserver(IUserSwitchObserver observer,
 516             String name) throws RemoteException;
 517     public void unregisterUserSwitchObserver(IUserSwitchObserver observer) throws RemoteException;
 518
 519     public void requestBugReport(int bugreportType) throws RemoteException;
 520
 521     public long inputDispatchingTimedOut(int pid, boolean aboveSystem, String reason)
 522             throws RemoteException;
 523
 524     public Bundle getAssistContextExtras(int requestType) throws RemoteException;
 525
 526     public boolean requestAssistContextExtras(int requestType, IResultReceiver receiver,
 527             Bundle receiverExtras,
 528             IBinder activityToken, boolean focused, boolean newSessionId) throws RemoteException;
 529
 530     public void reportAssistContextExtras(IBinder token, Bundle extras,
 531             AssistStructure structure, AssistContent content, Uri referrer) throws RemoteException;
 532
 533     public boolean launchAssistIntent(Intent intent, int requestType, String hint, int userHandle,
 534             Bundle args) throws RemoteException;
 535
 536     public boolean isAssistDataAllowedOnCurrentActivity() throws RemoteException;
 537
 538     public boolean showAssistFromActivity(IBinder token, Bundle args) throws RemoteException;
 539
 540     public void killUid(int appId, int userId, String reason) throws RemoteException;
 541
 542     public void hang(IBinder who, boolean allowRestart) throws RemoteException;
 543
 544     public void reportActivityFullyDrawn(IBinder token) throws RemoteException;
 545
 546     public void restart() throws RemoteException;
 547
 548     public void performIdleMaintenance() throws RemoteException;
 549
 550     public void sendIdleJobTrigger() throws RemoteException;
 551
 552     public IActivityContainer createVirtualActivityContainer(IBinder parentActivityToken,
 553             IActivityContainerCallback callback) throws RemoteException;
 554
 555     public IActivityContainer createStackOnDisplay(int displayId) throws RemoteException;
 556
 557     public void deleteActivityContainer(IActivityContainer container) throws RemoteException;
 558
 559     public int getActivityDisplayId(IBinder activityToken) throws RemoteException;
 560
 561     public void startSystemLockTaskMode(int taskId) throws RemoteException;
 562
 563     public void startLockTaskMode(int taskId) throws RemoteException;
 564
 565     public void startLockTaskMode(IBinder token) throws RemoteException;
 566
 567     public void stopLockTaskMode() throws RemoteException;
 568
 569     public void stopSystemLockTaskMode() throws RemoteException;
 570
 571     public boolean isInLockTaskMode() throws RemoteException;
 572
 573     public int getLockTaskModeState() throws RemoteException;
 574
 575     public void showLockTaskEscapeMessage(IBinder token) throws RemoteException;
 576
 577     public void setTaskDescription(IBinder token, ActivityManager.TaskDescription values)
 578             throws RemoteException;
 579     public void setTaskResizeable(int taskId, int resizeableMode) throws RemoteException;
 580     public void resizeTask(int taskId, Rect bounds, int resizeMode) throws RemoteException;
 581
 582     public Rect getTaskBounds(int taskId) throws RemoteException;
 583     public Bitmap getTaskDescriptionIcon(String filename, int userId) throws RemoteException;
 584
 585     public void startInPlaceAnimationOnFrontMostApplication(ActivityOptions opts)
 586             throws RemoteException;
 587
 588     public boolean requestVisibleBehind(IBinder token, boolean visible) throws RemoteException;
 589     public boolean isBackgroundVisibleBehind(IBinder token) throws RemoteException;
 590     public void backgroundResourcesReleased(IBinder token) throws RemoteException;
 591
 592     public void notifyLaunchTaskBehindComplete(IBinder token) throws RemoteException;
 593     public void notifyEnterAnimationComplete(IBinder token) throws RemoteException;
 594
 595     public void notifyCleartextNetwork(int uid, byte[] firstPacket) throws RemoteException;
 596
 597     public void setDumpHeapDebugLimit(String processName, int uid, long maxMemSize,
 598             String reportPackage) throws RemoteException;
 599     public void dumpHeapFinished(String path) throws RemoteException;
 600
 601     public void setVoiceKeepAwake(IVoiceInteractionSession session, boolean keepAwake)
 602             throws RemoteException;
 603     public void updateLockTaskPackages(int userId, String[] packages) throws RemoteException;
 604     public void updateDeviceOwner(String packageName) throws RemoteException;
 605
 606     public int getPackageProcessState(String packageName, String callingPackage)
 607             throws RemoteException;
 608
 609     public boolean setProcessMemoryTrimLevel(String process, int uid, int level)
 610             throws RemoteException;
 611
 612     public boolean isRootVoiceInteraction(IBinder token) throws RemoteException;
 613
 614     // Start Binder transaction tracking for all applications.
 615     public boolean startBinderTracking() throws RemoteException;
 616
 617     // Stop Binder transaction tracking for all applications and dump trace data to the given file
 618     // descriptor.
 619     public boolean stopBinderTrackingAndDump(ParcelFileDescriptor fd) throws RemoteException;
 620
 621     public int getActivityStackId(IBinder token) throws RemoteException;
 622     public void exitFreeformMode(IBinder token) throws RemoteException;
 623
 624     public void suppressResizeConfigChanges(boolean suppress) throws RemoteException;
 625
 626     public void moveTasksToFullscreenStack(int fromStackId, boolean onTop) throws RemoteException;
 627
 628     public int getAppStartMode(int uid, String packageName) throws RemoteException;
 629
 630     public boolean isInMultiWindowMode(IBinder token) throws RemoteException;
 631
 632     public boolean isInPictureInPictureMode(IBinder token) throws RemoteException;
 633
 634     public void enterPictureInPictureMode(IBinder token) throws RemoteException;
 635
 636     public int setVrMode(IBinder token, boolean enabled, ComponentName packageName)
 637             throws RemoteException;
 638
 639     public boolean isVrModePackageEnabled(ComponentName packageName) throws RemoteException;
 640
 641     public boolean isAppForeground(int uid) throws RemoteException;
 642
 643     public void startLocalVoiceInteraction(IBinder token, Bundle options) throws RemoteException;
 644
 645     public void stopLocalVoiceInteraction(IBinder token) throws RemoteException;
 646
 647     public boolean supportsLocalVoiceInteraction() throws RemoteException;
 648
 649     public void notifyPinnedStackAnimationEnded() throws RemoteException;
 650
 651     public void removeStack(int stackId) throws RemoteException;
 652
 653     public void notifyLockedProfile(@UserIdInt int userId) throws RemoteException;
 654
 655     public void startConfirmDeviceCredentialIntent(Intent intent) throws RemoteException;
 656
 657     public int sendIntentSender(IIntentSender target, int code, Intent intent, String resolvedType,
 658             IIntentReceiver finishedReceiver, String requiredPermission, Bundle options)
 659             throws RemoteException;
 660
 661     public void setVrThread(int tid) throws RemoteException;
 662     public void setRenderThread(int tid) throws RemoteException;
 663
 664     /**
 665      * Lets activity manager know whether the calling process is currently showing "top-level" UI
 666      * that is not an activity, i.e. windows on the screen the user is currently interacting with.
 667      *
 668      * <p>This flag can only be set for persistent processes.
 669      *
 670      * @param hasTopUi Whether the calling process has "top-level" UI.
 671      */
 672     public void setHasTopUi(boolean hasTopUi) throws RemoteException;
 673
 674     /**
 675      * Returns if the target of the PendingIntent can be fired directly, without triggering
 676      * a work profile challenge. This can happen if the PendingIntent is to start direct-boot
 677      * aware activities, and the target user is in RUNNING_LOCKED state, i.e. we should allow
 678      * direct-boot aware activity to bypass work challenge when the user hasn't unlocked yet.
 679      * @param intent the {@link  PendingIntent} to be tested.
 680      * @return {@code true} if the intent should not trigger a work challenge, {@code false}
 681      *     otherwise.
 682      * @throws RemoteException
 683      */
 684     public boolean canBypassWorkChallenge(PendingIntent intent) throws RemoteException;
 685
 686     /*
 687      * Private non-Binder interfaces
 688      */
 689     /* package */ boolean testIsSystemReady();
 690
 691     /** Information you can retrieve about a particular application. */
 692     public static class ContentProviderHolder implements Parcelable {
 693         public final ProviderInfo info;
 694         public IContentProvider provider;
 695         public IBinder connection;
 696         public boolean noReleaseNeeded;
 697
 698         public ContentProviderHolder(ProviderInfo _info) {
 699             info = _info;
 700         }
 701
 702         @Override
 703         public int describeContents() {
 704             return 0;
 705         }
 706
 707         @Override
 708         public void writeToParcel(Parcel dest, int flags) {
 709             info.writeToParcel(dest, 0);
 710             if (provider != null) {
 711                 dest.writeStrongBinder(provider.asBinder());
 712             } else {
 713                 dest.writeStrongBinder(null);
 714             }
 715             dest.writeStrongBinder(connection);
 716             dest.writeInt(noReleaseNeeded ? 1 : 0);
 717         }
 718
 719         public static final Parcelable.Creator<ContentProviderHolder> CREATOR
 720                 = new Parcelable.Creator<ContentProviderHolder>() {
 721             @Override
 722             public ContentProviderHolder createFromParcel(Parcel source) {
 723                 return new ContentProviderHolder(source);
 724             }
 725
 726             @Override
 727             public ContentProviderHolder[] newArray(int size) {
 728                 return new ContentProviderHolder[size];
 729             }
 730         };
 731
 732         private ContentProviderHolder(Parcel source) {
 733             info = ProviderInfo.CREATOR.createFromParcel(source);
 734             provider = ContentProviderNative.asInterface(
 735                     source.readStrongBinder());
 736             connection = source.readStrongBinder();
 737             noReleaseNeeded = source.readInt() != 0;
 738         }
 739     }
 740
 741     /** Information returned after waiting for an activity start. */
 742     public static class WaitResult implements Parcelable {
 743         public int result;
 744         public boolean timeout;
 745         public ComponentName who;
 746         public long thisTime;
 747         public long totalTime;
 748
 749         public WaitResult() {
 750         }
 751
 752         @Override
 753         public int describeContents() {
 754             return 0;
 755         }
 756
 757         @Override
 758         public void writeToParcel(Parcel dest, int flags) {
 759             dest.writeInt(result);
 760             dest.writeInt(timeout ? 1 : 0);
 761             ComponentName.writeToParcel(who, dest);
 762             dest.writeLong(thisTime);
 763             dest.writeLong(totalTime);
 764         }
 765
 766         public static final Parcelable.Creator<WaitResult> CREATOR
 767                 = new Parcelable.Creator<WaitResult>() {
 768             @Override
 769             public WaitResult createFromParcel(Parcel source) {
 770                 return new WaitResult(source);
 771             }
 772
 773             @Override
 774             public WaitResult[] newArray(int size) {
 775                 return new WaitResult[size];
 776             }
 777         };
 778
 779         private WaitResult(Parcel source) {
 780             result = source.readInt();
 781             timeout = source.readInt() != 0;
 782             who = ComponentName.readFromParcel(source);
 783             thisTime = source.readLong();
 784             totalTime = source.readLong();
 785         }
 786     }
 787
 788     String descriptor = "android.app.IActivityManager";
 789
 790     // Please keep these transaction codes the same -- they are also
 791     // sent by C++ code.
 792     int HANDLE_APPLICATION_CRASH_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+1;
 793     int START_ACTIVITY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+2;
 794     int UNHANDLED_BACK_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+3;
 795     int OPEN_CONTENT_URI_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+4;
 796
 797     // Remaining non-native transaction codes.
 798     int FINISH_ACTIVITY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+10;
 799     int REGISTER_RECEIVER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+11;
 800     int UNREGISTER_RECEIVER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+12;
 801     int BROADCAST_INTENT_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+13;
 802     int UNBROADCAST_INTENT_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+14;
 803     int FINISH_RECEIVER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+15;
 804     int ATTACH_APPLICATION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+16;
 805     int ACTIVITY_IDLE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+17;
 806     int ACTIVITY_PAUSED_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+18;
 807     int ACTIVITY_STOPPED_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+19;
 808     int GET_CALLING_PACKAGE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+20;
 809     int GET_CALLING_ACTIVITY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+21;
 810     int GET_TASKS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+22;
 811     int MOVE_TASK_TO_FRONT_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+23;
 812
 813     int MOVE_TASK_BACKWARDS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+25;
 814     int GET_TASK_FOR_ACTIVITY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+26;
 815
 816     int GET_CONTENT_PROVIDER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+28;
 817     int PUBLISH_CONTENT_PROVIDERS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+29;
 818     int REF_CONTENT_PROVIDER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+30;
 819     int FINISH_SUB_ACTIVITY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+31;
 820     int GET_RUNNING_SERVICE_CONTROL_PANEL_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+32;
 821     int START_SERVICE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+33;
 822     int STOP_SERVICE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+34;
 823     int BIND_SERVICE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+35;
 824     int UNBIND_SERVICE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+36;
 825     int PUBLISH_SERVICE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+37;
 826     int ACTIVITY_RESUMED_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+38;
 827     int SET_DEBUG_APP_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+41;
 828     int SET_ALWAYS_FINISH_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+42;
 829     int START_INSTRUMENTATION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+43;
 830     int FINISH_INSTRUMENTATION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+44;
 831     int GET_CONFIGURATION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+45;
 832     int UPDATE_CONFIGURATION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+46;
 833     int STOP_SERVICE_TOKEN_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+47;
 834     int GET_ACTIVITY_CLASS_FOR_TOKEN_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+48;
 835     int GET_PACKAGE_FOR_TOKEN_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+49;
 836     int SET_PROCESS_LIMIT_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+50;
 837     int GET_PROCESS_LIMIT_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+51;
 838     int CHECK_PERMISSION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+52;
 839     int CHECK_URI_PERMISSION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+53;
 840     int GRANT_URI_PERMISSION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+54;
 841     int REVOKE_URI_PERMISSION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+55;
 842     int SET_ACTIVITY_CONTROLLER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+56;
 843     int SHOW_WAITING_FOR_DEBUGGER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+57;
 844     int SIGNAL_PERSISTENT_PROCESSES_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+58;
 845     int GET_RECENT_TASKS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+59;
 846     int SERVICE_DONE_EXECUTING_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+60;
 847     int ACTIVITY_DESTROYED_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+61;
 848     int GET_INTENT_SENDER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+62;
 849     int CANCEL_INTENT_SENDER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+63;
 850     int GET_PACKAGE_FOR_INTENT_SENDER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+64;
 851     int ENTER_SAFE_MODE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+65;
 852     int START_NEXT_MATCHING_ACTIVITY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+66;
 853     int NOTE_WAKEUP_ALARM_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+67;
 854     int REMOVE_CONTENT_PROVIDER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+68;
 855     int SET_REQUESTED_ORIENTATION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+69;
 856     int GET_REQUESTED_ORIENTATION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+70;
 857     int UNBIND_FINISHED_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+71;
 858     int SET_PROCESS_FOREGROUND_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+72;
 859     int SET_SERVICE_FOREGROUND_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+73;
 860     int MOVE_ACTIVITY_TASK_TO_BACK_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+74;
 861     int GET_MEMORY_INFO_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+75;
 862     int GET_PROCESSES_IN_ERROR_STATE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+76;
 863     int CLEAR_APP_DATA_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+77;
 864     int FORCE_STOP_PACKAGE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+78;
 865     int KILL_PIDS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+79;
 866     int GET_SERVICES_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+80;
 867     int GET_TASK_THUMBNAIL_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+81;
 868     int GET_RUNNING_APP_PROCESSES_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+82;
 869     int GET_DEVICE_CONFIGURATION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+83;
 870     int PEEK_SERVICE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+84;
 871     int PROFILE_CONTROL_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+85;
 872     int SHUTDOWN_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+86;
 873     int STOP_APP_SWITCHES_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+87;
 874     int RESUME_APP_SWITCHES_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+88;
 875     int START_BACKUP_AGENT_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+89;
 876     int BACKUP_AGENT_CREATED_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+90;
 877     int UNBIND_BACKUP_AGENT_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+91;
 878     int GET_UID_FOR_INTENT_SENDER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+92;
 879     int HANDLE_INCOMING_USER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+93;
 880     int ADD_PACKAGE_DEPENDENCY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+94;
 881     int KILL_APPLICATION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+95;
 882     int CLOSE_SYSTEM_DIALOGS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+96;
 883     int GET_PROCESS_MEMORY_INFO_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+97;
 884     int KILL_APPLICATION_PROCESS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+98;
 885     int START_ACTIVITY_INTENT_SENDER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+99;
 886     int OVERRIDE_PENDING_TRANSITION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+100;
 887     int HANDLE_APPLICATION_WTF_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+101;
 888     int KILL_BACKGROUND_PROCESSES_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+102;
 889     int IS_USER_A_MONKEY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+103;
 890     int START_ACTIVITY_AND_WAIT_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+104;
 891     int WILL_ACTIVITY_BE_VISIBLE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+105;
 892     int START_ACTIVITY_WITH_CONFIG_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+106;
 893     int GET_RUNNING_EXTERNAL_APPLICATIONS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+107;
 894     int FINISH_HEAVY_WEIGHT_APP_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+108;
 895     int HANDLE_APPLICATION_STRICT_MODE_VIOLATION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+109;
 896     int IS_IMMERSIVE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+110;
 897     int SET_IMMERSIVE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+111;
 898     int IS_TOP_ACTIVITY_IMMERSIVE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+112;
 899     int CRASH_APPLICATION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+113;
 900     int GET_PROVIDER_MIME_TYPE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+114;
 901     int NEW_URI_PERMISSION_OWNER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+115;
 902     int GRANT_URI_PERMISSION_FROM_OWNER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+116;
 903     int REVOKE_URI_PERMISSION_FROM_OWNER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+117;
 904     int CHECK_GRANT_URI_PERMISSION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+118;
 905     int DUMP_HEAP_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+119;
 906     int START_ACTIVITIES_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+120;
 907     int IS_USER_RUNNING_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+121;
 908     int ACTIVITY_SLEPT_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+122;
 909     int GET_FRONT_ACTIVITY_SCREEN_COMPAT_MODE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+123;
 910     int SET_FRONT_ACTIVITY_SCREEN_COMPAT_MODE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+124;
 911     int GET_PACKAGE_SCREEN_COMPAT_MODE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+125;
 912     int SET_PACKAGE_SCREEN_COMPAT_MODE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+126;
 913     int GET_PACKAGE_ASK_SCREEN_COMPAT_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+127;
 914     int SET_PACKAGE_ASK_SCREEN_COMPAT_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+128;
 915     int SWITCH_USER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+129;
 916     int SET_FOCUSED_TASK_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+130;
 917     int REMOVE_TASK_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+131;
 918     int REGISTER_PROCESS_OBSERVER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+132;
 919     int UNREGISTER_PROCESS_OBSERVER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+133;
 920     int IS_INTENT_SENDER_TARGETED_TO_PACKAGE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+134;
 921     int UPDATE_PERSISTENT_CONFIGURATION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+135;
 922     int GET_PROCESS_PSS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+136;
 923     int SHOW_BOOT_MESSAGE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+137;
 924     int KILL_ALL_BACKGROUND_PROCESSES_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+139;
 925     int GET_CONTENT_PROVIDER_EXTERNAL_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+140;
 926     int REMOVE_CONTENT_PROVIDER_EXTERNAL_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+141;
 927     int GET_MY_MEMORY_STATE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+142;
 928     int KILL_PROCESSES_BELOW_FOREGROUND_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+143;
 929     int GET_CURRENT_USER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+144;
 930     int SHOULD_UP_RECREATE_TASK_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+145;
 931     int NAVIGATE_UP_TO_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+146;
 932     int SET_LOCK_SCREEN_SHOWN_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+147;
 933     int FINISH_ACTIVITY_AFFINITY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+148;
 934     int GET_LAUNCHED_FROM_UID_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+149;
 935     int UNSTABLE_PROVIDER_DIED_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+150;
 936     int IS_INTENT_SENDER_AN_ACTIVITY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+151;
 937     int START_ACTIVITY_AS_USER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+152;
 938     int STOP_USER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+153;
 939     int REGISTER_USER_SWITCH_OBSERVER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+154;
 940     int UNREGISTER_USER_SWITCH_OBSERVER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+155;
 941     int GET_RUNNING_USER_IDS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+156;
 942     int REQUEST_BUG_REPORT_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+157;
 943     int INPUT_DISPATCHING_TIMED_OUT_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+158;
 944     int CLEAR_PENDING_BACKUP_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+159;
 945     int GET_INTENT_FOR_INTENT_SENDER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+160;
 946     int GET_ASSIST_CONTEXT_EXTRAS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+161;
 947     int REPORT_ASSIST_CONTEXT_EXTRAS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+162;
 948     int GET_LAUNCHED_FROM_PACKAGE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+163;
 949     int KILL_UID_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+164;
 950     int SET_USER_IS_MONKEY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+165;
 951     int HANG_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+166;
 952     int CREATE_VIRTUAL_ACTIVITY_CONTAINER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+167;
 953     int MOVE_TASK_TO_STACK_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+168;
 954     int RESIZE_STACK_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+169;
 955     int GET_ALL_STACK_INFOS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+170;
 956     int SET_FOCUSED_STACK_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+171;
 957     int GET_STACK_INFO_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+172;
 958     int CONVERT_FROM_TRANSLUCENT_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+173;
 959     int CONVERT_TO_TRANSLUCENT_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+174;
 960     int NOTIFY_ACTIVITY_DRAWN_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+175;
 961     int REPORT_ACTIVITY_FULLY_DRAWN_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+176;
 962     int RESTART_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+177;
 963     int PERFORM_IDLE_MAINTENANCE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+178;
 964     int TAKE_PERSISTABLE_URI_PERMISSION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+179;
 965     int RELEASE_PERSISTABLE_URI_PERMISSION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+180;
 966     int GET_PERSISTED_URI_PERMISSIONS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+181;
 967     int APP_NOT_RESPONDING_VIA_PROVIDER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+182;
 968     int GET_TASK_BOUNDS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+183;
 969     int GET_ACTIVITY_DISPLAY_ID_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+184;
 970     int DELETE_ACTIVITY_CONTAINER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+185;
 971     int SET_PROCESS_MEMORY_TRIM_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+186;
 972
 973
 974     // Start of L transactions
 975     int GET_TAG_FOR_INTENT_SENDER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+210;
 976     int START_USER_IN_BACKGROUND_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+211;
 977     int IS_IN_HOME_STACK_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+212;
 978     int START_LOCK_TASK_BY_TASK_ID_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+213;
 979     int START_LOCK_TASK_BY_TOKEN_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+214;
 980     int STOP_LOCK_TASK_MODE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+215;
 981     int IS_IN_LOCK_TASK_MODE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+216;
 982     int SET_TASK_DESCRIPTION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+217;
 983     int START_VOICE_ACTIVITY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+218;
 984     int GET_ACTIVITY_OPTIONS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+219;
 985     int GET_APP_TASKS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+220;
 986     int START_SYSTEM_LOCK_TASK_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+221;
 987     int STOP_SYSTEM_LOCK_TASK_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+222;
 988     int FINISH_VOICE_TASK_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+223;
 989     int IS_TOP_OF_TASK_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+224;
 990     int REQUEST_VISIBLE_BEHIND_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+225;
 991     int IS_BACKGROUND_VISIBLE_BEHIND_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+226;
 992     int BACKGROUND_RESOURCES_RELEASED_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+227;
 993     int NOTIFY_LAUNCH_TASK_BEHIND_COMPLETE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+228;
 994     int START_ACTIVITY_FROM_RECENTS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 229;
 995     int NOTIFY_ENTER_ANIMATION_COMPLETE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+230;
 996     int KEYGUARD_WAITING_FOR_ACTIVITY_DRAWN_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+231;
 997     int START_ACTIVITY_AS_CALLER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+232;
 998     int ADD_APP_TASK_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+233;
 999     int GET_APP_TASK_THUMBNAIL_SIZE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+234;
1000     int RELEASE_ACTIVITY_INSTANCE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+235;
1001     int RELEASE_SOME_ACTIVITIES_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+236;
1002     int BOOT_ANIMATION_COMPLETE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+237;
1003     int GET_TASK_DESCRIPTION_ICON_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+238;
1004     int LAUNCH_ASSIST_INTENT_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+239;
1005     int START_IN_PLACE_ANIMATION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+240;
1006     int CHECK_PERMISSION_WITH_TOKEN_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+241;
1007     int REGISTER_TASK_STACK_LISTENER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+242;
1008
1009     // Start of M transactions
1010     int NOTIFY_CLEARTEXT_NETWORK_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+280;
1011     int CREATE_STACK_ON_DISPLAY = IBinder.FIRST_CALL_TRANSACTION+281;
1012     int GET_FOCUSED_STACK_ID_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+282;
1013     int SET_TASK_RESIZEABLE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+283;
1014     int REQUEST_ASSIST_CONTEXT_EXTRAS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+284;
1015     int RESIZE_TASK_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+285;
1016     int GET_LOCK_TASK_MODE_STATE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+286;
1017     int SET_DUMP_HEAP_DEBUG_LIMIT_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+287;
1018     int DUMP_HEAP_FINISHED_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+288;
1019     int SET_VOICE_KEEP_AWAKE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+289;
1020     int UPDATE_LOCK_TASK_PACKAGES_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+290;
1021     int NOTE_ALARM_START_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+291;
1022     int NOTE_ALARM_FINISH_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+292;
1023     int GET_PACKAGE_PROCESS_STATE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+293;
1024     int SHOW_LOCK_TASK_ESCAPE_MESSAGE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+294;
1025     int UPDATE_DEVICE_OWNER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+295;
1026     int KEYGUARD_GOING_AWAY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+296;
1027     int REGISTER_UID_OBSERVER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+297;
1028     int UNREGISTER_UID_OBSERVER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+298;
1029     int IS_SCREEN_CAPTURE_ALLOWED_ON_CURRENT_ACTIVITY_TRANSACTION
1030             = IBinder.FIRST_CALL_TRANSACTION+299;
1031     int SHOW_ASSIST_FROM_ACTIVITY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+300;
1032     int IS_ROOT_VOICE_INTERACTION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+301;
1033
1034     // Start of N transactions
1035     int START_BINDER_TRACKING_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 340;
1036     int STOP_BINDER_TRACKING_AND_DUMP_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 341;
1037     int POSITION_TASK_IN_STACK_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 342;
1038     int GET_ACTIVITY_STACK_ID_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 343;
1039     int EXIT_FREEFORM_MODE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 344;
1040     int REPORT_SIZE_CONFIGURATIONS = IBinder.FIRST_CALL_TRANSACTION + 345;
1041     int MOVE_TASK_TO_DOCKED_STACK_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 346;
1042     int SUPPRESS_RESIZE_CONFIG_CHANGES_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 347;
1043     int MOVE_TASKS_TO_FULLSCREEN_STACK_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 348;
1044     int MOVE_TOP_ACTIVITY_TO_PINNED_STACK_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 349;
1045     int GET_APP_START_MODE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 350;
1046     int UNLOCK_USER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 351;
1047     int IN_MULTI_WINDOW_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 352;
1048     int IN_PICTURE_IN_PICTURE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 353;
1049     int KILL_PACKAGE_DEPENDENTS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 354;
1050     int ENTER_PICTURE_IN_PICTURE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 355;
1051     int ACTIVITY_RELAUNCHED_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 356;
1052     int GET_URI_PERMISSION_OWNER_FOR_ACTIVITY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 357;
1053     int RESIZE_DOCKED_STACK_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 358;
1054     int SET_VR_MODE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 359;
1055     int GET_GRANTED_URI_PERMISSIONS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 360;
1056     int CLEAR_GRANTED_URI_PERMISSIONS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 361;
1057     int IS_APP_FOREGROUND_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 362;
1058     int START_LOCAL_VOICE_INTERACTION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 363;
1059     int STOP_LOCAL_VOICE_INTERACTION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 364;
1060     int SUPPORTS_LOCAL_VOICE_INTERACTION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 365;
1061     int NOTIFY_PINNED_STACK_ANIMATION_ENDED_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 366;
1062     int REMOVE_STACK = IBinder.FIRST_CALL_TRANSACTION + 367;
1063     int SET_LENIENT_BACKGROUND_CHECK_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+368;
1064     int GET_MEMORY_TRIM_LEVEL_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+369;
1065     int RESIZE_PINNED_STACK_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 370;
1066     int IS_VR_PACKAGE_ENABLED_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 371;
1067     int SWAP_DOCKED_AND_FULLSCREEN_STACK = IBinder.FIRST_CALL_TRANSACTION + 372;
1068     int NOTIFY_LOCKED_PROFILE = IBinder.FIRST_CALL_TRANSACTION + 373;
1069     int START_CONFIRM_DEVICE_CREDENTIAL_INTENT = IBinder.FIRST_CALL_TRANSACTION + 374;
1070     int SEND_IDLE_JOB_TRIGGER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 375;
1071     int SEND_INTENT_SENDER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 376;
1072
1073     // Start of N MR1 transactions
1074     int SET_VR_THREAD_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 377;
1075     int SET_RENDER_THREAD_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 378;
1076     int SET_HAS_TOP_UI = IBinder.FIRST_CALL_TRANSACTION + 379;
1077     int CAN_BYPASS_WORK_CHALLENGE = IBinder.FIRST_CALL_TRANSACTION + 380;
1078 }