Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Minor cleanup of Task" into sc-dev

Browse Source
This commit is contained in:
Riddle Hsu
2021-05-14 06:54:29 +00:00
committed by Android (Google) Code Review
parent 75e3baedbb f9f1e92cec
commit 24367cc06c
1 changed files with 3 additions and 125 deletions
Download Patch File Download Diff File Expand all files Collapse all files

128
services/core/java/com/android/server/wm/Task.java
View File

@@ -202,7 +202,6 @@ import android.provider.Settings;
import android.service.voice.IVoiceInteractionSession;
import android.util.ArraySet;
import android.util.DisplayMetrics;
import android.util.Log;
import android.util.Slog;
import android.util.TypedXmlPullParser;
import android.util.TypedXmlSerializer;
@@ -1076,25 +1075,6 @@ class Task extends WindowContainer<WindowContainer> {
deferResume, true /* schedulePictureInPictureModeChange */, reason);
}
/**
* Convenience method to reparent a task to the top or bottom position of the root task, with
* an option to skip scheduling the picture-in-picture mode change.
*/
boolean reparent(Task preferredRootTask, boolean toTop,
@ReparentMoveRootTaskMode int moveRootTaskMode, boolean animate, boolean deferResume,
boolean schedulePictureInPictureModeChange, String reason) {
return reparent(preferredRootTask, toTop ? MAX_VALUE : 0, moveRootTaskMode, animate,
deferResume, schedulePictureInPictureModeChange, reason);
}
/** Convenience method to reparent a task to a specific position of the root task. */
boolean reparent(Task preferredRootTask, int position,
@ReparentMoveRootTaskMode int moveRootTaskMode, boolean animate, boolean deferResume,
String reason) {
return reparent(preferredRootTask, position, moveRootTaskMode, animate, deferResume,
true /* schedulePictureInPictureModeChange */, reason);
}
/**
* Reparents the task into a preferred root task, creating it if necessary.
*
@@ -2954,20 +2934,6 @@ class Task extends WindowContainer<WindowContainer> {
return bounds;
}
/** Updates the task's bounds and override configuration to match what is expected for the
* input root task. */
void updateOverrideConfigurationForRootTask(Task inRootTask) {
final Task rootTask = getRootTask();
if (rootTask != null && rootTask == inRootTask) {
return;
}
if (!inRootTask.inFreeformWindowingMode()) {
setBounds(inRootTask.getRequestedOverrideBounds());
}
}
/** Returns the bounds that should be used to launch this task. */
Rect getLaunchBounds() {
final Task rootTask = getRootTask();
@@ -6018,16 +5984,6 @@ class Task extends WindowContainer<WindowContainer> {
return inPinnedWindowingMode();
}
// TODO(NOW!)
/**
* Returns {@code true} if this is the top-most split-screen-primary or
* split-screen-secondary root task, {@code false} otherwise.
*/
boolean isTopSplitScreenRootTask() {
return inSplitScreenWindowingMode()
&& this == getDisplayArea().getTopRootTaskInWindowingMode(getWindowingMode());
}
void checkTranslucentActivityWaiting(ActivityRecord top) {
if (mTranslucentActivityWaiting != top) {
mUndrawnActivitiesBelowTopTranslucent.clear();
@@ -6229,9 +6185,7 @@ class Task extends WindowContainer<WindowContainer> {
// If we are sleeping, and there is no resumed activity, and the top activity is paused,
// well that is the state we want.
if (shouldSleepOrShutDownActivities()
&& mLastPausedActivity == next
&& mRootWindowContainer.allPausedActivitiesComplete()) {
if (mLastPausedActivity == next && shouldSleepOrShutDownActivities()) {
// Make sure we have executed any pending transitions, since there
// should be nothing left to do at this point.
executeAppTransition(options);
@@ -6255,14 +6209,6 @@ class Task extends WindowContainer<WindowContainer> {
if (DEBUG_SWITCH) Slog.v(TAG_SWITCH, "Resuming " + next);
// If we are currently pausing an activity, then don't do anything until that is done.
if (!mRootWindowContainer.allPausedActivitiesComplete()) {
ProtoLog.v(WM_DEBUG_STATES,
"resumeTopActivityLocked: Skip resume: some activity pausing.");
return false;
}
mTaskSupervisor.setLaunchSource(next.info.applicationInfo.uid);
ActivityRecord lastResumed = null;
@@ -7275,21 +7221,6 @@ class Task extends WindowContainer<WindowContainer> {
task.setBounds(displayedBounds);
}
/**
* Until we can break this "set task bounds to same as root task bounds" behavior, this
* basically resizes both root task and task bounds to the same bounds.
*/
private void setTaskBounds(Rect bounds) {
final PooledConsumer c = PooledLambda.obtainConsumer(Task::setTaskBoundsInner,
PooledLambda.__(Task.class), bounds);
forAllLeafTasks(c, true /* traverseTopToBottom */);
c.recycle();
}
private static void setTaskBoundsInner(Task task, Rect bounds) {
task.setBounds(task.isResizeable() ? bounds : null);
}
boolean willActivityBeVisible(IBinder token) {
final ActivityRecord r = ActivityRecord.forTokenLocked(token);
if (r == null) {
@@ -7549,51 +7480,6 @@ class Task extends WindowContainer<WindowContainer> {
}
}
void positionChildAt(Task task, int position) {
if (task.getRootTask() != this) {
throw new IllegalArgumentException("AS.positionChildAt: task=" + task
+ " is not a child of root task=" + this + " current parent="
+ task.getRootTask());
}
task.updateOverrideConfigurationForRootTask(this);
final ActivityRecord topRunningActivity = task.topRunningActivityLocked();
final boolean wasResumed = topRunningActivity == task.mResumedActivity;
boolean toTop = position >= getChildCount();
boolean includingParents = toTop || getDisplayArea().getNextFocusableRootTask(this,
true /* ignoreCurrent */) == null;
if (WindowManagerDebugConfig.DEBUG_ROOT_TASK) {
Slog.i(TAG_WM, "positionChildAt: positioning task=" + task + " at " + position);
}
positionChildAt(position, task, includingParents);
getDisplayContent().layoutAndAssignWindowLayersIfNeeded();
// TODO: Investigate if this random code is really needed.
if (task.voiceSession != null) {
try {
task.voiceSession.taskStarted(task.intent, task.mTaskId);
} catch (RemoteException e) {
}
}
if (wasResumed) {
if (mResumedActivity != null) {
Log.wtf(TAG, "mResumedActivity was already set when moving mResumedActivity from"
+ " other root task to this task mResumedActivity=" + mResumedActivity
+ " other mResumedActivity=" + topRunningActivity);
}
topRunningActivity.setState(RESUMED, "positionChildAt");
}
// The task might have already been running and its visibility needs to be synchronized with
// the visibility of the root task / windows.
ensureActivitiesVisible(null, 0, !PRESERVE_WINDOWS);
mRootWindowContainer.resumeFocusedTasksTopActivities();
}
public void setAlwaysOnTop(boolean alwaysOnTop) {
// {@link #isAwaysonTop} overrides the original behavior which also evaluates if this
// task is force hidden, so super.isAlwaysOnTop() is used here to see whether the
@@ -7864,8 +7750,8 @@ class Task extends WindowContainer<WindowContainer> {
// Do not sleep activities in this root task if we're marked as focused and the keyguard
// is in the process of going away.
if (isFocusedRootTaskOnDisplay()
&& mTaskSupervisor.getKeyguardController().isKeyguardGoingAway()
if (mTaskSupervisor.getKeyguardController().isKeyguardGoingAway()
&& isFocusedRootTaskOnDisplay()
// Avoid resuming activities on secondary displays since we don't want bubble
// activities to be resumed while bubble is still collapsed.
// TODO(b/113840485): Having keyguard going away state for secondary displays.
@@ -7880,14 +7766,6 @@ class Task extends WindowContainer<WindowContainer> {
return shouldSleepActivities() || mAtmService.mShuttingDown;
}
/** Bounds of the root task without adjusting for other factors in the system like visibility
* of root docked task.
* Most callers should be using {@link ConfigurationContainer#getRequestedOverrideBounds} a
* it takes into consideration other system factors. */
void getRawBounds(Rect out) {
out.set(getRawBounds());
}
private Rect getRawBounds() {
return super.getBounds();
}