core/java/android/app/IActivityManager.aidl

   1 /*
   2  * Copyright (C) 2016 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.app.ActivityManager;
  20 import android.app.ApplicationErrorReport;
  21 import android.app.ContentProviderHolder;
  22 import android.app.IApplicationThread;
  23 import android.app.IActivityContainer;
  24 import android.app.IActivityContainerCallback;
  25 import android.app.IActivityController;
  26 import android.app.IAppTask;
  27 import android.app.IInstrumentationWatcher;
  28 import android.app.IProcessObserver;
  29 import android.app.IServiceConnection;
  30 import android.app.IStopUserCallback;
  31 import android.app.ITaskStackListener;
  32 import android.app.IUiAutomationConnection;
  33 import android.app.IUidObserver;
  34 import android.app.IUserSwitchObserver;
  35 import android.app.Notification;
  36 import android.app.PendingIntent;
  37 import android.app.PictureInPictureParams;
  38 import android.app.ProfilerInfo;
  39 import android.app.WaitResult;
  40 import android.app.assist.AssistContent;
  41 import android.app.assist.AssistStructure;
  42 import android.content.ComponentName;
  43 import android.content.IIntentReceiver;
  44 import android.content.IIntentSender;
  45 import android.content.Intent;
  46 import android.content.IntentFilter;
  47 import android.content.IntentSender;
  48 import android.content.pm.ApplicationInfo;
  49 import android.content.pm.ConfigurationInfo;
  50 import android.content.pm.IPackageDataObserver;
  51 import android.content.pm.ParceledListSlice;
  52 import android.content.pm.ProviderInfo;
  53 import android.content.pm.UserInfo;
  54 import android.content.res.Configuration;
  55 import android.graphics.Bitmap;
  56 import android.graphics.GraphicBuffer;
  57 import android.graphics.Point;
  58 import android.graphics.Rect;
  59 import android.net.Uri;
  60 import android.os.Bundle;
  61 import android.os.Debug;
  62 import android.os.IBinder;
  63 import android.os.IProgressListener;
  64 import android.os.ParcelFileDescriptor;
  65 import android.os.PersistableBundle;
  66 import android.os.StrictMode;
  67 import android.service.voice.IVoiceInteractionSession;
  68 import com.android.internal.app.IVoiceInteractor;
  69 import com.android.internal.os.IResultReceiver;
  70 import com.android.internal.policy.IKeyguardDismissCallback;
  71
  72 import java.util.List;
  73
  74 /**
  75  * System private API for talking with the activity manager service.  This
  76  * provides calls from the application back to the activity manager.
  77  *
  78  * {@hide}
  79  */
  80 interface IActivityManager {
  81     // WARNING: when these transactions are updated, check if they are any callers on the native
  82     // side. If so, make sure they are using the correct transaction ids and arguments.
  83     // If a transaction which will also be used on the native side is being inserted, add it to
  84     // below block of transactions.
  85
  86     // Since these transactions are also called from native code, these must be kept in sync with
  87     // the ones in frameworks/native/include/binder/IActivityManager.h
  88     // =============== Beginning of transactions used on native side as well ======================
  89     ParcelFileDescriptor openContentUri(in String uriString);
  90     // =============== End of transactions used on native side as well ============================
  91
  92     // Special low-level communication with activity manager.
  93     void handleApplicationCrash(in IBinder app,
  94             in ApplicationErrorReport.ParcelableCrashInfo crashInfo);
  95     int startActivity(in IApplicationThread caller, in String callingPackage, in Intent intent,
  96             in String resolvedType, in IBinder resultTo, in String resultWho, int requestCode,
  97             int flags, in ProfilerInfo profilerInfo, in Bundle options);
  98     void unhandledBack();
  99
 100     boolean finishActivity(in IBinder token, int code, in Intent data, int finishTask);
 101     Intent registerReceiver(in IApplicationThread caller, in String callerPackage,
 102             in IIntentReceiver receiver, in IntentFilter filter,
 103             in String requiredPermission, int userId, int flags);
 104     void unregisterReceiver(in IIntentReceiver receiver);
 105     int broadcastIntent(in IApplicationThread caller, in Intent intent,
 106             in String resolvedType, in IIntentReceiver resultTo, int resultCode,
 107             in String resultData, in Bundle map, in String[] requiredPermissions,
 108             int appOp, in Bundle options, boolean serialized, boolean sticky, int userId);
 109     void unbroadcastIntent(in IApplicationThread caller, in Intent intent, int userId);
 110     oneway void finishReceiver(in IBinder who, int resultCode, in String resultData, in Bundle map,
 111             boolean abortBroadcast, int flags);
 112     void attachApplication(in IApplicationThread app);
 113     oneway void activityIdle(in IBinder token, in Configuration config,
 114             in boolean stopProfiling);
 115     void activityPaused(in IBinder token);
 116     oneway void activityStopped(in IBinder token, in Bundle state,
 117             in PersistableBundle persistentState, in CharSequence description);
 118     String getCallingPackage(in IBinder token);
 119     ComponentName getCallingActivity(in IBinder token);
 120     List<ActivityManager.RunningTaskInfo> getTasks(int maxNum, int flags);
 121     void moveTaskToFront(int task, int flags, in Bundle options);
 122     void moveTaskBackwards(int task);
 123     int getTaskForActivity(in IBinder token, in boolean onlyRoot);
 124     ContentProviderHolder getContentProvider(in IApplicationThread caller,
 125             in String name, int userId, boolean stable);
 126     void publishContentProviders(in IApplicationThread caller,
 127             in List<ContentProviderHolder> providers);
 128     boolean refContentProvider(in IBinder connection, int stableDelta, int unstableDelta);
 129     void finishSubActivity(in IBinder token, in String resultWho, int requestCode);
 130     PendingIntent getRunningServiceControlPanel(in ComponentName service);
 131     ComponentName startService(in IApplicationThread caller, in Intent service,
 132             in String resolvedType, boolean requireForeground, in String callingPackage, int userId);
 133     int stopService(in IApplicationThread caller, in Intent service,
 134             in String resolvedType, int userId);
 135     int bindService(in IApplicationThread caller, in IBinder token, in Intent service,
 136             in String resolvedType, in IServiceConnection connection, int flags,
 137             in String callingPackage, int userId);
 138     boolean unbindService(in IServiceConnection connection);
 139     void publishService(in IBinder token, in Intent intent, in IBinder service);
 140     void activityResumed(in IBinder token);
 141     void setDebugApp(in String packageName, boolean waitForDebugger, boolean persistent);
 142     void setAlwaysFinish(boolean enabled);
 143     boolean startInstrumentation(in ComponentName className, in String profileFile,
 144             int flags, in Bundle arguments, in IInstrumentationWatcher watcher,
 145             in IUiAutomationConnection connection, int userId,
 146             in String abiOverride);
 147     void addInstrumentationResults(in IApplicationThread target, in Bundle results);
 148     void finishInstrumentation(in IApplicationThread target, int resultCode,
 149             in Bundle results);
 150     /**
 151      * @return A copy of global {@link Configuration}, contains general settings for the entire
 152      *         system. Corresponds to the configuration of the default display.
 153      * @throws RemoteException
 154      */
 155     Configuration getConfiguration();
 156     /**
 157      * Updates global configuration and applies changes to the entire system.
 158      * @param values Update values for global configuration. If null is passed it will request the
 159      *               Window Manager to compute new config for the default display.
 160      * @throws RemoteException
 161      * @return Returns true if the configuration was updated.
 162      */
 163     boolean updateConfiguration(in Configuration values);
 164     boolean stopServiceToken(in ComponentName className, in IBinder token, int startId);
 165     ComponentName getActivityClassForToken(in IBinder token);
 166     String getPackageForToken(in IBinder token);
 167     void setProcessLimit(int max);
 168     int getProcessLimit();
 169     int checkPermission(in String permission, int pid, int uid);
 170     int checkUriPermission(in Uri uri, int pid, int uid, int mode, int userId,
 171             in IBinder callerToken);
 172     void grantUriPermission(in IApplicationThread caller, in String targetPkg, in Uri uri,
 173             int mode, int userId);
 174     void revokeUriPermission(in IApplicationThread caller, in String targetPkg, in Uri uri,
 175             int mode, int userId);
 176     void setActivityController(in IActivityController watcher, boolean imAMonkey);
 177     void showWaitingForDebugger(in IApplicationThread who, boolean waiting);
 178     /*
 179      * This will deliver the specified signal to all the persistent processes. Currently only
 180      * SIGUSR1 is delivered. All others are ignored.
 181      */
 182     void signalPersistentProcesses(int signal);
 183     ParceledListSlice getRecentTasks(int maxNum,
 184             int flags, int userId);
 185     oneway void serviceDoneExecuting(in IBinder token, int type, int startId, int res);
 186     oneway void activityDestroyed(in IBinder token);
 187     IIntentSender getIntentSender(int type, in String packageName, in IBinder token,
 188             in String resultWho, int requestCode, in Intent[] intents, in String[] resolvedTypes,
 189             int flags, in Bundle options, int userId);
 190     void cancelIntentSender(in IIntentSender sender);
 191     String getPackageForIntentSender(in IIntentSender sender);
 192     void registerIntentSenderCancelListener(in IIntentSender sender, in IResultReceiver receiver);
 193     void unregisterIntentSenderCancelListener(in IIntentSender sender, in IResultReceiver receiver);
 194     void enterSafeMode();
 195     boolean startNextMatchingActivity(in IBinder callingActivity,
 196             in Intent intent, in Bundle options);
 197     void noteWakeupAlarm(in IIntentSender sender, int sourceUid,
 198             in String sourcePkg, in String tag);
 199     void removeContentProvider(in IBinder connection, boolean stable);
 200     void setRequestedOrientation(in IBinder token, int requestedOrientation);
 201     int getRequestedOrientation(in IBinder token);
 202     void unbindFinished(in IBinder token, in Intent service, boolean doRebind);
 203     void setProcessImportant(in IBinder token, int pid, boolean isForeground, String reason);
 204     void setServiceForeground(in ComponentName className, in IBinder token,
 205             int id, in Notification notification, int flags);
 206     boolean moveActivityTaskToBack(in IBinder token, boolean nonRoot);
 207     void getMemoryInfo(out ActivityManager.MemoryInfo outInfo);
 208     List<ActivityManager.ProcessErrorStateInfo> getProcessesInErrorState();
 209     boolean clearApplicationUserData(in String packageName,
 210             in IPackageDataObserver observer, int userId);
 211     void forceStopPackage(in String packageName, int userId);
 212     boolean killPids(in int[] pids, in String reason, boolean secure);
 213     List<ActivityManager.RunningServiceInfo> getServices(int maxNum, int flags);
 214     ActivityManager.TaskThumbnail getTaskThumbnail(int taskId);
 215     ActivityManager.TaskDescription getTaskDescription(int taskId);
 216     // Retrieve running application processes in the system
 217     List<ActivityManager.RunningAppProcessInfo> getRunningAppProcesses();
 218     // Get device configuration
 219     ConfigurationInfo getDeviceConfigurationInfo();
 220     IBinder peekService(in Intent service, in String resolvedType, in String callingPackage);
 221     // Turn on/off profiling in a particular process.
 222     boolean profileControl(in String process, int userId, boolean start,
 223             in ProfilerInfo profilerInfo, int profileType);
 224     boolean shutdown(int timeout);
 225     void stopAppSwitches();
 226     void resumeAppSwitches();
 227     boolean bindBackupAgent(in String packageName, int backupRestoreMode, int userId);
 228     void backupAgentCreated(in String packageName, in IBinder agent);
 229     void unbindBackupAgent(in ApplicationInfo appInfo);
 230     int getUidForIntentSender(in IIntentSender sender);
 231     int handleIncomingUser(int callingPid, int callingUid, int userId, boolean allowAll,
 232             boolean requireFull, in String name, in String callerPackage);
 233     void addPackageDependency(in String packageName);
 234     void killApplication(in String pkg, int appId, int userId, in String reason);
 235     void closeSystemDialogs(in String reason);
 236     Debug.MemoryInfo[] getProcessMemoryInfo(in int[] pids);
 237     void killApplicationProcess(in String processName, int uid);
 238     int startActivityIntentSender(in IApplicationThread caller,
 239             in IIntentSender target, in IBinder whitelistToken, in Intent fillInIntent,
 240             in String resolvedType, in IBinder resultTo, in String resultWho, int requestCode,
 241             int flagsMask, int flagsValues, in Bundle options);
 242     void overridePendingTransition(in IBinder token, in String packageName,
 243             int enterAnim, int exitAnim);
 244     // Special low-level communication with activity manager.
 245     boolean handleApplicationWtf(in IBinder app, in String tag, boolean system,
 246             in ApplicationErrorReport.ParcelableCrashInfo crashInfo);
 247     void killBackgroundProcesses(in String packageName, int userId);
 248     boolean isUserAMonkey();
 249     WaitResult startActivityAndWait(in IApplicationThread caller, in String callingPackage,
 250             in Intent intent, in String resolvedType, in IBinder resultTo, in String resultWho,
 251             int requestCode, int flags, in ProfilerInfo profilerInfo, in Bundle options,
 252             int userId);
 253     boolean willActivityBeVisible(in IBinder token);
 254     int startActivityWithConfig(in IApplicationThread caller, in String callingPackage,
 255             in Intent intent, in String resolvedType, in IBinder resultTo, in String resultWho,
 256             int requestCode, int startFlags, in Configuration newConfig,
 257             in Bundle options, int userId);
 258     // Retrieve info of applications installed on external media that are currently
 259     // running.
 260     List<ApplicationInfo> getRunningExternalApplications();
 261     void finishHeavyWeightApp();
 262     // A StrictMode violation to be handled.  The violationMask is a
 263     // subset of the original StrictMode policy bitmask, with only the
 264     // bit violated and penalty bits to be executed by the
 265     // ActivityManagerService remaining set.
 266     void handleApplicationStrictModeViolation(in IBinder app, int violationMask,
 267             in StrictMode.ViolationInfo crashInfo);
 268     boolean isImmersive(in IBinder token);
 269     void setImmersive(in IBinder token, boolean immersive);
 270     boolean isTopActivityImmersive();
 271     void crashApplication(int uid, int initialPid, in String packageName, int userId, in String message);
 272     String getProviderMimeType(in Uri uri, int userId);
 273     IBinder newUriPermissionOwner(in String name);
 274     void grantUriPermissionFromOwner(in IBinder owner, int fromUid, in String targetPkg,
 275             in Uri uri, int mode, int sourceUserId, int targetUserId);
 276     void revokeUriPermissionFromOwner(in IBinder owner, in Uri uri, int mode, int userId);
 277     int checkGrantUriPermission(int callingUid, in String targetPkg, in Uri uri,
 278             int modeFlags, int userId);
 279     // Cause the specified process to dump the specified heap.
 280     boolean dumpHeap(in String process, int userId, boolean managed, in String path,
 281             in ParcelFileDescriptor fd);
 282     int startActivities(in IApplicationThread caller, in String callingPackage,
 283             in Intent[] intents, in String[] resolvedTypes, in IBinder resultTo,
 284             in Bundle options, int userId);
 285     boolean isUserRunning(int userid, int flags);
 286     oneway void activitySlept(in IBinder token);
 287     int getFrontActivityScreenCompatMode();
 288     void setFrontActivityScreenCompatMode(int mode);
 289     int getPackageScreenCompatMode(in String packageName);
 290     void setPackageScreenCompatMode(in String packageName, int mode);
 291     boolean getPackageAskScreenCompat(in String packageName);
 292     void setPackageAskScreenCompat(in String packageName, boolean ask);
 293     boolean switchUser(int userid);
 294     void setFocusedTask(int taskId);
 295     boolean removeTask(int taskId);
 296     void registerProcessObserver(in IProcessObserver observer);
 297     void unregisterProcessObserver(in IProcessObserver observer);
 298     boolean isIntentSenderTargetedToPackage(in IIntentSender sender);
 299     void updatePersistentConfiguration(in Configuration values);
 300     long[] getProcessPss(in int[] pids);
 301     void showBootMessage(in CharSequence msg, boolean always);
 302     void killAllBackgroundProcesses();
 303     ContentProviderHolder getContentProviderExternal(in String name, int userId,
 304             in IBinder token);
 305     void removeContentProviderExternal(in String name, in IBinder token);
 306     // Get memory information about the calling process.
 307     void getMyMemoryState(out ActivityManager.RunningAppProcessInfo outInfo);
 308     boolean killProcessesBelowForeground(in String reason);
 309     UserInfo getCurrentUser();
 310     boolean shouldUpRecreateTask(in IBinder token, in String destAffinity);
 311     boolean navigateUpTo(in IBinder token, in Intent target, int resultCode,
 312             in Intent resultData);
 313     void setLockScreenShown(boolean showing);
 314     boolean finishActivityAffinity(in IBinder token);
 315     // This is not public because you need to be very careful in how you
 316     // manage your activity to make sure it is always the uid you expect.
 317     int getLaunchedFromUid(in IBinder activityToken);
 318     void unstableProviderDied(in IBinder connection);
 319     boolean isIntentSenderAnActivity(in IIntentSender sender);
 320     int startActivityAsUser(in IApplicationThread caller, in String callingPackage,
 321             in Intent intent, in String resolvedType, in IBinder resultTo, in String resultWho,
 322             int requestCode, int flags, in ProfilerInfo profilerInfo,
 323             in Bundle options, int userId);
 324     int stopUser(int userid, boolean force, in IStopUserCallback callback);
 325     void registerUserSwitchObserver(in IUserSwitchObserver observer, in String name);
 326     void unregisterUserSwitchObserver(in IUserSwitchObserver observer);
 327     int[] getRunningUserIds();
 328
 329     // Deprecated - This method is only used by a few internal components and it will soon be
 330     // replaced by a proper bug report API (which will be restricted to a few, pre-defined apps).
 331     // No new code should be calling it.
 332     void requestBugReport(int bugreportType);
 333
 334     /**
 335      *  Takes a telephony bug report and notifies the user with the title and description
 336      *  that are passed to this API as parameters
 337      *
 338      *  @param shareTitle should be a valid legible string less than 50 chars long
 339      *  @param shareDescription should be less than 91 bytes when encoded into UTF-8 format
 340      *
 341      *  @throws IllegalArgumentException if shareTitle or shareDescription is too big or if the
 342      *          paremeters cannot be encoding to an UTF-8 charset.
 343      */
 344     void requestTelephonyBugReport(in String shareTitle, in String shareDescription);
 345
 346     long inputDispatchingTimedOut(int pid, boolean aboveSystem, in String reason);
 347     void clearPendingBackup();
 348     Intent getIntentForIntentSender(in IIntentSender sender);
 349     Bundle getAssistContextExtras(int requestType);
 350     void reportAssistContextExtras(in IBinder token, in Bundle extras,
 351             in AssistStructure structure, in AssistContent content, in Uri referrer);
 352     // This is not public because you need to be very careful in how you
 353     // manage your activity to make sure it is always the uid you expect.
 354     String getLaunchedFromPackage(in IBinder activityToken);
 355     void killUid(int appId, int userId, in String reason);
 356     void setUserIsMonkey(boolean monkey);
 357     void hang(in IBinder who, boolean allowRestart);
 358     IActivityContainer createVirtualActivityContainer(in IBinder parentActivityToken,
 359             in IActivityContainerCallback callback);
 360     void moveTaskToStack(int taskId, int stackId, boolean toTop);
 361     /**
 362      * Resizes the input stack id to the given bounds.
 363      *
 364      * @param stackId Id of the stack to resize.
 365      * @param bounds Bounds to resize the stack to or {@code null} for fullscreen.
 366      * @param allowResizeInDockedMode True if the resize should be allowed when the docked stack is
 367      *                                active.
 368      * @param preserveWindows True if the windows of activities contained in the stack should be
 369      *                        preserved.
 370      * @param animate True if the stack resize should be animated.
 371      * @param animationDuration The duration of the resize animation in milliseconds or -1 if the
 372      *                          default animation duration should be used.
 373      * @throws RemoteException
 374      */
 375     void resizeStack(int stackId, in Rect bounds, boolean allowResizeInDockedMode,
 376             boolean preserveWindows, boolean animate, int animationDuration);
 377     List<ActivityManager.StackInfo> getAllStackInfos();
 378     void setFocusedStack(int stackId);
 379     ActivityManager.StackInfo getStackInfo(int stackId);
 380     boolean convertFromTranslucent(in IBinder token);
 381     boolean convertToTranslucent(in IBinder token, in Bundle options);
 382     void notifyActivityDrawn(in IBinder token);
 383     void reportActivityFullyDrawn(in IBinder token);
 384     void restart();
 385     void performIdleMaintenance();
 386     void takePersistableUriPermission(in Uri uri, int modeFlags, int userId);
 387     void releasePersistableUriPermission(in Uri uri, int modeFlags, int userId);
 388     ParceledListSlice getPersistedUriPermissions(in String packageName, boolean incoming);
 389     void appNotRespondingViaProvider(in IBinder connection);
 390     Rect getTaskBounds(int taskId);
 391     int getActivityDisplayId(in IBinder activityToken);
 392     boolean setProcessMemoryTrimLevel(in String process, int uid, int level);
 393
 394
 395     // Start of L transactions
 396     String getTagForIntentSender(in IIntentSender sender, in String prefix);
 397     boolean startUserInBackground(int userid);
 398     void startLockTaskModeById(int taskId);
 399     void startLockTaskModeByToken(in IBinder token);
 400     void stopLockTaskMode();
 401     boolean isInLockTaskMode();
 402     void setTaskDescription(in IBinder token, in ActivityManager.TaskDescription values);
 403     int startVoiceActivity(in String callingPackage, int callingPid, int callingUid,
 404             in Intent intent, in String resolvedType, in IVoiceInteractionSession session,
 405             in IVoiceInteractor interactor, int flags, in ProfilerInfo profilerInfo,
 406             in Bundle options, int userId);
 407     int startAssistantActivity(in String callingPackage, int callingPid, int callingUid,
 408             in Intent intent, in String resolvedType, in Bundle options, int userId);
 409     Bundle getActivityOptions(in IBinder token);
 410     List<IBinder> getAppTasks(in String callingPackage);
 411     void startSystemLockTaskMode(int taskId);
 412     void stopSystemLockTaskMode();
 413     void finishVoiceTask(in IVoiceInteractionSession session);
 414     boolean isTopOfTask(in IBinder token);
 415     boolean requestVisibleBehind(in IBinder token, boolean visible);
 416     boolean isBackgroundVisibleBehind(in IBinder token);
 417     void backgroundResourcesReleased(in IBinder token);
 418     void notifyLaunchTaskBehindComplete(in IBinder token);
 419     int startActivityFromRecents(int taskId, in Bundle options);
 420     void notifyEnterAnimationComplete(in IBinder token);
 421     int startActivityAsCaller(in IApplicationThread caller, in String callingPackage,
 422             in Intent intent, in String resolvedType, in IBinder resultTo, in String resultWho,
 423             int requestCode, int flags, in ProfilerInfo profilerInfo, in Bundle options,
 424             boolean ignoreTargetSecurity, int userId);
 425     int addAppTask(in IBinder activityToken, in Intent intent,
 426             in ActivityManager.TaskDescription description, in Bitmap thumbnail);
 427     Point getAppTaskThumbnailSize();
 428     boolean releaseActivityInstance(in IBinder token);
 429     void releaseSomeActivities(in IApplicationThread app);
 430     void bootAnimationComplete();
 431     Bitmap getTaskDescriptionIcon(in String filename, int userId);
 432     boolean launchAssistIntent(in Intent intent, int requestType, in String hint, int userHandle,
 433             in Bundle args);
 434     void startInPlaceAnimationOnFrontMostApplication(in Bundle opts);
 435     int checkPermissionWithToken(in String permission, int pid, int uid,
 436             in IBinder callerToken);
 437     void registerTaskStackListener(in ITaskStackListener listener);
 438
 439
 440     // Start of M transactions
 441     void notifyCleartextNetwork(int uid, in byte[] firstPacket);
 442     IActivityContainer createStackOnDisplay(int displayId);
 443     int getFocusedStackId();
 444     void setTaskResizeable(int taskId, int resizeableMode);
 445     boolean requestAssistContextExtras(int requestType, in IResultReceiver receiver,
 446             in Bundle receiverExtras, in IBinder activityToken,
 447             boolean focused, boolean newSessionId);
 448     void resizeTask(int taskId, in Rect bounds, int resizeMode);
 449     int getLockTaskModeState();
 450     void setDumpHeapDebugLimit(in String processName, int uid, long maxMemSize,
 451             in String reportPackage);
 452     void dumpHeapFinished(in String path);
 453     void setVoiceKeepAwake(in IVoiceInteractionSession session, boolean keepAwake);
 454     void updateLockTaskPackages(int userId, in String[] packages);
 455     void noteAlarmStart(in IIntentSender sender, int sourceUid, in String tag);
 456     void noteAlarmFinish(in IIntentSender sender, int sourceUid, in String tag);
 457     int getPackageProcessState(in String packageName, in String callingPackage);
 458     oneway void showLockTaskEscapeMessage(in IBinder token);
 459     void updateDeviceOwner(in String packageName);
 460     /**
 461      * Notify the system that the keyguard is going away.
 462      *
 463      * @param flags See {@link android.view.WindowManagerPolicy#KEYGUARD_GOING_AWAY_FLAG_TO_SHADE}
 464      *              etc.
 465      */
 466     void keyguardGoingAway(int flags);
 467     int getUidProcessState(int uid, in String callingPackage);
 468     void registerUidObserver(in IUidObserver observer, int which, int cutpoint,
 469             String callingPackage);
 470     void unregisterUidObserver(in IUidObserver observer);
 471     boolean isAssistDataAllowedOnCurrentActivity();
 472     boolean showAssistFromActivity(in IBinder token, in Bundle args);
 473     boolean isRootVoiceInteraction(in IBinder token);
 474
 475
 476     // Start of N transactions
 477     // Start Binder transaction tracking for all applications.
 478     boolean startBinderTracking();
 479     // Stop Binder transaction tracking for all applications and dump trace data to the given file
 480     // descriptor.
 481     boolean stopBinderTrackingAndDump(in ParcelFileDescriptor fd);
 482     /**
 483      * Try to place task to provided position. The final position might be different depending on
 484      * current user and stacks state. The task will be moved to target stack if it's currently in
 485      * different stack.
 486      */
 487     void positionTaskInStack(int taskId, int stackId, int position);
 488     int getActivityStackId(in IBinder token);
 489     void exitFreeformMode(in IBinder token);
 490     void reportSizeConfigurations(in IBinder token, in int[] horizontalSizeConfiguration,
 491             in int[] verticalSizeConfigurations, in int[] smallestWidthConfigurations);
 492     boolean moveTaskToDockedStack(int taskId, int createMode, boolean toTop, boolean animate,
 493             in Rect initialBounds);
 494     void suppressResizeConfigChanges(boolean suppress);
 495     void moveTasksToFullscreenStack(int fromStackId, boolean onTop);
 496     boolean moveTopActivityToPinnedStack(int stackId, in Rect bounds);
 497     boolean isAppStartModeDisabled(int uid, in String packageName);
 498     boolean unlockUser(int userid, in byte[] token, in byte[] secret,
 499             in IProgressListener listener);
 500     boolean isInMultiWindowMode(in IBinder token);
 501     boolean isInPictureInPictureMode(in IBinder token);
 502     void killPackageDependents(in String packageName, int userId);
 503     boolean enterPictureInPictureMode(in IBinder token, in PictureInPictureParams params);
 504     void setPictureInPictureParams(in IBinder token, in PictureInPictureParams params);
 505     int getMaxNumPictureInPictureActions(in IBinder token);
 506     void activityRelaunched(in IBinder token);
 507     IBinder getUriPermissionOwnerForActivity(in IBinder activityToken);
 508     /**
 509      * Resizes the docked stack, and all other stacks as the result of the dock stack bounds change.
 510      *
 511      * @param dockedBounds The bounds for the docked stack.
 512      * @param tempDockedTaskBounds The temporary bounds for the tasks in the docked stack, which
 513      *                             might be different from the stack bounds to allow more
 514      *                             flexibility while resizing, or {@code null} if they should be the
 515      *                             same as the stack bounds.
 516      * @param tempDockedTaskInsetBounds The temporary bounds for the tasks to calculate the insets.
 517      *                                  When resizing, we usually "freeze" the layout of a task. To
 518      *                                  achieve that, we also need to "freeze" the insets, which
 519      *                                  gets achieved by changing task bounds but not bounds used
 520      *                                  to calculate the insets in this transient state
 521      * @param tempOtherTaskBounds The temporary bounds for the tasks in all other stacks, or
 522      *                            {@code null} if they should be the same as the stack bounds.
 523      * @param tempOtherTaskInsetBounds Like {@code tempDockedTaskInsetBounds}, but for the other
 524      *                                 stacks.
 525      * @throws RemoteException
 526      */
 527     void resizeDockedStack(in Rect dockedBounds, in Rect tempDockedTaskBounds,
 528             in Rect tempDockedTaskInsetBounds,
 529             in Rect tempOtherTaskBounds, in Rect tempOtherTaskInsetBounds);
 530     int setVrMode(in IBinder token, boolean enabled, in ComponentName packageName);
 531     // Gets the URI permissions granted to an arbitrary package.
 532     // NOTE: this is different from getPersistedUriPermissions(), which returns the URIs the package
 533     // granted to another packages (instead of those granted to it).
 534     ParceledListSlice getGrantedUriPermissions(in String packageName, int userId);
 535     // Clears the URI permissions granted to an arbitrary package.
 536     void clearGrantedUriPermissions(in String packageName, int userId);
 537     boolean isAppForeground(int uid);
 538     void startLocalVoiceInteraction(in IBinder token, in Bundle options);
 539     void stopLocalVoiceInteraction(in IBinder token);
 540     boolean supportsLocalVoiceInteraction();
 541     void notifyPinnedStackAnimationStarted();
 542     void notifyPinnedStackAnimationEnded();
 543     void removeStack(int stackId);
 544     void makePackageIdle(String packageName, int userId);
 545     int getMemoryTrimLevel();
 546     /**
 547      * Resizes the pinned stack.
 548      *
 549      * @param pinnedBounds The bounds for the pinned stack.
 550      * @param tempPinnedTaskBounds The temporary bounds for the tasks in the pinned stack, which
 551      *                             might be different from the stack bounds to allow more
 552      *                             flexibility while resizing, or {@code null} if they should be the
 553      *                             same as the stack bounds.
 554      */
 555     void resizePinnedStack(in Rect pinnedBounds, in Rect tempPinnedTaskBounds);
 556     boolean isVrModePackageEnabled(in ComponentName packageName);
 557     /**
 558      * Moves all tasks from the docked stack in the fullscreen stack and puts the top task of the
 559      * fullscreen stack into the docked stack.
 560      */
 561     void swapDockedAndFullscreenStack();
 562     void notifyLockedProfile(int userId);
 563     void startConfirmDeviceCredentialIntent(in Intent intent, in Bundle options);
 564     void sendIdleJobTrigger();
 565     int sendIntentSender(in IIntentSender target, in IBinder whitelistToken, int code,
 566             in Intent intent, in String resolvedType, in IIntentReceiver finishedReceiver,
 567             in String requiredPermission, in Bundle options);
 568
 569
 570     // Start of N MR1 transactions
 571     void setVrThread(int tid);
 572     void setRenderThread(int tid);
 573     /**
 574      * Lets activity manager know whether the calling process is currently showing "top-level" UI
 575      * that is not an activity, i.e. windows on the screen the user is currently interacting with.
 576      *
 577      * <p>This flag can only be set for persistent processes.
 578      *
 579      * @param hasTopUi Whether the calling process has "top-level" UI.
 580      */
 581     void setHasTopUi(boolean hasTopUi);
 582
 583     // Start of O transactions
 584     void requestActivityRelaunch(in IBinder token);
 585     /**
 586      * Updates override configuration applied to specific display.
 587      * @param values Update values for display configuration. If null is passed it will request the
 588      *               Window Manager to compute new config for the specified display.
 589      * @param displayId Id of the display to apply the config to.
 590      * @throws RemoteException
 591      * @return Returns true if the configuration was updated.
 592      */
 593     boolean updateDisplayOverrideConfiguration(in Configuration values, int displayId);
 594     void unregisterTaskStackListener(ITaskStackListener listener);
 595     void moveStackToDisplay(int stackId, int displayId);
 596     boolean requestAutofillData(in IResultReceiver receiver, in Bundle receiverExtras,
 597                                 in IBinder activityToken, int flags);
 598     void dismissKeyguard(in IBinder token, in IKeyguardDismissCallback callback);
 599     int restartUserInBackground(int userId);
 600
 601     /** Cancels the window transitions for the given task. */
 602     void cancelTaskWindowTransition(int taskId);
 603
 604     /** Cancels the thumbnail transitions for the given task. */
 605     void cancelTaskThumbnailTransition(int taskId);
 606
 607     /**
 608      * @param taskId the id of the task to retrieve the sAutoapshots for
 609      * @param reducedResolution if set, if the snapshot needs to be loaded from disk, this will load
 610      *                          a reduced resolution of it, which is much faster
 611      * @return a graphic buffer representing a screenshot of a task
 612      */
 613     ActivityManager.TaskSnapshot getTaskSnapshot(int taskId, boolean reducedResolution);
 614
 615     void scheduleApplicationInfoChanged(in List<String> packageNames, int userId);
 616     void setPersistentVrThread(int tid);
 617
 618     void waitForNetworkStateUpdate(long procStateSeq);
 619
 620     /**
 621      * See {@link android.app.Activity#setDisablePreviewScreenshots}
 622      */
 623     void setDisablePreviewScreenshots(IBinder token, boolean disable);
 624
 625     /**
 626      * Return the user id of last resumed activity.
 627      */
 628     int getLastResumedActivityUserId();
 629
 630     /**
 631      * Add a bare uid to the background restrictions whitelist.  Only the system uid may call this.
 632      */
 633      void backgroundWhitelistUid(int uid);
 634
 635     // WARNING: when these transactions are updated, check if they are any callers on the native
 636     // side. If so, make sure they are using the correct transaction ids and arguments.
 637     // If a transaction which will also be used on the native side is being inserted, add it
 638     // alongside with other transactions of this kind at the top of this file.
 639 }