600 lines
21 KiB
Java
600 lines
21 KiB
Java
|
/*
|
||
|
|
* Copyright (C) 2018 The Android Open Source Project
|
||
|
|
*
|
||
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
||
|
|
* you may not use this file except in compliance with the License.
|
||
|
|
* You may obtain a copy of the License at
|
||
|
|
*
|
||
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||
|
|
*
|
||
|
|
* Unless required by applicable law or agreed to in writing, software
|
||
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
||
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
|
|
* See the License for the specific language governing permissions and
|
||
|
|
* limitations under the License.
|
||
|
|
*/
|
||
|
|
|
||
|
|
package android.app;
|
||
|
|
|
||
|
|
import static android.view.Display.INVALID_DISPLAY;
|
||
|
|
|
||
|
|
import android.annotation.NonNull;
|
||
|
|
import android.annotation.Nullable;
|
||
|
|
import android.annotation.RequiresPermission;
|
||
|
|
import android.annotation.SystemService;
|
||
|
|
import android.annotation.TestApi;
|
||
|
|
import android.compat.annotation.UnsupportedAppUsage;
|
||
|
|
import android.content.Context;
|
||
|
|
import android.content.pm.PackageManager;
|
||
|
|
import android.content.res.Configuration;
|
||
|
|
import android.content.res.Resources;
|
||
|
|
import android.graphics.Rect;
|
||
|
|
import android.os.Build;
|
||
|
|
import android.os.IBinder;
|
||
|
|
import android.os.Parcel;
|
||
|
|
import android.os.Parcelable;
|
||
|
|
import android.os.RemoteException;
|
||
|
|
import android.os.ServiceManager;
|
||
|
|
import android.util.DisplayMetrics;
|
||
|
|
import android.util.Singleton;
|
||
|
|
import android.view.RemoteAnimationDefinition;
|
||
|
|
import android.window.SplashScreenView.SplashScreenViewParcelable;
|
||
|
|
|
||
|
|
import java.util.List;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* This class gives information about, and interacts with activities and their containers like task,
|
||
|
|
* stacks, and displays.
|
||
|
|
*
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
@TestApi
|
||
|
|
@SystemService(Context.ACTIVITY_TASK_SERVICE)
|
||
|
|
public class ActivityTaskManager {
|
||
|
|
|
||
|
|
/** Invalid stack ID. */
|
||
|
|
public static final int INVALID_STACK_ID = -1;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Invalid task ID.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
public static final int INVALID_TASK_ID = -1;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Invalid windowing mode.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
public static final int INVALID_WINDOWING_MODE = -1;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Input parameter to {@link IActivityTaskManager#resizeTask} which indicates
|
||
|
|
* that the resize doesn't need to preserve the window, and can be skipped if bounds
|
||
|
|
* is unchanged. This mode is used by window manager in most cases.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
public static final int RESIZE_MODE_SYSTEM = 0;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Input parameter to {@link IActivityTaskManager#resizeTask} which indicates
|
||
|
|
* that the resize should preserve the window if possible.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
public static final int RESIZE_MODE_PRESERVE_WINDOW = (0x1 << 0);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Input parameter to {@link IActivityTaskManager#resizeTask} used when the
|
||
|
|
* resize is due to a drag action.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
public static final int RESIZE_MODE_USER = RESIZE_MODE_PRESERVE_WINDOW;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Input parameter to {@link IActivityTaskManager#resizeTask} which indicates
|
||
|
|
* that the resize should be performed even if the bounds appears unchanged.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
public static final int RESIZE_MODE_FORCED = (0x1 << 1);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Input parameter to {@link IActivityTaskManager#resizeTask} which indicates
|
||
|
|
* that the resize should preserve the window if possible, and should not be skipped
|
||
|
|
* even if the bounds is unchanged. Usually used to force a resizing when a drag action
|
||
|
|
* is ending.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
public static final int RESIZE_MODE_USER_FORCED =
|
||
|
|
RESIZE_MODE_PRESERVE_WINDOW | RESIZE_MODE_FORCED;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Extra included on intents that contain an EXTRA_INTENT, with options that the contained
|
||
|
|
* intent may want to be started with. Type is Bundle.
|
||
|
|
* TODO: remove once the ChooserActivity moves to systemui
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
public static final String EXTRA_OPTIONS = "android.app.extra.OPTIONS";
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Extra included on intents that contain an EXTRA_INTENT, use this boolean value for the
|
||
|
|
* parameter of the same name when starting the contained intent.
|
||
|
|
* TODO: remove once the ChooserActivity moves to systemui
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
public static final String EXTRA_IGNORE_TARGET_SECURITY =
|
||
|
|
"android.app.extra.EXTRA_IGNORE_TARGET_SECURITY";
|
||
|
|
|
||
|
|
/** The minimal size of a display's long-edge needed to support split-screen multi-window. */
|
||
|
|
public static final int DEFAULT_MINIMAL_SPLIT_SCREEN_DISPLAY_SIZE_DP = 440;
|
||
|
|
|
||
|
|
private static int sMaxRecentTasks = -1;
|
||
|
|
|
||
|
|
private static final Singleton<ActivityTaskManager> sInstance =
|
||
|
|
new Singleton<ActivityTaskManager>() {
|
||
|
|
@Override
|
||
|
|
protected ActivityTaskManager create() {
|
||
|
|
return new ActivityTaskManager();
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
private ActivityTaskManager() {
|
||
|
|
}
|
||
|
|
|
||
|
|
/** @hide */
|
||
|
|
public static ActivityTaskManager getInstance() {
|
||
|
|
return sInstance.get();
|
||
|
|
}
|
||
|
|
|
||
|
|
/** @hide */
|
||
|
|
public static IActivityTaskManager getService() {
|
||
|
|
return IActivityTaskManagerSingleton.get();
|
||
|
|
}
|
||
|
|
|
||
|
|
@UnsupportedAppUsage(trackingBug = 129726065)
|
||
|
|
private static final Singleton<IActivityTaskManager> IActivityTaskManagerSingleton =
|
||
|
|
new Singleton<IActivityTaskManager>() {
|
||
|
|
@Override
|
||
|
|
protected IActivityTaskManager create() {
|
||
|
|
final IBinder b = ServiceManager.getService(Context.ACTIVITY_TASK_SERVICE);
|
||
|
|
return IActivityTaskManager.Stub.asInterface(b);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Removes root tasks in the windowing modes from the system if they are of activity type
|
||
|
|
* ACTIVITY_TYPE_STANDARD or ACTIVITY_TYPE_UNDEFINED
|
||
|
|
*/
|
||
|
|
@RequiresPermission(android.Manifest.permission.MANAGE_ACTIVITY_TASKS)
|
||
|
|
public void removeRootTasksInWindowingModes(@NonNull int[] windowingModes) {
|
||
|
|
try {
|
||
|
|
getService().removeRootTasksInWindowingModes(windowingModes);
|
||
|
|
} catch (RemoteException e) {
|
||
|
|
throw e.rethrowFromSystemServer();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Removes root tasks of the activity types from the system. */
|
||
|
|
@RequiresPermission(android.Manifest.permission.MANAGE_ACTIVITY_TASKS)
|
||
|
|
public void removeRootTasksWithActivityTypes(@NonNull int[] activityTypes) {
|
||
|
|
try {
|
||
|
|
getService().removeRootTasksWithActivityTypes(activityTypes);
|
||
|
|
} catch (RemoteException e) {
|
||
|
|
throw e.rethrowFromSystemServer();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Removes all visible recent tasks from the system.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
@RequiresPermission(android.Manifest.permission.REMOVE_TASKS)
|
||
|
|
public void removeAllVisibleRecentTasks() {
|
||
|
|
try {
|
||
|
|
getService().removeAllVisibleRecentTasks();
|
||
|
|
} catch (RemoteException e) {
|
||
|
|
throw e.rethrowFromSystemServer();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Return the maximum number of recents entries that we will maintain and show.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
public static int getMaxRecentTasksStatic() {
|
||
|
|
if (sMaxRecentTasks < 0) {
|
||
|
|
return sMaxRecentTasks = ActivityManager.isLowRamDeviceStatic() ? 36 : 48;
|
||
|
|
}
|
||
|
|
return sMaxRecentTasks;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Notify the server that splash screen of the given task has been copied"
|
||
|
|
*
|
||
|
|
* @param taskId Id of task to handle the material to reconstruct the splash screen view.
|
||
|
|
* @param parcelable Used to reconstruct the view, null means the surface is un-copyable.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
public void onSplashScreenViewCopyFinished(int taskId,
|
||
|
|
@Nullable SplashScreenViewParcelable parcelable) {
|
||
|
|
try {
|
||
|
|
getService().onSplashScreenViewCopyFinished(taskId, parcelable);
|
||
|
|
} catch (RemoteException e) {
|
||
|
|
throw e.rethrowFromSystemServer();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Return the default limit on the number of recents that an app can make.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
public static int getDefaultAppRecentsLimitStatic() {
|
||
|
|
return getMaxRecentTasksStatic() / 6;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Return the maximum limit on the number of recents that an app can make.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
public static int getMaxAppRecentsLimitStatic() {
|
||
|
|
return getMaxRecentTasksStatic() / 2;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns true if the system supports at least one form of multi-window.
|
||
|
|
* E.g. freeform, split-screen, picture-in-picture.
|
||
|
|
*/
|
||
|
|
public static boolean supportsMultiWindow(Context context) {
|
||
|
|
// On watches, multi-window is used to present essential system UI, and thus it must be
|
||
|
|
// supported regardless of device memory characteristics.
|
||
|
|
boolean isWatch = context.getPackageManager().hasSystemFeature(
|
||
|
|
PackageManager.FEATURE_WATCH);
|
||
|
|
return (!ActivityManager.isLowRamDeviceStatic() || isWatch)
|
||
|
|
&& Resources.getSystem().getBoolean(
|
||
|
|
com.android.internal.R.bool.config_supportsMultiWindow);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns {@code true} if the display the context is associated with supports split screen
|
||
|
|
* multi-window.
|
||
|
|
*
|
||
|
|
* @throws UnsupportedOperationException if the supplied {@link Context} is not associated with
|
||
|
|
* a display.
|
||
|
|
*/
|
||
|
|
public static boolean supportsSplitScreenMultiWindow(Context context) {
|
||
|
|
DisplayMetrics dm = new DisplayMetrics();
|
||
|
|
context.getDisplay().getRealMetrics(dm);
|
||
|
|
|
||
|
|
int widthDp = (int) (dm.widthPixels / dm.density);
|
||
|
|
int heightDp = (int) (dm.heightPixels / dm.density);
|
||
|
|
if (Math.max(widthDp, heightDp) < DEFAULT_MINIMAL_SPLIT_SCREEN_DISPLAY_SIZE_DP) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
return supportsMultiWindow(context)
|
||
|
|
&& Resources.getSystem().getBoolean(
|
||
|
|
com.android.internal.R.bool.config_supportsSplitScreenMultiWindow);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Start to enter lock task mode for given task by system(UI).
|
||
|
|
* @param taskId Id of task to lock.
|
||
|
|
*/
|
||
|
|
@RequiresPermission(android.Manifest.permission.MANAGE_ACTIVITY_TASKS)
|
||
|
|
public void startSystemLockTaskMode(int taskId) {
|
||
|
|
try {
|
||
|
|
getService().startSystemLockTaskMode(taskId);
|
||
|
|
} catch (RemoteException e) {
|
||
|
|
throw e.rethrowFromSystemServer();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Stop lock task mode by system(UI).
|
||
|
|
*/
|
||
|
|
@RequiresPermission(android.Manifest.permission.MANAGE_ACTIVITY_TASKS)
|
||
|
|
public void stopSystemLockTaskMode() {
|
||
|
|
try {
|
||
|
|
getService().stopSystemLockTaskMode();
|
||
|
|
} catch (RemoteException e) {
|
||
|
|
throw e.rethrowFromSystemServer();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Move task to root task with given id.
|
||
|
|
* @param taskId Id of the task to move.
|
||
|
|
* @param rootTaskId Id of the rootTask for task moving.
|
||
|
|
* @param toTop Whether the given task should shown to top of stack.
|
||
|
|
*/
|
||
|
|
@RequiresPermission(android.Manifest.permission.MANAGE_ACTIVITY_TASKS)
|
||
|
|
public void moveTaskToRootTask(int taskId, int rootTaskId, boolean toTop) {
|
||
|
|
try {
|
||
|
|
getService().moveTaskToRootTask(taskId, rootTaskId, toTop);
|
||
|
|
} catch (RemoteException e) {
|
||
|
|
throw e.rethrowFromSystemServer();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Resize task to given bounds.
|
||
|
|
* @param taskId Id of task to resize.
|
||
|
|
* @param bounds Bounds to resize task.
|
||
|
|
*/
|
||
|
|
@RequiresPermission(android.Manifest.permission.MANAGE_ACTIVITY_TASKS)
|
||
|
|
public void resizeTask(int taskId, Rect bounds) {
|
||
|
|
try {
|
||
|
|
getService().resizeTask(taskId, bounds, RESIZE_MODE_SYSTEM);
|
||
|
|
} catch (RemoteException e) {
|
||
|
|
throw e.rethrowFromSystemServer();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Clears launch params for the given package.
|
||
|
|
* @param packageNames the names of the packages of which the launch params are to be cleared
|
||
|
|
*/
|
||
|
|
@RequiresPermission(android.Manifest.permission.MANAGE_ACTIVITY_TASKS)
|
||
|
|
public void clearLaunchParamsForPackages(List<String> packageNames) {
|
||
|
|
try {
|
||
|
|
getService().clearLaunchParamsForPackages(packageNames);
|
||
|
|
} catch (RemoteException e) {
|
||
|
|
e.rethrowFromSystemServer();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @return whether the UI mode of the given config supports error dialogs (ANR, crash, etc).
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
public static boolean currentUiModeSupportsErrorDialogs(@NonNull Configuration config) {
|
||
|
|
int modeType = config.uiMode & Configuration.UI_MODE_TYPE_MASK;
|
||
|
|
return (modeType != Configuration.UI_MODE_TYPE_CAR
|
||
|
|
&& !(modeType == Configuration.UI_MODE_TYPE_WATCH && Build.IS_USER)
|
||
|
|
&& modeType != Configuration.UI_MODE_TYPE_TELEVISION
|
||
|
|
&& modeType != Configuration.UI_MODE_TYPE_VR_HEADSET);
|
||
|
|
}
|
||
|
|
|
||
|
|
/** @return whether the current UI mode supports error dialogs (ANR, crash, etc). */
|
||
|
|
public static boolean currentUiModeSupportsErrorDialogs(@NonNull Context context) {
|
||
|
|
final Configuration config = context.getResources().getConfiguration();
|
||
|
|
return currentUiModeSupportsErrorDialogs(config);
|
||
|
|
}
|
||
|
|
|
||
|
|
/** @return max allowed number of actions in picture-in-picture mode. */
|
||
|
|
public static int getMaxNumPictureInPictureActions(@NonNull Context context) {
|
||
|
|
return context.getResources().getInteger(
|
||
|
|
com.android.internal.R.integer.config_pictureInPictureMaxNumberOfActions);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @return List of running tasks.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
public List<ActivityManager.RunningTaskInfo> getTasks(int maxNum) {
|
||
|
|
return getTasks(maxNum, false /* filterForVisibleRecents */, false /* keepIntentExtra */,
|
||
|
|
INVALID_DISPLAY);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @return List of running tasks that can be filtered by visibility in recents.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
public List<ActivityManager.RunningTaskInfo> getTasks(
|
||
|
|
int maxNum, boolean filterOnlyVisibleRecents) {
|
||
|
|
return getTasks(maxNum, filterOnlyVisibleRecents, false /* keepIntentExtra */,
|
||
|
|
INVALID_DISPLAY);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @return List of running tasks that can be filtered by visibility in recents and keep intent
|
||
|
|
* extra.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
public List<ActivityManager.RunningTaskInfo> getTasks(
|
||
|
|
int maxNum, boolean filterOnlyVisibleRecents, boolean keepIntentExtra) {
|
||
|
|
return getTasks(maxNum, filterOnlyVisibleRecents, keepIntentExtra, INVALID_DISPLAY);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @return List of running tasks that can be filtered by visibility and displayId in recents
|
||
|
|
* and keep intent extra.
|
||
|
|
* @param displayId the target display id, or {@link INVALID_DISPLAY} not to filter by displayId
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
public List<ActivityManager.RunningTaskInfo> getTasks(
|
||
|
|
int maxNum, boolean filterOnlyVisibleRecents, boolean keepIntentExtra, int displayId) {
|
||
|
|
try {
|
||
|
|
return getService().getTasks(maxNum, filterOnlyVisibleRecents, keepIntentExtra,
|
||
|
|
displayId);
|
||
|
|
} catch (RemoteException e) {
|
||
|
|
throw e.rethrowFromSystemServer();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @return List of recent tasks.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
public List<ActivityManager.RecentTaskInfo> getRecentTasks(
|
||
|
|
int maxNum, int flags, int userId) {
|
||
|
|
try {
|
||
|
|
return getService().getRecentTasks(maxNum, flags, userId).getList();
|
||
|
|
} catch (RemoteException e) {
|
||
|
|
throw e.rethrowFromSystemServer();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/** @hide */
|
||
|
|
public void registerTaskStackListener(TaskStackListener listener) {
|
||
|
|
try {
|
||
|
|
getService().registerTaskStackListener(listener);
|
||
|
|
} catch (RemoteException e) {
|
||
|
|
throw e.rethrowFromSystemServer();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/** @hide */
|
||
|
|
public void unregisterTaskStackListener(TaskStackListener listener) {
|
||
|
|
try {
|
||
|
|
getService().unregisterTaskStackListener(listener);
|
||
|
|
} catch (RemoteException e) {
|
||
|
|
throw e.rethrowFromSystemServer();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/** @hide */
|
||
|
|
public Rect getTaskBounds(int taskId) {
|
||
|
|
try {
|
||
|
|
return getService().getTaskBounds(taskId);
|
||
|
|
} catch (RemoteException e) {
|
||
|
|
throw e.rethrowFromSystemServer();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Registers remote animations for a display.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
public void registerRemoteAnimationsForDisplay(
|
||
|
|
int displayId, RemoteAnimationDefinition definition) {
|
||
|
|
try {
|
||
|
|
getService().registerRemoteAnimationsForDisplay(displayId, definition);
|
||
|
|
} catch (RemoteException e) {
|
||
|
|
throw e.rethrowFromSystemServer();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/** @hide */
|
||
|
|
public boolean isInLockTaskMode() {
|
||
|
|
try {
|
||
|
|
return getService().isInLockTaskMode();
|
||
|
|
} catch (RemoteException e) {
|
||
|
|
throw e.rethrowFromSystemServer();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Removes task by a given taskId */
|
||
|
|
@RequiresPermission(android.Manifest.permission.MANAGE_ACTIVITY_TASKS)
|
||
|
|
public boolean removeTask(int taskId) {
|
||
|
|
try {
|
||
|
|
return getService().removeTask(taskId);
|
||
|
|
} catch (RemoteException e) {
|
||
|
|
throw e.rethrowFromSystemServer();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Detaches the navigation bar from the app it was attached to during a transition.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
@RequiresPermission(android.Manifest.permission.CONTROL_REMOTE_APP_TRANSITION_ANIMATIONS)
|
||
|
|
public void detachNavigationBarFromApp(@NonNull IBinder transition) {
|
||
|
|
try {
|
||
|
|
getService().detachNavigationBarFromApp(transition);
|
||
|
|
} catch (RemoteException e) {
|
||
|
|
throw e.rethrowFromSystemServer();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Update the list of packages allowed in lock task mode. */
|
||
|
|
@RequiresPermission(android.Manifest.permission.UPDATE_LOCK_TASK_PACKAGES)
|
||
|
|
public void updateLockTaskPackages(@NonNull Context context, @NonNull String[] packages) {
|
||
|
|
try {
|
||
|
|
getService().updateLockTaskPackages(context.getUserId(), packages);
|
||
|
|
} catch (RemoteException e) {
|
||
|
|
throw e.rethrowFromSystemServer();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Information you can retrieve about a root task in the system.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
public static class RootTaskInfo extends TaskInfo implements Parcelable {
|
||
|
|
// TODO(b/148895075): Move some of the fields to TaskInfo.
|
||
|
|
public Rect bounds = new Rect();
|
||
|
|
public int[] childTaskIds;
|
||
|
|
public String[] childTaskNames;
|
||
|
|
public Rect[] childTaskBounds;
|
||
|
|
public int[] childTaskUserIds;
|
||
|
|
public boolean visible;
|
||
|
|
// Index of the stack in the display's stack list, can be used for comparison of stack order
|
||
|
|
public int position;
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public int describeContents() {
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public void writeToParcel(Parcel dest, int flags) {
|
||
|
|
dest.writeTypedObject(bounds, flags);
|
||
|
|
dest.writeIntArray(childTaskIds);
|
||
|
|
dest.writeStringArray(childTaskNames);
|
||
|
|
dest.writeTypedArray(childTaskBounds, flags);
|
||
|
|
dest.writeIntArray(childTaskUserIds);
|
||
|
|
dest.writeInt(visible ? 1 : 0);
|
||
|
|
dest.writeInt(position);
|
||
|
|
super.writeToParcel(dest, flags);
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
void readFromParcel(Parcel source) {
|
||
|
|
bounds = source.readTypedObject(Rect.CREATOR);
|
||
|
|
childTaskIds = source.createIntArray();
|
||
|
|
childTaskNames = source.createStringArray();
|
||
|
|
childTaskBounds = source.createTypedArray(Rect.CREATOR);
|
||
|
|
childTaskUserIds = source.createIntArray();
|
||
|
|
visible = source.readInt() > 0;
|
||
|
|
position = source.readInt();
|
||
|
|
super.readFromParcel(source);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static final @NonNull Creator<RootTaskInfo> CREATOR = new Creator<>() {
|
||
|
|
@Override
|
||
|
|
public RootTaskInfo createFromParcel(Parcel source) {
|
||
|
|
return new RootTaskInfo(source);
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public RootTaskInfo[] newArray(int size) {
|
||
|
|
return new RootTaskInfo[size];
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
public RootTaskInfo() {
|
||
|
|
}
|
||
|
|
|
||
|
|
private RootTaskInfo(Parcel source) {
|
||
|
|
readFromParcel(source);
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public String toString() {
|
||
|
|
StringBuilder sb = new StringBuilder(256);
|
||
|
|
sb.append("RootTask id="); sb.append(taskId);
|
||
|
|
sb.append(" bounds="); sb.append(bounds.toShortString());
|
||
|
|
sb.append(" displayId="); sb.append(displayId);
|
||
|
|
sb.append(" userId="); sb.append(userId);
|
||
|
|
sb.append("\n");
|
||
|
|
|
||
|
|
sb.append(" configuration="); sb.append(configuration);
|
||
|
|
sb.append("\n");
|
||
|
|
|
||
|
|
for (int i = 0; i < childTaskIds.length; ++i) {
|
||
|
|
sb.append(" taskId="); sb.append(childTaskIds[i]);
|
||
|
|
sb.append(": "); sb.append(childTaskNames[i]);
|
||
|
|
if (childTaskBounds != null) {
|
||
|
|
sb.append(" bounds="); sb.append(childTaskBounds[i].toShortString());
|
||
|
|
}
|
||
|
|
sb.append(" userId=").append(childTaskUserIds[i]);
|
||
|
|
sb.append(" visible=").append(visible);
|
||
|
|
if (topActivity != null) {
|
||
|
|
sb.append(" topActivity=").append(topActivity);
|
||
|
|
}
|
||
|
|
sb.append("\n");
|
||
|
|
}
|
||
|
|
return sb.toString();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|