Merge "Copy current split codes to stagesplit package" into sc-v2-dev
This commit is contained in:
Tony Huang
@@ -0,0 +1,103 @@
|
|||||||
|
/*
|
||||||
|
* Copyright (C) 2021 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 com.android.wm.shell.stagesplit;
|
||||||
|
|
||||||
|
import android.app.PendingIntent;
|
||||||
|
import android.content.Intent;
|
||||||
|
import android.os.Bundle;
|
||||||
|
import android.os.UserHandle;
|
||||||
|
import android.view.RemoteAnimationAdapter;
|
||||||
|
import android.view.RemoteAnimationTarget;
|
||||||
|
import android.window.RemoteTransition;
|
||||||
|
|
||||||
|
import com.android.wm.shell.stagesplit.ISplitScreenListener;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Interface that is exposed to remote callers to manipulate the splitscreen feature.
|
||||||
|
*/
|
||||||
|
interface ISplitScreen {
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Registers a split screen listener.
|
||||||
|
*/
|
||||||
|
oneway void registerSplitScreenListener(in ISplitScreenListener listener) = 1;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Unregisters a split screen listener.
|
||||||
|
*/
|
||||||
|
oneway void unregisterSplitScreenListener(in ISplitScreenListener listener) = 2;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Hides the side-stage if it is currently visible.
|
||||||
|
*/
|
||||||
|
oneway void setSideStageVisibility(boolean visible) = 3;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Removes a task from the side stage.
|
||||||
|
*/
|
||||||
|
oneway void removeFromSideStage(int taskId) = 4;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Removes the split-screen stages and leaving indicated task to top. Passing INVALID_TASK_ID
|
||||||
|
* to indicate leaving no top task after leaving split-screen.
|
||||||
|
*/
|
||||||
|
oneway void exitSplitScreen(int toTopTaskId) = 5;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @param exitSplitScreenOnHide if to exit split-screen if both stages are not visible.
|
||||||
|
*/
|
||||||
|
oneway void exitSplitScreenOnHide(boolean exitSplitScreenOnHide) = 6;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Starts a task in a stage.
|
||||||
|
*/
|
||||||
|
oneway void startTask(int taskId, int stage, int position, in Bundle options) = 7;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Starts a shortcut in a stage.
|
||||||
|
*/
|
||||||
|
oneway void startShortcut(String packageName, String shortcutId, int stage, int position,
|
||||||
|
in Bundle options, in UserHandle user) = 8;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Starts an activity in a stage.
|
||||||
|
*/
|
||||||
|
oneway void startIntent(in PendingIntent intent, in Intent fillInIntent, int stage,
|
||||||
|
int position, in Bundle options) = 9;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Starts tasks simultaneously in one transition.
|
||||||
|
*/
|
||||||
|
oneway void startTasks(int mainTaskId, in Bundle mainOptions, int sideTaskId,
|
||||||
|
in Bundle sideOptions, int sidePosition, in RemoteTransition remoteTransition) = 10;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Version of startTasks using legacy transition system.
|
||||||
|
*/
|
||||||
|
oneway void startTasksWithLegacyTransition(int mainTaskId, in Bundle mainOptions,
|
||||||
|
int sideTaskId, in Bundle sideOptions, int sidePosition,
|
||||||
|
in RemoteAnimationAdapter adapter) = 11;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Blocking call that notifies and gets additional split-screen targets when entering
|
||||||
|
* recents (for example: the dividerBar).
|
||||||
|
* @param cancel is true if leaving recents back to split (eg. the gesture was cancelled).
|
||||||
|
* @param appTargets apps that will be re-parented to display area
|
||||||
|
*/
|
||||||
|
RemoteAnimationTarget[] onGoingToRecentsLegacy(boolean cancel,
|
||||||
|
in RemoteAnimationTarget[] appTargets) = 12;
|
||||||
|
}
|
||||||
@@ -0,0 +1,33 @@
|
|||||||
|
/*
|
||||||
|
* Copyright (C) 2021 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 com.android.wm.shell.stagesplit;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Listener interface that Launcher attaches to SystemUI to get split-screen callbacks.
|
||||||
|
*/
|
||||||
|
oneway interface ISplitScreenListener {
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Called when the stage position changes.
|
||||||
|
*/
|
||||||
|
void onStagePositionChanged(int stage, int position);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Called when a task changes stages.
|
||||||
|
*/
|
||||||
|
void onTaskStageChanged(int taskId, int stage, boolean visible);
|
||||||
|
}
|
||||||
@@ -0,0 +1,104 @@
|
|||||||
|
/*
|
||||||
|
* Copyright (C) 2020 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 com.android.wm.shell.stagesplit;
|
||||||
|
|
||||||
|
import static android.app.WindowConfiguration.WINDOWING_MODE_MULTI_WINDOW;
|
||||||
|
|
||||||
|
import android.annotation.Nullable;
|
||||||
|
import android.graphics.Rect;
|
||||||
|
import android.view.SurfaceSession;
|
||||||
|
import android.window.WindowContainerToken;
|
||||||
|
import android.window.WindowContainerTransaction;
|
||||||
|
|
||||||
|
import com.android.wm.shell.ShellTaskOrganizer;
|
||||||
|
import com.android.wm.shell.common.SyncTransactionQueue;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Main stage for split-screen mode. When split-screen is active all standard activity types launch
|
||||||
|
* on the main stage, except for task that are explicitly pinned to the {@link SideStage}.
|
||||||
|
* @see StageCoordinator
|
||||||
|
*/
|
||||||
|
class MainStage extends StageTaskListener {
|
||||||
|
private static final String TAG = MainStage.class.getSimpleName();
|
||||||
|
|
||||||
|
private boolean mIsActive = false;
|
||||||
|
|
||||||
|
MainStage(ShellTaskOrganizer taskOrganizer, int displayId,
|
||||||
|
StageListenerCallbacks callbacks, SyncTransactionQueue syncQueue,
|
||||||
|
SurfaceSession surfaceSession,
|
||||||
|
@Nullable StageTaskUnfoldController stageTaskUnfoldController) {
|
||||||
|
super(taskOrganizer, displayId, callbacks, syncQueue, surfaceSession,
|
||||||
|
stageTaskUnfoldController);
|
||||||
|
}
|
||||||
|
|
||||||
|
boolean isActive() {
|
||||||
|
return mIsActive;
|
||||||
|
}
|
||||||
|
|
||||||
|
void activate(Rect rootBounds, WindowContainerTransaction wct) {
|
||||||
|
if (mIsActive) return;
|
||||||
|
|
||||||
|
final WindowContainerToken rootToken = mRootTaskInfo.token;
|
||||||
|
wct.setBounds(rootToken, rootBounds)
|
||||||
|
.setWindowingMode(rootToken, WINDOWING_MODE_MULTI_WINDOW)
|
||||||
|
.setLaunchRoot(
|
||||||
|
rootToken,
|
||||||
|
CONTROLLED_WINDOWING_MODES,
|
||||||
|
CONTROLLED_ACTIVITY_TYPES)
|
||||||
|
.reparentTasks(
|
||||||
|
null /* currentParent */,
|
||||||
|
rootToken,
|
||||||
|
CONTROLLED_WINDOWING_MODES,
|
||||||
|
CONTROLLED_ACTIVITY_TYPES,
|
||||||
|
true /* onTop */)
|
||||||
|
// Moving the root task to top after the child tasks were re-parented , or the root
|
||||||
|
// task cannot be visible and focused.
|
||||||
|
.reorder(rootToken, true /* onTop */);
|
||||||
|
|
||||||
|
mIsActive = true;
|
||||||
|
}
|
||||||
|
|
||||||
|
void deactivate(WindowContainerTransaction wct) {
|
||||||
|
deactivate(wct, false /* toTop */);
|
||||||
|
}
|
||||||
|
|
||||||
|
void deactivate(WindowContainerTransaction wct, boolean toTop) {
|
||||||
|
if (!mIsActive) return;
|
||||||
|
mIsActive = false;
|
||||||
|
|
||||||
|
if (mRootTaskInfo == null) return;
|
||||||
|
final WindowContainerToken rootToken = mRootTaskInfo.token;
|
||||||
|
wct.setLaunchRoot(
|
||||||
|
rootToken,
|
||||||
|
null,
|
||||||
|
null)
|
||||||
|
.reparentTasks(
|
||||||
|
rootToken,
|
||||||
|
null /* newParent */,
|
||||||
|
CONTROLLED_WINDOWING_MODES_WHEN_ACTIVE,
|
||||||
|
CONTROLLED_ACTIVITY_TYPES,
|
||||||
|
toTop)
|
||||||
|
// We want this re-order to the bottom regardless since we are re-parenting
|
||||||
|
// all its tasks.
|
||||||
|
.reorder(rootToken, false /* onTop */);
|
||||||
|
}
|
||||||
|
|
||||||
|
void updateConfiguration(int windowingMode, Rect bounds, WindowContainerTransaction wct) {
|
||||||
|
wct.setBounds(mRootTaskInfo.token, bounds)
|
||||||
|
.setWindowingMode(mRootTaskInfo.token, windowingMode);
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,181 @@
|
|||||||
|
/*
|
||||||
|
* Copyright (C) 2021 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 com.android.wm.shell.stagesplit;
|
||||||
|
|
||||||
|
import static android.view.WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE;
|
||||||
|
import static android.view.WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE;
|
||||||
|
import static android.view.WindowManager.LayoutParams.PRIVATE_FLAG_NO_MOVE_ANIMATION;
|
||||||
|
import static android.view.WindowManager.LayoutParams.PRIVATE_FLAG_TRUSTED_OVERLAY;
|
||||||
|
import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY;
|
||||||
|
|
||||||
|
import android.annotation.Nullable;
|
||||||
|
import android.content.Context;
|
||||||
|
import android.content.res.Configuration;
|
||||||
|
import android.graphics.PixelFormat;
|
||||||
|
import android.graphics.Rect;
|
||||||
|
import android.os.Binder;
|
||||||
|
import android.view.IWindow;
|
||||||
|
import android.view.InsetsSource;
|
||||||
|
import android.view.InsetsState;
|
||||||
|
import android.view.LayoutInflater;
|
||||||
|
import android.view.SurfaceControl;
|
||||||
|
import android.view.SurfaceControlViewHost;
|
||||||
|
import android.view.View;
|
||||||
|
import android.view.ViewGroup;
|
||||||
|
import android.view.WindowManager;
|
||||||
|
import android.view.WindowlessWindowManager;
|
||||||
|
import android.widget.FrameLayout;
|
||||||
|
|
||||||
|
import com.android.wm.shell.R;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Handles drawing outline of the bounds of provided root surface. The outline will be drown with
|
||||||
|
* the consideration of display insets like status bar, navigation bar and display cutout.
|
||||||
|
*/
|
||||||
|
class OutlineManager extends WindowlessWindowManager {
|
||||||
|
private static final String WINDOW_NAME = "SplitOutlineLayer";
|
||||||
|
private final Context mContext;
|
||||||
|
private final Rect mRootBounds = new Rect();
|
||||||
|
private final Rect mTempRect = new Rect();
|
||||||
|
private final Rect mLastOutlineBounds = new Rect();
|
||||||
|
private final InsetsState mInsetsState = new InsetsState();
|
||||||
|
private final int mExpandedTaskBarHeight;
|
||||||
|
private OutlineView mOutlineView;
|
||||||
|
private SurfaceControlViewHost mViewHost;
|
||||||
|
private SurfaceControl mHostLeash;
|
||||||
|
private SurfaceControl mLeash;
|
||||||
|
|
||||||
|
OutlineManager(Context context, Configuration configuration) {
|
||||||
|
super(configuration, null /* rootSurface */, null /* hostInputToken */);
|
||||||
|
mContext = context.createWindowContext(context.getDisplay(), TYPE_APPLICATION_OVERLAY,
|
||||||
|
null /* options */);
|
||||||
|
mExpandedTaskBarHeight = mContext.getResources().getDimensionPixelSize(
|
||||||
|
com.android.internal.R.dimen.taskbar_frame_height);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
protected void attachToParentSurface(IWindow window, SurfaceControl.Builder b) {
|
||||||
|
b.setParent(mHostLeash);
|
||||||
|
}
|
||||||
|
|
||||||
|
void inflate(SurfaceControl rootLeash, Rect rootBounds) {
|
||||||
|
if (mLeash != null || mViewHost != null) return;
|
||||||
|
|
||||||
|
mHostLeash = rootLeash;
|
||||||
|
mRootBounds.set(rootBounds);
|
||||||
|
mViewHost = new SurfaceControlViewHost(mContext, mContext.getDisplay(), this);
|
||||||
|
|
||||||
|
final FrameLayout rootLayout = (FrameLayout) LayoutInflater.from(mContext)
|
||||||
|
.inflate(R.layout.split_outline, null);
|
||||||
|
mOutlineView = rootLayout.findViewById(R.id.split_outline);
|
||||||
|
|
||||||
|
final WindowManager.LayoutParams lp = new WindowManager.LayoutParams(
|
||||||
|
0 /* width */, 0 /* height */, TYPE_APPLICATION_OVERLAY,
|
||||||
|
FLAG_NOT_FOCUSABLE | FLAG_NOT_TOUCHABLE, PixelFormat.TRANSLUCENT);
|
||||||
|
lp.width = mRootBounds.width();
|
||||||
|
lp.height = mRootBounds.height();
|
||||||
|
lp.token = new Binder();
|
||||||
|
lp.setTitle(WINDOW_NAME);
|
||||||
|
lp.privateFlags |= PRIVATE_FLAG_NO_MOVE_ANIMATION | PRIVATE_FLAG_TRUSTED_OVERLAY;
|
||||||
|
// TODO(b/189839391): Set INPUT_FEATURE_NO_INPUT_CHANNEL after WM supports
|
||||||
|
// TRUSTED_OVERLAY for windowless window without input channel.
|
||||||
|
mViewHost.setView(rootLayout, lp);
|
||||||
|
mLeash = getSurfaceControl(mViewHost.getWindowToken());
|
||||||
|
|
||||||
|
drawOutline();
|
||||||
|
}
|
||||||
|
|
||||||
|
void release() {
|
||||||
|
if (mViewHost != null) {
|
||||||
|
mViewHost.release();
|
||||||
|
mViewHost = null;
|
||||||
|
}
|
||||||
|
mRootBounds.setEmpty();
|
||||||
|
mLastOutlineBounds.setEmpty();
|
||||||
|
mOutlineView = null;
|
||||||
|
mHostLeash = null;
|
||||||
|
mLeash = null;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Nullable
|
||||||
|
SurfaceControl getOutlineLeash() {
|
||||||
|
return mLeash;
|
||||||
|
}
|
||||||
|
|
||||||
|
void setVisibility(boolean visible) {
|
||||||
|
if (mOutlineView != null) {
|
||||||
|
mOutlineView.setVisibility(visible ? View.VISIBLE : View.INVISIBLE);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void setRootBounds(Rect rootBounds) {
|
||||||
|
if (mViewHost == null || mViewHost.getView() == null) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!mRootBounds.equals(rootBounds)) {
|
||||||
|
WindowManager.LayoutParams lp =
|
||||||
|
(WindowManager.LayoutParams) mViewHost.getView().getLayoutParams();
|
||||||
|
lp.width = rootBounds.width();
|
||||||
|
lp.height = rootBounds.height();
|
||||||
|
mViewHost.relayout(lp);
|
||||||
|
mRootBounds.set(rootBounds);
|
||||||
|
drawOutline();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void onInsetsChanged(InsetsState insetsState) {
|
||||||
|
if (!mInsetsState.equals(insetsState)) {
|
||||||
|
mInsetsState.set(insetsState);
|
||||||
|
drawOutline();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private void computeOutlineBounds(Rect rootBounds, InsetsState insetsState, Rect outBounds) {
|
||||||
|
outBounds.set(rootBounds);
|
||||||
|
final InsetsSource taskBarInsetsSource =
|
||||||
|
insetsState.getSource(InsetsState.ITYPE_EXTRA_NAVIGATION_BAR);
|
||||||
|
// Only insets the divider bar with task bar when it's expanded so that the rounded corners
|
||||||
|
// will be drawn against task bar.
|
||||||
|
if (taskBarInsetsSource.getFrame().height() >= mExpandedTaskBarHeight) {
|
||||||
|
outBounds.inset(taskBarInsetsSource.calculateVisibleInsets(outBounds));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Offset the coordinate from screen based to surface based.
|
||||||
|
outBounds.offset(-rootBounds.left, -rootBounds.top);
|
||||||
|
}
|
||||||
|
|
||||||
|
void drawOutline() {
|
||||||
|
if (mOutlineView == null) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
computeOutlineBounds(mRootBounds, mInsetsState, mTempRect);
|
||||||
|
if (mTempRect.equals(mLastOutlineBounds)) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
ViewGroup.MarginLayoutParams lp =
|
||||||
|
(ViewGroup.MarginLayoutParams) mOutlineView.getLayoutParams();
|
||||||
|
lp.leftMargin = mTempRect.left;
|
||||||
|
lp.topMargin = mTempRect.top;
|
||||||
|
lp.width = mTempRect.width();
|
||||||
|
lp.height = mTempRect.height();
|
||||||
|
mOutlineView.setLayoutParams(lp);
|
||||||
|
mLastOutlineBounds.set(mTempRect);
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,82 @@
|
|||||||
|
/*
|
||||||
|
* Copyright (C) 2021 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 com.android.wm.shell.stagesplit;
|
||||||
|
|
||||||
|
import static android.view.RoundedCorner.POSITION_BOTTOM_LEFT;
|
||||||
|
import static android.view.RoundedCorner.POSITION_BOTTOM_RIGHT;
|
||||||
|
import static android.view.RoundedCorner.POSITION_TOP_LEFT;
|
||||||
|
import static android.view.RoundedCorner.POSITION_TOP_RIGHT;
|
||||||
|
|
||||||
|
import android.content.Context;
|
||||||
|
import android.graphics.Canvas;
|
||||||
|
import android.graphics.Paint;
|
||||||
|
import android.graphics.Path;
|
||||||
|
import android.util.AttributeSet;
|
||||||
|
import android.view.RoundedCorner;
|
||||||
|
import android.view.View;
|
||||||
|
|
||||||
|
import androidx.annotation.NonNull;
|
||||||
|
import androidx.annotation.Nullable;
|
||||||
|
|
||||||
|
import com.android.internal.R;
|
||||||
|
|
||||||
|
/** View for drawing split outline. */
|
||||||
|
public class OutlineView extends View {
|
||||||
|
private final Paint mPaint = new Paint();
|
||||||
|
private final Path mPath = new Path();
|
||||||
|
private final float[] mRadii = new float[8];
|
||||||
|
|
||||||
|
public OutlineView(@NonNull Context context, @Nullable AttributeSet attrs) {
|
||||||
|
super(context, attrs);
|
||||||
|
mPaint.setStyle(Paint.Style.STROKE);
|
||||||
|
mPaint.setStrokeWidth(
|
||||||
|
getResources().getDimension(R.dimen.accessibility_focus_highlight_stroke_width));
|
||||||
|
mPaint.setColor(getResources().getColor(R.color.system_accent1_100, null));
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
protected void onAttachedToWindow() {
|
||||||
|
// TODO(b/200850654): match the screen corners with the actual display decor.
|
||||||
|
mRadii[0] = mRadii[1] = getCornerRadius(POSITION_TOP_LEFT);
|
||||||
|
mRadii[2] = mRadii[3] = getCornerRadius(POSITION_TOP_RIGHT);
|
||||||
|
mRadii[4] = mRadii[5] = getCornerRadius(POSITION_BOTTOM_RIGHT);
|
||||||
|
mRadii[6] = mRadii[7] = getCornerRadius(POSITION_BOTTOM_LEFT);
|
||||||
|
}
|
||||||
|
|
||||||
|
private int getCornerRadius(@RoundedCorner.Position int position) {
|
||||||
|
final RoundedCorner roundedCorner = getDisplay().getRoundedCorner(position);
|
||||||
|
return roundedCorner == null ? 0 : roundedCorner.getRadius();
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
|
||||||
|
if (changed) {
|
||||||
|
mPath.reset();
|
||||||
|
mPath.addRoundRect(0, 0, getWidth(), getHeight(), mRadii, Path.Direction.CW);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
protected void onDraw(Canvas canvas) {
|
||||||
|
canvas.drawPath(mPath, mPaint);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public boolean hasOverlappingRendering() {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,144 @@
|
|||||||
|
/*
|
||||||
|
* Copyright (C) 2020 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 com.android.wm.shell.stagesplit;
|
||||||
|
|
||||||
|
import android.annotation.CallSuper;
|
||||||
|
import android.annotation.Nullable;
|
||||||
|
import android.app.ActivityManager;
|
||||||
|
import android.content.Context;
|
||||||
|
import android.graphics.Rect;
|
||||||
|
import android.view.InsetsSourceControl;
|
||||||
|
import android.view.InsetsState;
|
||||||
|
import android.view.SurfaceControl;
|
||||||
|
import android.view.SurfaceSession;
|
||||||
|
import android.window.WindowContainerToken;
|
||||||
|
import android.window.WindowContainerTransaction;
|
||||||
|
|
||||||
|
import com.android.wm.shell.ShellTaskOrganizer;
|
||||||
|
import com.android.wm.shell.common.DisplayInsetsController;
|
||||||
|
import com.android.wm.shell.common.SyncTransactionQueue;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Side stage for split-screen mode. Only tasks that are explicitly pinned to this stage show up
|
||||||
|
* here. All other task are launch in the {@link MainStage}.
|
||||||
|
*
|
||||||
|
* @see StageCoordinator
|
||||||
|
*/
|
||||||
|
class SideStage extends StageTaskListener implements
|
||||||
|
DisplayInsetsController.OnInsetsChangedListener {
|
||||||
|
private static final String TAG = SideStage.class.getSimpleName();
|
||||||
|
private final Context mContext;
|
||||||
|
private OutlineManager mOutlineManager;
|
||||||
|
|
||||||
|
SideStage(Context context, ShellTaskOrganizer taskOrganizer, int displayId,
|
||||||
|
StageListenerCallbacks callbacks, SyncTransactionQueue syncQueue,
|
||||||
|
SurfaceSession surfaceSession,
|
||||||
|
@Nullable StageTaskUnfoldController stageTaskUnfoldController) {
|
||||||
|
super(taskOrganizer, displayId, callbacks, syncQueue, surfaceSession,
|
||||||
|
stageTaskUnfoldController);
|
||||||
|
mContext = context;
|
||||||
|
}
|
||||||
|
|
||||||
|
void addTask(ActivityManager.RunningTaskInfo task, Rect rootBounds,
|
||||||
|
WindowContainerTransaction wct) {
|
||||||
|
final WindowContainerToken rootToken = mRootTaskInfo.token;
|
||||||
|
wct.setBounds(rootToken, rootBounds)
|
||||||
|
.reparent(task.token, rootToken, true /* onTop*/)
|
||||||
|
// Moving the root task to top after the child tasks were reparented , or the root
|
||||||
|
// task cannot be visible and focused.
|
||||||
|
.reorder(rootToken, true /* onTop */);
|
||||||
|
}
|
||||||
|
|
||||||
|
boolean removeAllTasks(WindowContainerTransaction wct, boolean toTop) {
|
||||||
|
// No matter if the root task is empty or not, moving the root to bottom because it no
|
||||||
|
// longer preserves visible child task.
|
||||||
|
wct.reorder(mRootTaskInfo.token, false /* onTop */);
|
||||||
|
if (mChildrenTaskInfo.size() == 0) return false;
|
||||||
|
wct.reparentTasks(
|
||||||
|
mRootTaskInfo.token,
|
||||||
|
null /* newParent */,
|
||||||
|
CONTROLLED_WINDOWING_MODES_WHEN_ACTIVE,
|
||||||
|
CONTROLLED_ACTIVITY_TYPES,
|
||||||
|
toTop);
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
boolean removeTask(int taskId, WindowContainerToken newParent, WindowContainerTransaction wct) {
|
||||||
|
final ActivityManager.RunningTaskInfo task = mChildrenTaskInfo.get(taskId);
|
||||||
|
if (task == null) return false;
|
||||||
|
wct.reparent(task.token, newParent, false /* onTop */);
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Nullable
|
||||||
|
public SurfaceControl getOutlineLeash() {
|
||||||
|
return mOutlineManager.getOutlineLeash();
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
@CallSuper
|
||||||
|
public void onTaskAppeared(ActivityManager.RunningTaskInfo taskInfo, SurfaceControl leash) {
|
||||||
|
super.onTaskAppeared(taskInfo, leash);
|
||||||
|
if (isRootTask(taskInfo)) {
|
||||||
|
mOutlineManager = new OutlineManager(mContext, taskInfo.configuration);
|
||||||
|
enableOutline(true);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
@CallSuper
|
||||||
|
public void onTaskInfoChanged(ActivityManager.RunningTaskInfo taskInfo) {
|
||||||
|
super.onTaskInfoChanged(taskInfo);
|
||||||
|
if (isRootTask(taskInfo)) {
|
||||||
|
mOutlineManager.setRootBounds(taskInfo.configuration.windowConfiguration.getBounds());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private boolean isRootTask(ActivityManager.RunningTaskInfo taskInfo) {
|
||||||
|
return mRootTaskInfo != null && mRootTaskInfo.taskId == taskInfo.taskId;
|
||||||
|
}
|
||||||
|
|
||||||
|
void enableOutline(boolean enable) {
|
||||||
|
if (mOutlineManager == null) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (enable) {
|
||||||
|
if (mRootTaskInfo != null) {
|
||||||
|
mOutlineManager.inflate(mRootLeash,
|
||||||
|
mRootTaskInfo.configuration.windowConfiguration.getBounds());
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
mOutlineManager.release();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void setOutlineVisibility(boolean visible) {
|
||||||
|
mOutlineManager.setVisibility(visible);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void insetsChanged(InsetsState insetsState) {
|
||||||
|
mOutlineManager.onInsetsChanged(insetsState);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void insetsControlChanged(InsetsState insetsState,
|
||||||
|
InsetsSourceControl[] activeControls) {
|
||||||
|
insetsChanged(insetsState);
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,99 @@
|
|||||||
|
/*
|
||||||
|
* Copyright (C) 2020 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 com.android.wm.shell.stagesplit;
|
||||||
|
|
||||||
|
import android.annotation.IntDef;
|
||||||
|
import android.annotation.NonNull;
|
||||||
|
|
||||||
|
import com.android.wm.shell.common.annotations.ExternalThread;
|
||||||
|
import com.android.wm.shell.common.split.SplitLayout.SplitPosition;
|
||||||
|
|
||||||
|
import java.util.concurrent.Executor;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Interface to engage split-screen feature.
|
||||||
|
* TODO: Figure out which of these are actually needed outside of the Shell
|
||||||
|
*/
|
||||||
|
@ExternalThread
|
||||||
|
public interface SplitScreen {
|
||||||
|
/**
|
||||||
|
* Stage type isn't specified normally meaning to use what ever the default is.
|
||||||
|
* E.g. exit split-screen and launch the app in fullscreen.
|
||||||
|
*/
|
||||||
|
int STAGE_TYPE_UNDEFINED = -1;
|
||||||
|
/**
|
||||||
|
* The main stage type.
|
||||||
|
* @see MainStage
|
||||||
|
*/
|
||||||
|
int STAGE_TYPE_MAIN = 0;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The side stage type.
|
||||||
|
* @see SideStage
|
||||||
|
*/
|
||||||
|
int STAGE_TYPE_SIDE = 1;
|
||||||
|
|
||||||
|
@IntDef(prefix = { "STAGE_TYPE_" }, value = {
|
||||||
|
STAGE_TYPE_UNDEFINED,
|
||||||
|
STAGE_TYPE_MAIN,
|
||||||
|
STAGE_TYPE_SIDE
|
||||||
|
})
|
||||||
|
@interface StageType {}
|
||||||
|
|
||||||
|
/** Callback interface for listening to changes in a split-screen stage. */
|
||||||
|
interface SplitScreenListener {
|
||||||
|
default void onStagePositionChanged(@StageType int stage, @SplitPosition int position) {}
|
||||||
|
default void onTaskStageChanged(int taskId, @StageType int stage, boolean visible) {}
|
||||||
|
default void onSplitVisibilityChanged(boolean visible) {}
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Registers listener that gets split screen callback. */
|
||||||
|
void registerSplitScreenListener(@NonNull SplitScreenListener listener,
|
||||||
|
@NonNull Executor executor);
|
||||||
|
|
||||||
|
/** Unregisters listener that gets split screen callback. */
|
||||||
|
void unregisterSplitScreenListener(@NonNull SplitScreenListener listener);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Returns a binder that can be passed to an external process to manipulate SplitScreen.
|
||||||
|
*/
|
||||||
|
default ISplitScreen createExternalInterface() {
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Called when the keyguard occluded state changes.
|
||||||
|
* @param occluded Indicates if the keyguard is now occluded.
|
||||||
|
*/
|
||||||
|
void onKeyguardOccludedChanged(boolean occluded);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Called when the visibility of the keyguard changes.
|
||||||
|
* @param showing Indicates if the keyguard is now visible.
|
||||||
|
*/
|
||||||
|
void onKeyguardVisibilityChanged(boolean showing);
|
||||||
|
|
||||||
|
/** Get a string representation of a stage type */
|
||||||
|
static String stageTypeToString(@StageType int stage) {
|
||||||
|
switch (stage) {
|
||||||
|
case STAGE_TYPE_UNDEFINED: return "UNDEFINED";
|
||||||
|
case STAGE_TYPE_MAIN: return "MAIN";
|
||||||
|
case STAGE_TYPE_SIDE: return "SIDE";
|
||||||
|
default: return "UNKNOWN(" + stage + ")";
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,595 @@
|
|||||||
|
/*
|
||||||
|
* Copyright (C) 2020 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 com.android.wm.shell.stagesplit;
|
||||||
|
|
||||||
|
import static android.view.Display.DEFAULT_DISPLAY;
|
||||||
|
import static android.view.RemoteAnimationTarget.MODE_OPENING;
|
||||||
|
|
||||||
|
import static com.android.wm.shell.common.ExecutorUtils.executeRemoteCallWithTaskPermission;
|
||||||
|
import static com.android.wm.shell.common.split.SplitLayout.SPLIT_POSITION_BOTTOM_OR_RIGHT;
|
||||||
|
import static com.android.wm.shell.common.split.SplitLayout.SPLIT_POSITION_TOP_OR_LEFT;
|
||||||
|
|
||||||
|
import android.app.ActivityManager;
|
||||||
|
import android.app.ActivityTaskManager;
|
||||||
|
import android.app.PendingIntent;
|
||||||
|
import android.content.ActivityNotFoundException;
|
||||||
|
import android.content.Context;
|
||||||
|
import android.content.Intent;
|
||||||
|
import android.content.pm.LauncherApps;
|
||||||
|
import android.graphics.Rect;
|
||||||
|
import android.os.Bundle;
|
||||||
|
import android.os.IBinder;
|
||||||
|
import android.os.RemoteException;
|
||||||
|
import android.os.UserHandle;
|
||||||
|
import android.util.ArrayMap;
|
||||||
|
import android.util.Slog;
|
||||||
|
import android.view.IRemoteAnimationFinishedCallback;
|
||||||
|
import android.view.RemoteAnimationAdapter;
|
||||||
|
import android.view.RemoteAnimationTarget;
|
||||||
|
import android.view.SurfaceControl;
|
||||||
|
import android.view.SurfaceSession;
|
||||||
|
import android.view.WindowManager;
|
||||||
|
import android.window.RemoteTransition;
|
||||||
|
import android.window.WindowContainerTransaction;
|
||||||
|
|
||||||
|
import androidx.annotation.BinderThread;
|
||||||
|
import androidx.annotation.NonNull;
|
||||||
|
import androidx.annotation.Nullable;
|
||||||
|
|
||||||
|
import com.android.internal.logging.InstanceId;
|
||||||
|
import com.android.internal.util.FrameworkStatsLog;
|
||||||
|
import com.android.wm.shell.RootTaskDisplayAreaOrganizer;
|
||||||
|
import com.android.wm.shell.ShellTaskOrganizer;
|
||||||
|
import com.android.wm.shell.common.DisplayImeController;
|
||||||
|
import com.android.wm.shell.common.DisplayInsetsController;
|
||||||
|
import com.android.wm.shell.common.RemoteCallable;
|
||||||
|
import com.android.wm.shell.common.ShellExecutor;
|
||||||
|
import com.android.wm.shell.common.SyncTransactionQueue;
|
||||||
|
import com.android.wm.shell.common.TransactionPool;
|
||||||
|
import com.android.wm.shell.common.annotations.ExternalThread;
|
||||||
|
import com.android.wm.shell.common.split.SplitLayout.SplitPosition;
|
||||||
|
import com.android.wm.shell.draganddrop.DragAndDropPolicy;
|
||||||
|
import com.android.wm.shell.transition.LegacyTransitions;
|
||||||
|
import com.android.wm.shell.transition.Transitions;
|
||||||
|
|
||||||
|
import java.io.PrintWriter;
|
||||||
|
import java.util.Arrays;
|
||||||
|
import java.util.Optional;
|
||||||
|
import java.util.concurrent.Executor;
|
||||||
|
|
||||||
|
import javax.inject.Provider;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Class manages split-screen multitasking mode and implements the main interface
|
||||||
|
* {@link SplitScreen}.
|
||||||
|
* @see StageCoordinator
|
||||||
|
*/
|
||||||
|
// TODO(b/198577848): Implement split screen flicker test to consolidate CUJ of split screen.
|
||||||
|
public class SplitScreenController implements DragAndDropPolicy.Starter,
|
||||||
|
RemoteCallable<SplitScreenController> {
|
||||||
|
private static final String TAG = SplitScreenController.class.getSimpleName();
|
||||||
|
|
||||||
|
private final ShellTaskOrganizer mTaskOrganizer;
|
||||||
|
private final SyncTransactionQueue mSyncQueue;
|
||||||
|
private final Context mContext;
|
||||||
|
private final RootTaskDisplayAreaOrganizer mRootTDAOrganizer;
|
||||||
|
private final ShellExecutor mMainExecutor;
|
||||||
|
private final SplitScreenImpl mImpl = new SplitScreenImpl();
|
||||||
|
private final DisplayImeController mDisplayImeController;
|
||||||
|
private final DisplayInsetsController mDisplayInsetsController;
|
||||||
|
private final Transitions mTransitions;
|
||||||
|
private final TransactionPool mTransactionPool;
|
||||||
|
private final SplitscreenEventLogger mLogger;
|
||||||
|
private final Provider<Optional<StageTaskUnfoldController>> mUnfoldControllerProvider;
|
||||||
|
|
||||||
|
private StageCoordinator mStageCoordinator;
|
||||||
|
|
||||||
|
public SplitScreenController(ShellTaskOrganizer shellTaskOrganizer,
|
||||||
|
SyncTransactionQueue syncQueue, Context context,
|
||||||
|
RootTaskDisplayAreaOrganizer rootTDAOrganizer,
|
||||||
|
ShellExecutor mainExecutor, DisplayImeController displayImeController,
|
||||||
|
DisplayInsetsController displayInsetsController,
|
||||||
|
Transitions transitions, TransactionPool transactionPool,
|
||||||
|
Provider<Optional<StageTaskUnfoldController>> unfoldControllerProvider) {
|
||||||
|
mTaskOrganizer = shellTaskOrganizer;
|
||||||
|
mSyncQueue = syncQueue;
|
||||||
|
mContext = context;
|
||||||
|
mRootTDAOrganizer = rootTDAOrganizer;
|
||||||
|
mMainExecutor = mainExecutor;
|
||||||
|
mDisplayImeController = displayImeController;
|
||||||
|
mDisplayInsetsController = displayInsetsController;
|
||||||
|
mTransitions = transitions;
|
||||||
|
mTransactionPool = transactionPool;
|
||||||
|
mUnfoldControllerProvider = unfoldControllerProvider;
|
||||||
|
mLogger = new SplitscreenEventLogger();
|
||||||
|
}
|
||||||
|
|
||||||
|
public SplitScreen asSplitScreen() {
|
||||||
|
return mImpl;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Context getContext() {
|
||||||
|
return mContext;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public ShellExecutor getRemoteCallExecutor() {
|
||||||
|
return mMainExecutor;
|
||||||
|
}
|
||||||
|
|
||||||
|
public void onOrganizerRegistered() {
|
||||||
|
if (mStageCoordinator == null) {
|
||||||
|
// TODO: Multi-display
|
||||||
|
mStageCoordinator = new StageCoordinator(mContext, DEFAULT_DISPLAY, mSyncQueue,
|
||||||
|
mRootTDAOrganizer, mTaskOrganizer, mDisplayImeController,
|
||||||
|
mDisplayInsetsController, mTransitions, mTransactionPool, mLogger,
|
||||||
|
mUnfoldControllerProvider);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
public boolean isSplitScreenVisible() {
|
||||||
|
return mStageCoordinator.isSplitScreenVisible();
|
||||||
|
}
|
||||||
|
|
||||||
|
public boolean moveToSideStage(int taskId, @SplitPosition int sideStagePosition) {
|
||||||
|
final ActivityManager.RunningTaskInfo task = mTaskOrganizer.getRunningTaskInfo(taskId);
|
||||||
|
if (task == null) {
|
||||||
|
throw new IllegalArgumentException("Unknown taskId" + taskId);
|
||||||
|
}
|
||||||
|
return moveToSideStage(task, sideStagePosition);
|
||||||
|
}
|
||||||
|
|
||||||
|
public boolean moveToSideStage(ActivityManager.RunningTaskInfo task,
|
||||||
|
@SplitPosition int sideStagePosition) {
|
||||||
|
return mStageCoordinator.moveToSideStage(task, sideStagePosition);
|
||||||
|
}
|
||||||
|
|
||||||
|
public boolean removeFromSideStage(int taskId) {
|
||||||
|
return mStageCoordinator.removeFromSideStage(taskId);
|
||||||
|
}
|
||||||
|
|
||||||
|
public void setSideStageOutline(boolean enable) {
|
||||||
|
mStageCoordinator.setSideStageOutline(enable);
|
||||||
|
}
|
||||||
|
|
||||||
|
public void setSideStagePosition(@SplitPosition int sideStagePosition) {
|
||||||
|
mStageCoordinator.setSideStagePosition(sideStagePosition, null /* wct */);
|
||||||
|
}
|
||||||
|
|
||||||
|
public void setSideStageVisibility(boolean visible) {
|
||||||
|
mStageCoordinator.setSideStageVisibility(visible);
|
||||||
|
}
|
||||||
|
|
||||||
|
public void enterSplitScreen(int taskId, boolean leftOrTop) {
|
||||||
|
moveToSideStage(taskId,
|
||||||
|
leftOrTop ? SPLIT_POSITION_TOP_OR_LEFT : SPLIT_POSITION_BOTTOM_OR_RIGHT);
|
||||||
|
}
|
||||||
|
|
||||||
|
public void exitSplitScreen(int toTopTaskId, int exitReason) {
|
||||||
|
mStageCoordinator.exitSplitScreen(toTopTaskId, exitReason);
|
||||||
|
}
|
||||||
|
|
||||||
|
public void onKeyguardOccludedChanged(boolean occluded) {
|
||||||
|
mStageCoordinator.onKeyguardOccludedChanged(occluded);
|
||||||
|
}
|
||||||
|
|
||||||
|
public void onKeyguardVisibilityChanged(boolean showing) {
|
||||||
|
mStageCoordinator.onKeyguardVisibilityChanged(showing);
|
||||||
|
}
|
||||||
|
|
||||||
|
public void exitSplitScreenOnHide(boolean exitSplitScreenOnHide) {
|
||||||
|
mStageCoordinator.exitSplitScreenOnHide(exitSplitScreenOnHide);
|
||||||
|
}
|
||||||
|
|
||||||
|
public void getStageBounds(Rect outTopOrLeftBounds, Rect outBottomOrRightBounds) {
|
||||||
|
mStageCoordinator.getStageBounds(outTopOrLeftBounds, outBottomOrRightBounds);
|
||||||
|
}
|
||||||
|
|
||||||
|
public void registerSplitScreenListener(SplitScreen.SplitScreenListener listener) {
|
||||||
|
mStageCoordinator.registerSplitScreenListener(listener);
|
||||||
|
}
|
||||||
|
|
||||||
|
public void unregisterSplitScreenListener(SplitScreen.SplitScreenListener listener) {
|
||||||
|
mStageCoordinator.unregisterSplitScreenListener(listener);
|
||||||
|
}
|
||||||
|
|
||||||
|
public void startTask(int taskId, @SplitScreen.StageType int stage,
|
||||||
|
@SplitPosition int position, @Nullable Bundle options) {
|
||||||
|
options = mStageCoordinator.resolveStartStage(stage, position, options, null /* wct */);
|
||||||
|
|
||||||
|
try {
|
||||||
|
ActivityTaskManager.getService().startActivityFromRecents(taskId, options);
|
||||||
|
} catch (RemoteException e) {
|
||||||
|
Slog.e(TAG, "Failed to launch task", e);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
public void startShortcut(String packageName, String shortcutId,
|
||||||
|
@SplitScreen.StageType int stage, @SplitPosition int position,
|
||||||
|
@Nullable Bundle options, UserHandle user) {
|
||||||
|
options = mStageCoordinator.resolveStartStage(stage, position, options, null /* wct */);
|
||||||
|
|
||||||
|
try {
|
||||||
|
LauncherApps launcherApps =
|
||||||
|
mContext.getSystemService(LauncherApps.class);
|
||||||
|
launcherApps.startShortcut(packageName, shortcutId, null /* sourceBounds */,
|
||||||
|
options, user);
|
||||||
|
} catch (ActivityNotFoundException e) {
|
||||||
|
Slog.e(TAG, "Failed to launch shortcut", e);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
public void startIntent(PendingIntent intent, Intent fillInIntent,
|
||||||
|
@SplitScreen.StageType int stage, @SplitPosition int position,
|
||||||
|
@Nullable Bundle options) {
|
||||||
|
if (!Transitions.ENABLE_SHELL_TRANSITIONS) {
|
||||||
|
startIntentLegacy(intent, fillInIntent, stage, position, options);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
mStageCoordinator.startIntent(intent, fillInIntent, stage, position, options,
|
||||||
|
null /* remote */);
|
||||||
|
}
|
||||||
|
|
||||||
|
private void startIntentLegacy(PendingIntent intent, Intent fillInIntent,
|
||||||
|
@SplitScreen.StageType int stage, @SplitPosition int position,
|
||||||
|
@Nullable Bundle options) {
|
||||||
|
LegacyTransitions.ILegacyTransition transition = new LegacyTransitions.ILegacyTransition() {
|
||||||
|
@Override
|
||||||
|
public void onAnimationStart(int transit, RemoteAnimationTarget[] apps,
|
||||||
|
RemoteAnimationTarget[] wallpapers, RemoteAnimationTarget[] nonApps,
|
||||||
|
IRemoteAnimationFinishedCallback finishedCallback,
|
||||||
|
SurfaceControl.Transaction t) {
|
||||||
|
mStageCoordinator.updateSurfaceBounds(null /* layout */, t);
|
||||||
|
|
||||||
|
if (apps != null) {
|
||||||
|
for (int i = 0; i < apps.length; ++i) {
|
||||||
|
if (apps[i].mode == MODE_OPENING) {
|
||||||
|
t.show(apps[i].leash);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
t.apply();
|
||||||
|
if (finishedCallback != null) {
|
||||||
|
try {
|
||||||
|
finishedCallback.onAnimationFinished();
|
||||||
|
} catch (RemoteException e) {
|
||||||
|
Slog.e(TAG, "Error finishing legacy transition: ", e);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
WindowContainerTransaction wct = new WindowContainerTransaction();
|
||||||
|
options = mStageCoordinator.resolveStartStage(stage, position, options, wct);
|
||||||
|
wct.sendPendingIntent(intent, fillInIntent, options);
|
||||||
|
mSyncQueue.queue(transition, WindowManager.TRANSIT_OPEN, wct);
|
||||||
|
}
|
||||||
|
|
||||||
|
RemoteAnimationTarget[] onGoingToRecentsLegacy(boolean cancel, RemoteAnimationTarget[] apps) {
|
||||||
|
if (!isSplitScreenVisible()) return null;
|
||||||
|
final SurfaceControl.Builder builder = new SurfaceControl.Builder(new SurfaceSession())
|
||||||
|
.setContainerLayer()
|
||||||
|
.setName("RecentsAnimationSplitTasks")
|
||||||
|
.setHidden(false)
|
||||||
|
.setCallsite("SplitScreenController#onGoingtoRecentsLegacy");
|
||||||
|
mRootTDAOrganizer.attachToDisplayArea(DEFAULT_DISPLAY, builder);
|
||||||
|
SurfaceControl sc = builder.build();
|
||||||
|
SurfaceControl.Transaction transaction = new SurfaceControl.Transaction();
|
||||||
|
|
||||||
|
// Ensure that we order these in the parent in the right z-order as their previous order
|
||||||
|
Arrays.sort(apps, (a1, a2) -> a1.prefixOrderIndex - a2.prefixOrderIndex);
|
||||||
|
int layer = 1;
|
||||||
|
for (RemoteAnimationTarget appTarget : apps) {
|
||||||
|
transaction.reparent(appTarget.leash, sc);
|
||||||
|
transaction.setPosition(appTarget.leash, appTarget.screenSpaceBounds.left,
|
||||||
|
appTarget.screenSpaceBounds.top);
|
||||||
|
transaction.setLayer(appTarget.leash, layer++);
|
||||||
|
}
|
||||||
|
transaction.apply();
|
||||||
|
transaction.close();
|
||||||
|
return new RemoteAnimationTarget[]{
|
||||||
|
mStageCoordinator.getDividerBarLegacyTarget(),
|
||||||
|
mStageCoordinator.getOutlineLegacyTarget()};
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Sets drag info to be logged when splitscreen is entered.
|
||||||
|
*/
|
||||||
|
public void logOnDroppedToSplit(@SplitPosition int position, InstanceId dragSessionId) {
|
||||||
|
mStageCoordinator.logOnDroppedToSplit(position, dragSessionId);
|
||||||
|
}
|
||||||
|
|
||||||
|
public void dump(@NonNull PrintWriter pw, String prefix) {
|
||||||
|
pw.println(prefix + TAG);
|
||||||
|
if (mStageCoordinator != null) {
|
||||||
|
mStageCoordinator.dump(pw, prefix);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The interface for calls from outside the Shell, within the host process.
|
||||||
|
*/
|
||||||
|
@ExternalThread
|
||||||
|
private class SplitScreenImpl implements SplitScreen {
|
||||||
|
private ISplitScreenImpl mISplitScreen;
|
||||||
|
private final ArrayMap<SplitScreenListener, Executor> mExecutors = new ArrayMap<>();
|
||||||
|
private final SplitScreenListener mListener = new SplitScreenListener() {
|
||||||
|
@Override
|
||||||
|
public void onStagePositionChanged(int stage, int position) {
|
||||||
|
for (int i = 0; i < mExecutors.size(); i++) {
|
||||||
|
final int index = i;
|
||||||
|
mExecutors.valueAt(index).execute(() -> {
|
||||||
|
mExecutors.keyAt(index).onStagePositionChanged(stage, position);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void onTaskStageChanged(int taskId, int stage, boolean visible) {
|
||||||
|
for (int i = 0; i < mExecutors.size(); i++) {
|
||||||
|
final int index = i;
|
||||||
|
mExecutors.valueAt(index).execute(() -> {
|
||||||
|
mExecutors.keyAt(index).onTaskStageChanged(taskId, stage, visible);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void onSplitVisibilityChanged(boolean visible) {
|
||||||
|
for (int i = 0; i < mExecutors.size(); i++) {
|
||||||
|
final int index = i;
|
||||||
|
mExecutors.valueAt(index).execute(() -> {
|
||||||
|
mExecutors.keyAt(index).onSplitVisibilityChanged(visible);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public ISplitScreen createExternalInterface() {
|
||||||
|
if (mISplitScreen != null) {
|
||||||
|
mISplitScreen.invalidate();
|
||||||
|
}
|
||||||
|
mISplitScreen = new ISplitScreenImpl(SplitScreenController.this);
|
||||||
|
return mISplitScreen;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void onKeyguardOccludedChanged(boolean occluded) {
|
||||||
|
mMainExecutor.execute(() -> {
|
||||||
|
SplitScreenController.this.onKeyguardOccludedChanged(occluded);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void registerSplitScreenListener(SplitScreenListener listener, Executor executor) {
|
||||||
|
if (mExecutors.containsKey(listener)) return;
|
||||||
|
|
||||||
|
mMainExecutor.execute(() -> {
|
||||||
|
if (mExecutors.size() == 0) {
|
||||||
|
SplitScreenController.this.registerSplitScreenListener(mListener);
|
||||||
|
}
|
||||||
|
|
||||||
|
mExecutors.put(listener, executor);
|
||||||
|
});
|
||||||
|
|
||||||
|
executor.execute(() -> {
|
||||||
|
mStageCoordinator.sendStatusToListener(listener);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void unregisterSplitScreenListener(SplitScreenListener listener) {
|
||||||
|
mMainExecutor.execute(() -> {
|
||||||
|
mExecutors.remove(listener);
|
||||||
|
|
||||||
|
if (mExecutors.size() == 0) {
|
||||||
|
SplitScreenController.this.unregisterSplitScreenListener(mListener);
|
||||||
|
}
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void onKeyguardVisibilityChanged(boolean showing) {
|
||||||
|
mMainExecutor.execute(() -> {
|
||||||
|
SplitScreenController.this.onKeyguardVisibilityChanged(showing);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The interface for calls from outside the host process.
|
||||||
|
*/
|
||||||
|
@BinderThread
|
||||||
|
private static class ISplitScreenImpl extends ISplitScreen.Stub {
|
||||||
|
private SplitScreenController mController;
|
||||||
|
private ISplitScreenListener mListener;
|
||||||
|
private final SplitScreen.SplitScreenListener mSplitScreenListener =
|
||||||
|
new SplitScreen.SplitScreenListener() {
|
||||||
|
@Override
|
||||||
|
public void onStagePositionChanged(int stage, int position) {
|
||||||
|
try {
|
||||||
|
if (mListener != null) {
|
||||||
|
mListener.onStagePositionChanged(stage, position);
|
||||||
|
}
|
||||||
|
} catch (RemoteException e) {
|
||||||
|
Slog.e(TAG, "onStagePositionChanged", e);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void onTaskStageChanged(int taskId, int stage, boolean visible) {
|
||||||
|
try {
|
||||||
|
if (mListener != null) {
|
||||||
|
mListener.onTaskStageChanged(taskId, stage, visible);
|
||||||
|
}
|
||||||
|
} catch (RemoteException e) {
|
||||||
|
Slog.e(TAG, "onTaskStageChanged", e);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
private final IBinder.DeathRecipient mListenerDeathRecipient =
|
||||||
|
new IBinder.DeathRecipient() {
|
||||||
|
@Override
|
||||||
|
@BinderThread
|
||||||
|
public void binderDied() {
|
||||||
|
final SplitScreenController controller = mController;
|
||||||
|
controller.getRemoteCallExecutor().execute(() -> {
|
||||||
|
mListener = null;
|
||||||
|
controller.unregisterSplitScreenListener(mSplitScreenListener);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
public ISplitScreenImpl(SplitScreenController controller) {
|
||||||
|
mController = controller;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Invalidates this instance, preventing future calls from updating the controller.
|
||||||
|
*/
|
||||||
|
void invalidate() {
|
||||||
|
mController = null;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void registerSplitScreenListener(ISplitScreenListener listener) {
|
||||||
|
executeRemoteCallWithTaskPermission(mController, "registerSplitScreenListener",
|
||||||
|
(controller) -> {
|
||||||
|
if (mListener != null) {
|
||||||
|
mListener.asBinder().unlinkToDeath(mListenerDeathRecipient,
|
||||||
|
0 /* flags */);
|
||||||
|
}
|
||||||
|
if (listener != null) {
|
||||||
|
try {
|
||||||
|
listener.asBinder().linkToDeath(mListenerDeathRecipient,
|
||||||
|
0 /* flags */);
|
||||||
|
} catch (RemoteException e) {
|
||||||
|
Slog.e(TAG, "Failed to link to death");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
mListener = listener;
|
||||||
|
controller.registerSplitScreenListener(mSplitScreenListener);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void unregisterSplitScreenListener(ISplitScreenListener listener) {
|
||||||
|
executeRemoteCallWithTaskPermission(mController, "unregisterSplitScreenListener",
|
||||||
|
(controller) -> {
|
||||||
|
if (mListener != null) {
|
||||||
|
mListener.asBinder().unlinkToDeath(mListenerDeathRecipient,
|
||||||
|
0 /* flags */);
|
||||||
|
}
|
||||||
|
mListener = null;
|
||||||
|
controller.unregisterSplitScreenListener(mSplitScreenListener);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void exitSplitScreen(int toTopTaskId) {
|
||||||
|
executeRemoteCallWithTaskPermission(mController, "exitSplitScreen",
|
||||||
|
(controller) -> {
|
||||||
|
controller.exitSplitScreen(toTopTaskId,
|
||||||
|
FrameworkStatsLog.SPLITSCREEN_UICHANGED__EXIT_REASON__UNKNOWN_EXIT);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void exitSplitScreenOnHide(boolean exitSplitScreenOnHide) {
|
||||||
|
executeRemoteCallWithTaskPermission(mController, "exitSplitScreenOnHide",
|
||||||
|
(controller) -> {
|
||||||
|
controller.exitSplitScreenOnHide(exitSplitScreenOnHide);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void setSideStageVisibility(boolean visible) {
|
||||||
|
executeRemoteCallWithTaskPermission(mController, "setSideStageVisibility",
|
||||||
|
(controller) -> {
|
||||||
|
controller.setSideStageVisibility(visible);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void removeFromSideStage(int taskId) {
|
||||||
|
executeRemoteCallWithTaskPermission(mController, "removeFromSideStage",
|
||||||
|
(controller) -> {
|
||||||
|
controller.removeFromSideStage(taskId);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void startTask(int taskId, int stage, int position, @Nullable Bundle options) {
|
||||||
|
executeRemoteCallWithTaskPermission(mController, "startTask",
|
||||||
|
(controller) -> {
|
||||||
|
controller.startTask(taskId, stage, position, options);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void startTasksWithLegacyTransition(int mainTaskId, @Nullable Bundle mainOptions,
|
||||||
|
int sideTaskId, @Nullable Bundle sideOptions, @SplitPosition int sidePosition,
|
||||||
|
RemoteAnimationAdapter adapter) {
|
||||||
|
executeRemoteCallWithTaskPermission(mController, "startTasks",
|
||||||
|
(controller) -> controller.mStageCoordinator.startTasksWithLegacyTransition(
|
||||||
|
mainTaskId, mainOptions, sideTaskId, sideOptions, sidePosition,
|
||||||
|
adapter));
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void startTasks(int mainTaskId, @Nullable Bundle mainOptions,
|
||||||
|
int sideTaskId, @Nullable Bundle sideOptions,
|
||||||
|
@SplitPosition int sidePosition,
|
||||||
|
@Nullable RemoteTransition remoteTransition) {
|
||||||
|
executeRemoteCallWithTaskPermission(mController, "startTasks",
|
||||||
|
(controller) -> controller.mStageCoordinator.startTasks(mainTaskId, mainOptions,
|
||||||
|
sideTaskId, sideOptions, sidePosition, remoteTransition));
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void startShortcut(String packageName, String shortcutId, int stage, int position,
|
||||||
|
@Nullable Bundle options, UserHandle user) {
|
||||||
|
executeRemoteCallWithTaskPermission(mController, "startShortcut",
|
||||||
|
(controller) -> {
|
||||||
|
controller.startShortcut(packageName, shortcutId, stage, position,
|
||||||
|
options, user);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void startIntent(PendingIntent intent, Intent fillInIntent, int stage, int position,
|
||||||
|
@Nullable Bundle options) {
|
||||||
|
executeRemoteCallWithTaskPermission(mController, "startIntent",
|
||||||
|
(controller) -> {
|
||||||
|
controller.startIntent(intent, fillInIntent, stage, position, options);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public RemoteAnimationTarget[] onGoingToRecentsLegacy(boolean cancel,
|
||||||
|
RemoteAnimationTarget[] apps) {
|
||||||
|
final RemoteAnimationTarget[][] out = new RemoteAnimationTarget[][]{null};
|
||||||
|
executeRemoteCallWithTaskPermission(mController, "onGoingToRecentsLegacy",
|
||||||
|
(controller) -> out[0] = controller.onGoingToRecentsLegacy(cancel, apps),
|
||||||
|
true /* blocking */);
|
||||||
|
return out[0];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,298 @@
|
|||||||
|
/*
|
||||||
|
* Copyright (C) 2021 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 com.android.wm.shell.stagesplit;
|
||||||
|
|
||||||
|
import static android.view.WindowManager.TRANSIT_CHANGE;
|
||||||
|
import static android.view.WindowManager.TRANSIT_CLOSE;
|
||||||
|
import static android.view.WindowManager.TRANSIT_OPEN;
|
||||||
|
import static android.view.WindowManager.TRANSIT_TO_BACK;
|
||||||
|
import static android.view.WindowManager.TRANSIT_TO_FRONT;
|
||||||
|
import static android.window.TransitionInfo.FLAG_FIRST_CUSTOM;
|
||||||
|
|
||||||
|
import static com.android.wm.shell.transition.Transitions.TRANSIT_SPLIT_DISMISS_SNAP;
|
||||||
|
import static com.android.wm.shell.transition.Transitions.isOpeningType;
|
||||||
|
|
||||||
|
import android.animation.Animator;
|
||||||
|
import android.animation.AnimatorListenerAdapter;
|
||||||
|
import android.animation.ValueAnimator;
|
||||||
|
import android.annotation.NonNull;
|
||||||
|
import android.annotation.Nullable;
|
||||||
|
import android.graphics.Rect;
|
||||||
|
import android.os.IBinder;
|
||||||
|
import android.view.SurfaceControl;
|
||||||
|
import android.view.WindowManager;
|
||||||
|
import android.window.RemoteTransition;
|
||||||
|
import android.window.TransitionInfo;
|
||||||
|
import android.window.WindowContainerToken;
|
||||||
|
import android.window.WindowContainerTransaction;
|
||||||
|
|
||||||
|
import com.android.wm.shell.common.TransactionPool;
|
||||||
|
import com.android.wm.shell.transition.OneShotRemoteHandler;
|
||||||
|
import com.android.wm.shell.transition.Transitions;
|
||||||
|
|
||||||
|
import java.util.ArrayList;
|
||||||
|
|
||||||
|
/** Manages transition animations for split-screen. */
|
||||||
|
class SplitScreenTransitions {
|
||||||
|
private static final String TAG = "SplitScreenTransitions";
|
||||||
|
|
||||||
|
/** Flag applied to a transition change to identify it as a divider bar for animation. */
|
||||||
|
public static final int FLAG_IS_DIVIDER_BAR = FLAG_FIRST_CUSTOM;
|
||||||
|
|
||||||
|
private final TransactionPool mTransactionPool;
|
||||||
|
private final Transitions mTransitions;
|
||||||
|
private final Runnable mOnFinish;
|
||||||
|
|
||||||
|
IBinder mPendingDismiss = null;
|
||||||
|
IBinder mPendingEnter = null;
|
||||||
|
|
||||||
|
private IBinder mAnimatingTransition = null;
|
||||||
|
private OneShotRemoteHandler mRemoteHandler = null;
|
||||||
|
|
||||||
|
private Transitions.TransitionFinishCallback mRemoteFinishCB = (wct, wctCB) -> {
|
||||||
|
if (wct != null || wctCB != null) {
|
||||||
|
throw new UnsupportedOperationException("finish transactions not supported yet.");
|
||||||
|
}
|
||||||
|
onFinish();
|
||||||
|
};
|
||||||
|
|
||||||
|
/** Keeps track of currently running animations */
|
||||||
|
private final ArrayList<Animator> mAnimations = new ArrayList<>();
|
||||||
|
|
||||||
|
private Transitions.TransitionFinishCallback mFinishCallback = null;
|
||||||
|
private SurfaceControl.Transaction mFinishTransaction;
|
||||||
|
|
||||||
|
SplitScreenTransitions(@NonNull TransactionPool pool, @NonNull Transitions transitions,
|
||||||
|
@NonNull Runnable onFinishCallback) {
|
||||||
|
mTransactionPool = pool;
|
||||||
|
mTransitions = transitions;
|
||||||
|
mOnFinish = onFinishCallback;
|
||||||
|
}
|
||||||
|
|
||||||
|
void playAnimation(@NonNull IBinder transition, @NonNull TransitionInfo info,
|
||||||
|
@NonNull SurfaceControl.Transaction startTransaction,
|
||||||
|
@NonNull SurfaceControl.Transaction finishTransaction,
|
||||||
|
@NonNull Transitions.TransitionFinishCallback finishCallback,
|
||||||
|
@NonNull WindowContainerToken mainRoot, @NonNull WindowContainerToken sideRoot) {
|
||||||
|
mFinishCallback = finishCallback;
|
||||||
|
mAnimatingTransition = transition;
|
||||||
|
if (mRemoteHandler != null) {
|
||||||
|
mRemoteHandler.startAnimation(transition, info, startTransaction, finishTransaction,
|
||||||
|
mRemoteFinishCB);
|
||||||
|
mRemoteHandler = null;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
playInternalAnimation(transition, info, startTransaction, mainRoot, sideRoot);
|
||||||
|
}
|
||||||
|
|
||||||
|
private void playInternalAnimation(@NonNull IBinder transition, @NonNull TransitionInfo info,
|
||||||
|
@NonNull SurfaceControl.Transaction t, @NonNull WindowContainerToken mainRoot,
|
||||||
|
@NonNull WindowContainerToken sideRoot) {
|
||||||
|
mFinishTransaction = mTransactionPool.acquire();
|
||||||
|
|
||||||
|
// Play some place-holder fade animations
|
||||||
|
for (int i = info.getChanges().size() - 1; i >= 0; --i) {
|
||||||
|
final TransitionInfo.Change change = info.getChanges().get(i);
|
||||||
|
final SurfaceControl leash = change.getLeash();
|
||||||
|
final int mode = info.getChanges().get(i).getMode();
|
||||||
|
|
||||||
|
if (mode == TRANSIT_CHANGE) {
|
||||||
|
if (change.getParent() != null) {
|
||||||
|
// This is probably reparented, so we want the parent to be immediately visible
|
||||||
|
final TransitionInfo.Change parentChange = info.getChange(change.getParent());
|
||||||
|
t.show(parentChange.getLeash());
|
||||||
|
t.setAlpha(parentChange.getLeash(), 1.f);
|
||||||
|
// and then animate this layer outside the parent (since, for example, this is
|
||||||
|
// the home task animating from fullscreen to part-screen).
|
||||||
|
t.reparent(leash, info.getRootLeash());
|
||||||
|
t.setLayer(leash, info.getChanges().size() - i);
|
||||||
|
// build the finish reparent/reposition
|
||||||
|
mFinishTransaction.reparent(leash, parentChange.getLeash());
|
||||||
|
mFinishTransaction.setPosition(leash,
|
||||||
|
change.getEndRelOffset().x, change.getEndRelOffset().y);
|
||||||
|
}
|
||||||
|
// TODO(shell-transitions): screenshot here
|
||||||
|
final Rect startBounds = new Rect(change.getStartAbsBounds());
|
||||||
|
if (info.getType() == TRANSIT_SPLIT_DISMISS_SNAP) {
|
||||||
|
// Dismissing split via snap which means the still-visible task has been
|
||||||
|
// dragged to its end position at animation start so reflect that here.
|
||||||
|
startBounds.offsetTo(change.getEndAbsBounds().left,
|
||||||
|
change.getEndAbsBounds().top);
|
||||||
|
}
|
||||||
|
final Rect endBounds = new Rect(change.getEndAbsBounds());
|
||||||
|
startBounds.offset(-info.getRootOffset().x, -info.getRootOffset().y);
|
||||||
|
endBounds.offset(-info.getRootOffset().x, -info.getRootOffset().y);
|
||||||
|
startExampleResizeAnimation(leash, startBounds, endBounds);
|
||||||
|
}
|
||||||
|
if (change.getParent() != null) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (transition == mPendingEnter && (mainRoot.equals(change.getContainer())
|
||||||
|
|| sideRoot.equals(change.getContainer()))) {
|
||||||
|
t.setWindowCrop(leash, change.getStartAbsBounds().width(),
|
||||||
|
change.getStartAbsBounds().height());
|
||||||
|
}
|
||||||
|
boolean isOpening = isOpeningType(info.getType());
|
||||||
|
if (isOpening && (mode == TRANSIT_OPEN || mode == TRANSIT_TO_FRONT)) {
|
||||||
|
// fade in
|
||||||
|
startExampleAnimation(leash, true /* show */);
|
||||||
|
} else if (!isOpening && (mode == TRANSIT_CLOSE || mode == TRANSIT_TO_BACK)) {
|
||||||
|
// fade out
|
||||||
|
if (info.getType() == TRANSIT_SPLIT_DISMISS_SNAP) {
|
||||||
|
// Dismissing via snap-to-top/bottom means that the dismissed task is already
|
||||||
|
// not-visible (usually cropped to oblivion) so immediately set its alpha to 0
|
||||||
|
// and don't animate it so it doesn't pop-in when reparented.
|
||||||
|
t.setAlpha(leash, 0.f);
|
||||||
|
} else {
|
||||||
|
startExampleAnimation(leash, false /* show */);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
t.apply();
|
||||||
|
onFinish();
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Starts a transition to enter split with a remote transition animator. */
|
||||||
|
IBinder startEnterTransition(@WindowManager.TransitionType int transitType,
|
||||||
|
@NonNull WindowContainerTransaction wct, @Nullable RemoteTransition remoteTransition,
|
||||||
|
@NonNull Transitions.TransitionHandler handler) {
|
||||||
|
if (remoteTransition != null) {
|
||||||
|
// Wrapping it for ease-of-use (OneShot handles all the binder linking/death stuff)
|
||||||
|
mRemoteHandler = new OneShotRemoteHandler(
|
||||||
|
mTransitions.getMainExecutor(), remoteTransition);
|
||||||
|
}
|
||||||
|
final IBinder transition = mTransitions.startTransition(transitType, wct, handler);
|
||||||
|
mPendingEnter = transition;
|
||||||
|
if (mRemoteHandler != null) {
|
||||||
|
mRemoteHandler.setTransition(transition);
|
||||||
|
}
|
||||||
|
return transition;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Starts a transition for dismissing split after dragging the divider to a screen edge */
|
||||||
|
IBinder startSnapToDismiss(@NonNull WindowContainerTransaction wct,
|
||||||
|
@NonNull Transitions.TransitionHandler handler) {
|
||||||
|
final IBinder transition = mTransitions.startTransition(
|
||||||
|
TRANSIT_SPLIT_DISMISS_SNAP, wct, handler);
|
||||||
|
mPendingDismiss = transition;
|
||||||
|
return transition;
|
||||||
|
}
|
||||||
|
|
||||||
|
void onFinish() {
|
||||||
|
if (!mAnimations.isEmpty()) return;
|
||||||
|
mOnFinish.run();
|
||||||
|
if (mFinishTransaction != null) {
|
||||||
|
mFinishTransaction.apply();
|
||||||
|
mTransactionPool.release(mFinishTransaction);
|
||||||
|
mFinishTransaction = null;
|
||||||
|
}
|
||||||
|
mFinishCallback.onTransitionFinished(null /* wct */, null /* wctCB */);
|
||||||
|
mFinishCallback = null;
|
||||||
|
if (mAnimatingTransition == mPendingEnter) {
|
||||||
|
mPendingEnter = null;
|
||||||
|
}
|
||||||
|
if (mAnimatingTransition == mPendingDismiss) {
|
||||||
|
mPendingDismiss = null;
|
||||||
|
}
|
||||||
|
mAnimatingTransition = null;
|
||||||
|
}
|
||||||
|
|
||||||
|
// TODO(shell-transitions): real animations
|
||||||
|
private void startExampleAnimation(@NonNull SurfaceControl leash, boolean show) {
|
||||||
|
final float end = show ? 1.f : 0.f;
|
||||||
|
final float start = 1.f - end;
|
||||||
|
final SurfaceControl.Transaction transaction = mTransactionPool.acquire();
|
||||||
|
final ValueAnimator va = ValueAnimator.ofFloat(start, end);
|
||||||
|
va.setDuration(500);
|
||||||
|
va.addUpdateListener(animation -> {
|
||||||
|
float fraction = animation.getAnimatedFraction();
|
||||||
|
transaction.setAlpha(leash, start * (1.f - fraction) + end * fraction);
|
||||||
|
transaction.apply();
|
||||||
|
});
|
||||||
|
final Runnable finisher = () -> {
|
||||||
|
transaction.setAlpha(leash, end);
|
||||||
|
transaction.apply();
|
||||||
|
mTransactionPool.release(transaction);
|
||||||
|
mTransitions.getMainExecutor().execute(() -> {
|
||||||
|
mAnimations.remove(va);
|
||||||
|
onFinish();
|
||||||
|
});
|
||||||
|
};
|
||||||
|
va.addListener(new Animator.AnimatorListener() {
|
||||||
|
@Override
|
||||||
|
public void onAnimationStart(Animator animation) { }
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void onAnimationEnd(Animator animation) {
|
||||||
|
finisher.run();
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void onAnimationCancel(Animator animation) {
|
||||||
|
finisher.run();
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void onAnimationRepeat(Animator animation) { }
|
||||||
|
});
|
||||||
|
mAnimations.add(va);
|
||||||
|
mTransitions.getAnimExecutor().execute(va::start);
|
||||||
|
}
|
||||||
|
|
||||||
|
// TODO(shell-transitions): real animations
|
||||||
|
private void startExampleResizeAnimation(@NonNull SurfaceControl leash,
|
||||||
|
@NonNull Rect startBounds, @NonNull Rect endBounds) {
|
||||||
|
final SurfaceControl.Transaction transaction = mTransactionPool.acquire();
|
||||||
|
final ValueAnimator va = ValueAnimator.ofFloat(0.f, 1.f);
|
||||||
|
va.setDuration(500);
|
||||||
|
va.addUpdateListener(animation -> {
|
||||||
|
float fraction = animation.getAnimatedFraction();
|
||||||
|
transaction.setWindowCrop(leash,
|
||||||
|
(int) (startBounds.width() * (1.f - fraction) + endBounds.width() * fraction),
|
||||||
|
(int) (startBounds.height() * (1.f - fraction)
|
||||||
|
+ endBounds.height() * fraction));
|
||||||
|
transaction.setPosition(leash,
|
||||||
|
startBounds.left * (1.f - fraction) + endBounds.left * fraction,
|
||||||
|
startBounds.top * (1.f - fraction) + endBounds.top * fraction);
|
||||||
|
transaction.apply();
|
||||||
|
});
|
||||||
|
final Runnable finisher = () -> {
|
||||||
|
transaction.setWindowCrop(leash, 0, 0);
|
||||||
|
transaction.setPosition(leash, endBounds.left, endBounds.top);
|
||||||
|
transaction.apply();
|
||||||
|
mTransactionPool.release(transaction);
|
||||||
|
mTransitions.getMainExecutor().execute(() -> {
|
||||||
|
mAnimations.remove(va);
|
||||||
|
onFinish();
|
||||||
|
});
|
||||||
|
};
|
||||||
|
va.addListener(new AnimatorListenerAdapter() {
|
||||||
|
@Override
|
||||||
|
public void onAnimationEnd(Animator animation) {
|
||||||
|
finisher.run();
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void onAnimationCancel(Animator animation) {
|
||||||
|
finisher.run();
|
||||||
|
}
|
||||||
|
});
|
||||||
|
mAnimations.add(va);
|
||||||
|
mTransitions.getAnimExecutor().execute(va::start);
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,324 @@
|
|||||||
|
/*
|
||||||
|
* Copyright (C) 2021 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 com.android.wm.shell.stagesplit;
|
||||||
|
|
||||||
|
import static com.android.internal.util.FrameworkStatsLog.SPLITSCREEN_UICHANGED__ENTER_REASON__OVERVIEW;
|
||||||
|
import static com.android.wm.shell.common.split.SplitLayout.SPLIT_POSITION_TOP_OR_LEFT;
|
||||||
|
import static com.android.wm.shell.common.split.SplitLayout.SPLIT_POSITION_UNDEFINED;
|
||||||
|
|
||||||
|
import com.android.internal.logging.InstanceId;
|
||||||
|
import com.android.internal.logging.InstanceIdSequence;
|
||||||
|
import com.android.internal.util.FrameworkStatsLog;
|
||||||
|
import com.android.wm.shell.common.split.SplitLayout.SplitPosition;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Helper class that to log Drag & Drop UIEvents for a single session, see also go/uievent
|
||||||
|
*/
|
||||||
|
public class SplitscreenEventLogger {
|
||||||
|
|
||||||
|
// Used to generate instance ids for this drag if one is not provided
|
||||||
|
private final InstanceIdSequence mIdSequence;
|
||||||
|
|
||||||
|
// The instance id for the current splitscreen session (from start to end)
|
||||||
|
private InstanceId mLoggerSessionId;
|
||||||
|
|
||||||
|
// Drag info
|
||||||
|
private @SplitPosition int mDragEnterPosition;
|
||||||
|
private InstanceId mDragEnterSessionId;
|
||||||
|
|
||||||
|
// For deduping async events
|
||||||
|
private int mLastMainStagePosition = -1;
|
||||||
|
private int mLastMainStageUid = -1;
|
||||||
|
private int mLastSideStagePosition = -1;
|
||||||
|
private int mLastSideStageUid = -1;
|
||||||
|
private float mLastSplitRatio = -1f;
|
||||||
|
|
||||||
|
public SplitscreenEventLogger() {
|
||||||
|
mIdSequence = new InstanceIdSequence(Integer.MAX_VALUE);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Return whether a splitscreen session has started.
|
||||||
|
*/
|
||||||
|
public boolean hasStartedSession() {
|
||||||
|
return mLoggerSessionId != null;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* May be called before logEnter() to indicate that the session was started from a drag.
|
||||||
|
*/
|
||||||
|
public void enterRequestedByDrag(@SplitPosition int position, InstanceId dragSessionId) {
|
||||||
|
mDragEnterPosition = position;
|
||||||
|
mDragEnterSessionId = dragSessionId;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Logs when the user enters splitscreen.
|
||||||
|
*/
|
||||||
|
public void logEnter(float splitRatio,
|
||||||
|
@SplitPosition int mainStagePosition, int mainStageUid,
|
||||||
|
@SplitPosition int sideStagePosition, int sideStageUid,
|
||||||
|
boolean isLandscape) {
|
||||||
|
mLoggerSessionId = mIdSequence.newInstanceId();
|
||||||
|
int enterReason = mDragEnterPosition != SPLIT_POSITION_UNDEFINED
|
||||||
|
? getDragEnterReasonFromSplitPosition(mDragEnterPosition, isLandscape)
|
||||||
|
: SPLITSCREEN_UICHANGED__ENTER_REASON__OVERVIEW;
|
||||||
|
updateMainStageState(getMainStagePositionFromSplitPosition(mainStagePosition, isLandscape),
|
||||||
|
mainStageUid);
|
||||||
|
updateSideStageState(getSideStagePositionFromSplitPosition(sideStagePosition, isLandscape),
|
||||||
|
sideStageUid);
|
||||||
|
updateSplitRatioState(splitRatio);
|
||||||
|
FrameworkStatsLog.write(FrameworkStatsLog.SPLITSCREEN_UI_CHANGED,
|
||||||
|
FrameworkStatsLog.SPLITSCREEN_UICHANGED__ACTION__ENTER,
|
||||||
|
enterReason,
|
||||||
|
0 /* exitReason */,
|
||||||
|
splitRatio,
|
||||||
|
mLastMainStagePosition,
|
||||||
|
mLastMainStageUid,
|
||||||
|
mLastSideStagePosition,
|
||||||
|
mLastSideStageUid,
|
||||||
|
mDragEnterSessionId != null ? mDragEnterSessionId.getId() : 0,
|
||||||
|
mLoggerSessionId.getId());
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Logs when the user exits splitscreen. Only one of the main or side stages should be
|
||||||
|
* specified to indicate which position was focused as a part of exiting (both can be unset).
|
||||||
|
*/
|
||||||
|
public void logExit(int exitReason, @SplitPosition int mainStagePosition, int mainStageUid,
|
||||||
|
@SplitPosition int sideStagePosition, int sideStageUid, boolean isLandscape) {
|
||||||
|
if (mLoggerSessionId == null) {
|
||||||
|
// Ignore changes until we've started logging the session
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
if ((mainStagePosition != SPLIT_POSITION_UNDEFINED
|
||||||
|
&& sideStagePosition != SPLIT_POSITION_UNDEFINED)
|
||||||
|
|| (mainStageUid != 0 && sideStageUid != 0)) {
|
||||||
|
throw new IllegalArgumentException("Only main or side stage should be set");
|
||||||
|
}
|
||||||
|
FrameworkStatsLog.write(FrameworkStatsLog.SPLITSCREEN_UI_CHANGED,
|
||||||
|
FrameworkStatsLog.SPLITSCREEN_UICHANGED__ACTION__EXIT,
|
||||||
|
0 /* enterReason */,
|
||||||
|
exitReason,
|
||||||
|
0f /* splitRatio */,
|
||||||
|
getMainStagePositionFromSplitPosition(mainStagePosition, isLandscape),
|
||||||
|
mainStageUid,
|
||||||
|
getSideStagePositionFromSplitPosition(sideStagePosition, isLandscape),
|
||||||
|
sideStageUid,
|
||||||
|
0 /* dragInstanceId */,
|
||||||
|
mLoggerSessionId.getId());
|
||||||
|
|
||||||
|
// Reset states
|
||||||
|
mLoggerSessionId = null;
|
||||||
|
mDragEnterPosition = SPLIT_POSITION_UNDEFINED;
|
||||||
|
mDragEnterSessionId = null;
|
||||||
|
mLastMainStagePosition = -1;
|
||||||
|
mLastMainStageUid = -1;
|
||||||
|
mLastSideStagePosition = -1;
|
||||||
|
mLastSideStageUid = -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Logs when an app in the main stage changes.
|
||||||
|
*/
|
||||||
|
public void logMainStageAppChange(@SplitPosition int mainStagePosition, int mainStageUid,
|
||||||
|
boolean isLandscape) {
|
||||||
|
if (mLoggerSessionId == null) {
|
||||||
|
// Ignore changes until we've started logging the session
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
if (!updateMainStageState(getMainStagePositionFromSplitPosition(mainStagePosition,
|
||||||
|
isLandscape), mainStageUid)) {
|
||||||
|
// Ignore if there are no user perceived changes
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
FrameworkStatsLog.write(FrameworkStatsLog.SPLITSCREEN_UI_CHANGED,
|
||||||
|
FrameworkStatsLog.SPLITSCREEN_UICHANGED__ACTION__APP_CHANGE,
|
||||||
|
0 /* enterReason */,
|
||||||
|
0 /* exitReason */,
|
||||||
|
0f /* splitRatio */,
|
||||||
|
mLastMainStagePosition,
|
||||||
|
mLastMainStageUid,
|
||||||
|
0 /* sideStagePosition */,
|
||||||
|
0 /* sideStageUid */,
|
||||||
|
0 /* dragInstanceId */,
|
||||||
|
mLoggerSessionId.getId());
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Logs when an app in the side stage changes.
|
||||||
|
*/
|
||||||
|
public void logSideStageAppChange(@SplitPosition int sideStagePosition, int sideStageUid,
|
||||||
|
boolean isLandscape) {
|
||||||
|
if (mLoggerSessionId == null) {
|
||||||
|
// Ignore changes until we've started logging the session
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
if (!updateSideStageState(getSideStagePositionFromSplitPosition(sideStagePosition,
|
||||||
|
isLandscape), sideStageUid)) {
|
||||||
|
// Ignore if there are no user perceived changes
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
FrameworkStatsLog.write(FrameworkStatsLog.SPLITSCREEN_UI_CHANGED,
|
||||||
|
FrameworkStatsLog.SPLITSCREEN_UICHANGED__ACTION__APP_CHANGE,
|
||||||
|
0 /* enterReason */,
|
||||||
|
0 /* exitReason */,
|
||||||
|
0f /* splitRatio */,
|
||||||
|
0 /* mainStagePosition */,
|
||||||
|
0 /* mainStageUid */,
|
||||||
|
mLastSideStagePosition,
|
||||||
|
mLastSideStageUid,
|
||||||
|
0 /* dragInstanceId */,
|
||||||
|
mLoggerSessionId.getId());
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Logs when the splitscreen ratio changes.
|
||||||
|
*/
|
||||||
|
public void logResize(float splitRatio) {
|
||||||
|
if (mLoggerSessionId == null) {
|
||||||
|
// Ignore changes until we've started logging the session
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
if (splitRatio <= 0f || splitRatio >= 1f) {
|
||||||
|
// Don't bother reporting resizes that end up dismissing the split, that will be logged
|
||||||
|
// via the exit event
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
if (!updateSplitRatioState(splitRatio)) {
|
||||||
|
// Ignore if there are no user perceived changes
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
FrameworkStatsLog.write(FrameworkStatsLog.SPLITSCREEN_UI_CHANGED,
|
||||||
|
FrameworkStatsLog.SPLITSCREEN_UICHANGED__ACTION__RESIZE,
|
||||||
|
0 /* enterReason */,
|
||||||
|
0 /* exitReason */,
|
||||||
|
mLastSplitRatio,
|
||||||
|
0 /* mainStagePosition */, 0 /* mainStageUid */,
|
||||||
|
0 /* sideStagePosition */, 0 /* sideStageUid */,
|
||||||
|
0 /* dragInstanceId */,
|
||||||
|
mLoggerSessionId.getId());
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Logs when the apps in splitscreen are swapped.
|
||||||
|
*/
|
||||||
|
public void logSwap(@SplitPosition int mainStagePosition, int mainStageUid,
|
||||||
|
@SplitPosition int sideStagePosition, int sideStageUid, boolean isLandscape) {
|
||||||
|
if (mLoggerSessionId == null) {
|
||||||
|
// Ignore changes until we've started logging the session
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
updateMainStageState(getMainStagePositionFromSplitPosition(mainStagePosition, isLandscape),
|
||||||
|
mainStageUid);
|
||||||
|
updateSideStageState(getSideStagePositionFromSplitPosition(sideStagePosition, isLandscape),
|
||||||
|
sideStageUid);
|
||||||
|
FrameworkStatsLog.write(FrameworkStatsLog.SPLITSCREEN_UI_CHANGED,
|
||||||
|
FrameworkStatsLog.SPLITSCREEN_UICHANGED__ACTION__SWAP,
|
||||||
|
0 /* enterReason */,
|
||||||
|
0 /* exitReason */,
|
||||||
|
0f /* splitRatio */,
|
||||||
|
mLastMainStagePosition,
|
||||||
|
mLastMainStageUid,
|
||||||
|
mLastSideStagePosition,
|
||||||
|
mLastSideStageUid,
|
||||||
|
0 /* dragInstanceId */,
|
||||||
|
mLoggerSessionId.getId());
|
||||||
|
}
|
||||||
|
|
||||||
|
private boolean updateMainStageState(int mainStagePosition, int mainStageUid) {
|
||||||
|
boolean changed = (mLastMainStagePosition != mainStagePosition)
|
||||||
|
|| (mLastMainStageUid != mainStageUid);
|
||||||
|
if (!changed) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
mLastMainStagePosition = mainStagePosition;
|
||||||
|
mLastMainStageUid = mainStageUid;
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
private boolean updateSideStageState(int sideStagePosition, int sideStageUid) {
|
||||||
|
boolean changed = (mLastSideStagePosition != sideStagePosition)
|
||||||
|
|| (mLastSideStageUid != sideStageUid);
|
||||||
|
if (!changed) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
mLastSideStagePosition = sideStagePosition;
|
||||||
|
mLastSideStageUid = sideStageUid;
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
private boolean updateSplitRatioState(float splitRatio) {
|
||||||
|
boolean changed = Float.compare(mLastSplitRatio, splitRatio) != 0;
|
||||||
|
if (!changed) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
mLastSplitRatio = splitRatio;
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
public int getDragEnterReasonFromSplitPosition(@SplitPosition int position,
|
||||||
|
boolean isLandscape) {
|
||||||
|
if (isLandscape) {
|
||||||
|
return position == SPLIT_POSITION_TOP_OR_LEFT
|
||||||
|
? FrameworkStatsLog.SPLITSCREEN_UICHANGED__ENTER_REASON__DRAG_LEFT
|
||||||
|
: FrameworkStatsLog.SPLITSCREEN_UICHANGED__ENTER_REASON__DRAG_RIGHT;
|
||||||
|
} else {
|
||||||
|
return position == SPLIT_POSITION_TOP_OR_LEFT
|
||||||
|
? FrameworkStatsLog.SPLITSCREEN_UICHANGED__ENTER_REASON__DRAG_TOP
|
||||||
|
: FrameworkStatsLog.SPLITSCREEN_UICHANGED__ENTER_REASON__DRAG_BOTTOM;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private int getMainStagePositionFromSplitPosition(@SplitPosition int position,
|
||||||
|
boolean isLandscape) {
|
||||||
|
if (position == SPLIT_POSITION_UNDEFINED) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
if (isLandscape) {
|
||||||
|
return position == SPLIT_POSITION_TOP_OR_LEFT
|
||||||
|
? FrameworkStatsLog.SPLITSCREEN_UICHANGED__MAIN_STAGE_POSITION__LEFT
|
||||||
|
: FrameworkStatsLog.SPLITSCREEN_UICHANGED__MAIN_STAGE_POSITION__RIGHT;
|
||||||
|
} else {
|
||||||
|
return position == SPLIT_POSITION_TOP_OR_LEFT
|
||||||
|
? FrameworkStatsLog.SPLITSCREEN_UICHANGED__MAIN_STAGE_POSITION__TOP
|
||||||
|
: FrameworkStatsLog.SPLITSCREEN_UICHANGED__MAIN_STAGE_POSITION__BOTTOM;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private int getSideStagePositionFromSplitPosition(@SplitPosition int position,
|
||||||
|
boolean isLandscape) {
|
||||||
|
if (position == SPLIT_POSITION_UNDEFINED) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
if (isLandscape) {
|
||||||
|
return position == SPLIT_POSITION_TOP_OR_LEFT
|
||||||
|
? FrameworkStatsLog.SPLITSCREEN_UICHANGED__SIDE_STAGE_POSITION__LEFT
|
||||||
|
: FrameworkStatsLog.SPLITSCREEN_UICHANGED__SIDE_STAGE_POSITION__RIGHT;
|
||||||
|
} else {
|
||||||
|
return position == SPLIT_POSITION_TOP_OR_LEFT
|
||||||
|
? FrameworkStatsLog.SPLITSCREEN_UICHANGED__SIDE_STAGE_POSITION__TOP
|
||||||
|
: FrameworkStatsLog.SPLITSCREEN_UICHANGED__SIDE_STAGE_POSITION__BOTTOM;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,288 @@
|
|||||||
|
/*
|
||||||
|
* Copyright (C) 2020 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 com.android.wm.shell.stagesplit;
|
||||||
|
|
||||||
|
import static android.app.WindowConfiguration.ACTIVITY_TYPE_STANDARD;
|
||||||
|
import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;
|
||||||
|
import static android.app.WindowConfiguration.WINDOWING_MODE_MULTI_WINDOW;
|
||||||
|
import static android.app.WindowConfiguration.WINDOWING_MODE_UNDEFINED;
|
||||||
|
|
||||||
|
import static com.android.wm.shell.transition.Transitions.ENABLE_SHELL_TRANSITIONS;
|
||||||
|
|
||||||
|
import android.annotation.CallSuper;
|
||||||
|
import android.annotation.Nullable;
|
||||||
|
import android.app.ActivityManager;
|
||||||
|
import android.graphics.Point;
|
||||||
|
import android.graphics.Rect;
|
||||||
|
import android.util.SparseArray;
|
||||||
|
import android.view.SurfaceControl;
|
||||||
|
import android.view.SurfaceSession;
|
||||||
|
import android.window.WindowContainerTransaction;
|
||||||
|
|
||||||
|
import androidx.annotation.NonNull;
|
||||||
|
|
||||||
|
import com.android.wm.shell.ShellTaskOrganizer;
|
||||||
|
import com.android.wm.shell.common.SurfaceUtils;
|
||||||
|
import com.android.wm.shell.common.SyncTransactionQueue;
|
||||||
|
|
||||||
|
import java.io.PrintWriter;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Base class that handle common task org. related for split-screen stages.
|
||||||
|
* Note that this class and its sub-class do not directly perform hierarchy operations.
|
||||||
|
* They only serve to hold a collection of tasks and provide APIs like
|
||||||
|
* {@link #setBounds(Rect, WindowContainerTransaction)} for the centralized {@link StageCoordinator}
|
||||||
|
* to perform operations in-sync with other containers.
|
||||||
|
*
|
||||||
|
* @see StageCoordinator
|
||||||
|
*/
|
||||||
|
class StageTaskListener implements ShellTaskOrganizer.TaskListener {
|
||||||
|
private static final String TAG = StageTaskListener.class.getSimpleName();
|
||||||
|
|
||||||
|
protected static final int[] CONTROLLED_ACTIVITY_TYPES = {ACTIVITY_TYPE_STANDARD};
|
||||||
|
protected static final int[] CONTROLLED_WINDOWING_MODES =
|
||||||
|
{WINDOWING_MODE_FULLSCREEN, WINDOWING_MODE_UNDEFINED};
|
||||||
|
protected static final int[] CONTROLLED_WINDOWING_MODES_WHEN_ACTIVE =
|
||||||
|
{WINDOWING_MODE_FULLSCREEN, WINDOWING_MODE_UNDEFINED, WINDOWING_MODE_MULTI_WINDOW};
|
||||||
|
|
||||||
|
/** Callback interface for listening to changes in a split-screen stage. */
|
||||||
|
public interface StageListenerCallbacks {
|
||||||
|
void onRootTaskAppeared();
|
||||||
|
|
||||||
|
void onStatusChanged(boolean visible, boolean hasChildren);
|
||||||
|
|
||||||
|
void onChildTaskStatusChanged(int taskId, boolean present, boolean visible);
|
||||||
|
|
||||||
|
void onRootTaskVanished();
|
||||||
|
void onNoLongerSupportMultiWindow();
|
||||||
|
}
|
||||||
|
|
||||||
|
private final StageListenerCallbacks mCallbacks;
|
||||||
|
private final SurfaceSession mSurfaceSession;
|
||||||
|
protected final SyncTransactionQueue mSyncQueue;
|
||||||
|
|
||||||
|
protected ActivityManager.RunningTaskInfo mRootTaskInfo;
|
||||||
|
protected SurfaceControl mRootLeash;
|
||||||
|
protected SurfaceControl mDimLayer;
|
||||||
|
protected SparseArray<ActivityManager.RunningTaskInfo> mChildrenTaskInfo = new SparseArray<>();
|
||||||
|
private final SparseArray<SurfaceControl> mChildrenLeashes = new SparseArray<>();
|
||||||
|
|
||||||
|
private final StageTaskUnfoldController mStageTaskUnfoldController;
|
||||||
|
|
||||||
|
StageTaskListener(ShellTaskOrganizer taskOrganizer, int displayId,
|
||||||
|
StageListenerCallbacks callbacks, SyncTransactionQueue syncQueue,
|
||||||
|
SurfaceSession surfaceSession,
|
||||||
|
@Nullable StageTaskUnfoldController stageTaskUnfoldController) {
|
||||||
|
mCallbacks = callbacks;
|
||||||
|
mSyncQueue = syncQueue;
|
||||||
|
mSurfaceSession = surfaceSession;
|
||||||
|
mStageTaskUnfoldController = stageTaskUnfoldController;
|
||||||
|
taskOrganizer.createRootTask(displayId, WINDOWING_MODE_MULTI_WINDOW, this);
|
||||||
|
}
|
||||||
|
|
||||||
|
int getChildCount() {
|
||||||
|
return mChildrenTaskInfo.size();
|
||||||
|
}
|
||||||
|
|
||||||
|
boolean containsTask(int taskId) {
|
||||||
|
return mChildrenTaskInfo.contains(taskId);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Returns the top activity uid for the top child task.
|
||||||
|
*/
|
||||||
|
int getTopChildTaskUid() {
|
||||||
|
for (int i = mChildrenTaskInfo.size() - 1; i >= 0; --i) {
|
||||||
|
final ActivityManager.RunningTaskInfo info = mChildrenTaskInfo.valueAt(i);
|
||||||
|
if (info.topActivityInfo == null) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
return info.topActivityInfo.applicationInfo.uid;
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** @return {@code true} if this listener contains the currently focused task. */
|
||||||
|
boolean isFocused() {
|
||||||
|
if (mRootTaskInfo == null) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (mRootTaskInfo.isFocused) {
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (int i = mChildrenTaskInfo.size() - 1; i >= 0; --i) {
|
||||||
|
if (mChildrenTaskInfo.valueAt(i).isFocused) {
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
@CallSuper
|
||||||
|
public void onTaskAppeared(ActivityManager.RunningTaskInfo taskInfo, SurfaceControl leash) {
|
||||||
|
if (mRootTaskInfo == null && !taskInfo.hasParentTask()) {
|
||||||
|
mRootLeash = leash;
|
||||||
|
mRootTaskInfo = taskInfo;
|
||||||
|
mCallbacks.onRootTaskAppeared();
|
||||||
|
sendStatusChanged();
|
||||||
|
mSyncQueue.runInSync(t -> {
|
||||||
|
t.hide(mRootLeash);
|
||||||
|
mDimLayer =
|
||||||
|
SurfaceUtils.makeDimLayer(t, mRootLeash, "Dim layer", mSurfaceSession);
|
||||||
|
});
|
||||||
|
} else if (taskInfo.parentTaskId == mRootTaskInfo.taskId) {
|
||||||
|
final int taskId = taskInfo.taskId;
|
||||||
|
mChildrenLeashes.put(taskId, leash);
|
||||||
|
mChildrenTaskInfo.put(taskId, taskInfo);
|
||||||
|
updateChildTaskSurface(taskInfo, leash, true /* firstAppeared */);
|
||||||
|
mCallbacks.onChildTaskStatusChanged(taskId, true /* present */, taskInfo.isVisible);
|
||||||
|
if (ENABLE_SHELL_TRANSITIONS) {
|
||||||
|
// Status is managed/synchronized by the transition lifecycle.
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
sendStatusChanged();
|
||||||
|
} else {
|
||||||
|
throw new IllegalArgumentException(this + "\n Unknown task: " + taskInfo
|
||||||
|
+ "\n mRootTaskInfo: " + mRootTaskInfo);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (mStageTaskUnfoldController != null) {
|
||||||
|
mStageTaskUnfoldController.onTaskAppeared(taskInfo, leash);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
@CallSuper
|
||||||
|
public void onTaskInfoChanged(ActivityManager.RunningTaskInfo taskInfo) {
|
||||||
|
if (!taskInfo.supportsMultiWindow) {
|
||||||
|
// Leave split screen if the task no longer supports multi window.
|
||||||
|
mCallbacks.onNoLongerSupportMultiWindow();
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
if (mRootTaskInfo.taskId == taskInfo.taskId) {
|
||||||
|
mRootTaskInfo = taskInfo;
|
||||||
|
} else if (taskInfo.parentTaskId == mRootTaskInfo.taskId) {
|
||||||
|
mChildrenTaskInfo.put(taskInfo.taskId, taskInfo);
|
||||||
|
mCallbacks.onChildTaskStatusChanged(taskInfo.taskId, true /* present */,
|
||||||
|
taskInfo.isVisible);
|
||||||
|
if (!ENABLE_SHELL_TRANSITIONS) {
|
||||||
|
updateChildTaskSurface(
|
||||||
|
taskInfo, mChildrenLeashes.get(taskInfo.taskId), false /* firstAppeared */);
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
throw new IllegalArgumentException(this + "\n Unknown task: " + taskInfo
|
||||||
|
+ "\n mRootTaskInfo: " + mRootTaskInfo);
|
||||||
|
}
|
||||||
|
if (ENABLE_SHELL_TRANSITIONS) {
|
||||||
|
// Status is managed/synchronized by the transition lifecycle.
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
sendStatusChanged();
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
@CallSuper
|
||||||
|
public void onTaskVanished(ActivityManager.RunningTaskInfo taskInfo) {
|
||||||
|
final int taskId = taskInfo.taskId;
|
||||||
|
if (mRootTaskInfo.taskId == taskId) {
|
||||||
|
mCallbacks.onRootTaskVanished();
|
||||||
|
mSyncQueue.runInSync(t -> t.remove(mDimLayer));
|
||||||
|
mRootTaskInfo = null;
|
||||||
|
} else if (mChildrenTaskInfo.contains(taskId)) {
|
||||||
|
mChildrenTaskInfo.remove(taskId);
|
||||||
|
mChildrenLeashes.remove(taskId);
|
||||||
|
mCallbacks.onChildTaskStatusChanged(taskId, false /* present */, taskInfo.isVisible);
|
||||||
|
if (ENABLE_SHELL_TRANSITIONS) {
|
||||||
|
// Status is managed/synchronized by the transition lifecycle.
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
sendStatusChanged();
|
||||||
|
} else {
|
||||||
|
throw new IllegalArgumentException(this + "\n Unknown task: " + taskInfo
|
||||||
|
+ "\n mRootTaskInfo: " + mRootTaskInfo);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (mStageTaskUnfoldController != null) {
|
||||||
|
mStageTaskUnfoldController.onTaskVanished(taskInfo);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void attachChildSurfaceToTask(int taskId, SurfaceControl.Builder b) {
|
||||||
|
if (mRootTaskInfo.taskId == taskId) {
|
||||||
|
b.setParent(mRootLeash);
|
||||||
|
} else if (mChildrenLeashes.contains(taskId)) {
|
||||||
|
b.setParent(mChildrenLeashes.get(taskId));
|
||||||
|
} else {
|
||||||
|
throw new IllegalArgumentException("There is no surface for taskId=" + taskId);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void setBounds(Rect bounds, WindowContainerTransaction wct) {
|
||||||
|
wct.setBounds(mRootTaskInfo.token, bounds);
|
||||||
|
}
|
||||||
|
|
||||||
|
void reorderChild(int taskId, boolean onTop, WindowContainerTransaction wct) {
|
||||||
|
if (!containsTask(taskId)) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
wct.reorder(mChildrenTaskInfo.get(taskId).token, onTop /* onTop */);
|
||||||
|
}
|
||||||
|
|
||||||
|
void setVisibility(boolean visible, WindowContainerTransaction wct) {
|
||||||
|
wct.reorder(mRootTaskInfo.token, visible /* onTop */);
|
||||||
|
}
|
||||||
|
|
||||||
|
void onSplitScreenListenerRegistered(SplitScreen.SplitScreenListener listener,
|
||||||
|
@SplitScreen.StageType int stage) {
|
||||||
|
for (int i = mChildrenTaskInfo.size() - 1; i >= 0; --i) {
|
||||||
|
int taskId = mChildrenTaskInfo.keyAt(i);
|
||||||
|
listener.onTaskStageChanged(taskId, stage,
|
||||||
|
mChildrenTaskInfo.get(taskId).isVisible);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private void updateChildTaskSurface(ActivityManager.RunningTaskInfo taskInfo,
|
||||||
|
SurfaceControl leash, boolean firstAppeared) {
|
||||||
|
final Point taskPositionInParent = taskInfo.positionInParent;
|
||||||
|
mSyncQueue.runInSync(t -> {
|
||||||
|
t.setWindowCrop(leash, null);
|
||||||
|
t.setPosition(leash, taskPositionInParent.x, taskPositionInParent.y);
|
||||||
|
if (firstAppeared && !ENABLE_SHELL_TRANSITIONS) {
|
||||||
|
t.setAlpha(leash, 1f);
|
||||||
|
t.setMatrix(leash, 1, 0, 0, 1);
|
||||||
|
t.show(leash);
|
||||||
|
}
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
private void sendStatusChanged() {
|
||||||
|
mCallbacks.onStatusChanged(mRootTaskInfo.isVisible, mChildrenTaskInfo.size() > 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
@CallSuper
|
||||||
|
public void dump(@NonNull PrintWriter pw, String prefix) {
|
||||||
|
final String innerPrefix = prefix + " ";
|
||||||
|
final String childPrefix = innerPrefix + " ";
|
||||||
|
pw.println(prefix + this);
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,224 @@
|
|||||||
|
/*
|
||||||
|
* Copyright (C) 2021 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 com.android.wm.shell.stagesplit;
|
||||||
|
|
||||||
|
import static android.view.Display.DEFAULT_DISPLAY;
|
||||||
|
|
||||||
|
import android.animation.RectEvaluator;
|
||||||
|
import android.animation.TypeEvaluator;
|
||||||
|
import android.annotation.NonNull;
|
||||||
|
import android.app.ActivityManager;
|
||||||
|
import android.content.Context;
|
||||||
|
import android.graphics.Rect;
|
||||||
|
import android.util.SparseArray;
|
||||||
|
import android.view.InsetsSource;
|
||||||
|
import android.view.InsetsState;
|
||||||
|
import android.view.SurfaceControl;
|
||||||
|
|
||||||
|
import com.android.internal.policy.ScreenDecorationsUtils;
|
||||||
|
import com.android.wm.shell.common.DisplayInsetsController;
|
||||||
|
import com.android.wm.shell.common.DisplayInsetsController.OnInsetsChangedListener;
|
||||||
|
import com.android.wm.shell.common.TransactionPool;
|
||||||
|
import com.android.wm.shell.unfold.ShellUnfoldProgressProvider;
|
||||||
|
import com.android.wm.shell.unfold.ShellUnfoldProgressProvider.UnfoldListener;
|
||||||
|
import com.android.wm.shell.unfold.UnfoldBackgroundController;
|
||||||
|
|
||||||
|
import java.util.concurrent.Executor;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Controls transformations of the split screen task surfaces in response
|
||||||
|
* to the unfolding/folding action on foldable devices
|
||||||
|
*/
|
||||||
|
public class StageTaskUnfoldController implements UnfoldListener, OnInsetsChangedListener {
|
||||||
|
|
||||||
|
private static final TypeEvaluator<Rect> RECT_EVALUATOR = new RectEvaluator(new Rect());
|
||||||
|
private static final float CROPPING_START_MARGIN_FRACTION = 0.05f;
|
||||||
|
|
||||||
|
private final SparseArray<AnimationContext> mAnimationContextByTaskId = new SparseArray<>();
|
||||||
|
private final ShellUnfoldProgressProvider mUnfoldProgressProvider;
|
||||||
|
private final DisplayInsetsController mDisplayInsetsController;
|
||||||
|
private final UnfoldBackgroundController mBackgroundController;
|
||||||
|
private final Executor mExecutor;
|
||||||
|
private final int mExpandedTaskBarHeight;
|
||||||
|
private final float mWindowCornerRadiusPx;
|
||||||
|
private final Rect mStageBounds = new Rect();
|
||||||
|
private final TransactionPool mTransactionPool;
|
||||||
|
|
||||||
|
private InsetsSource mTaskbarInsetsSource;
|
||||||
|
private boolean mBothStagesVisible;
|
||||||
|
|
||||||
|
public StageTaskUnfoldController(@NonNull Context context,
|
||||||
|
@NonNull TransactionPool transactionPool,
|
||||||
|
@NonNull ShellUnfoldProgressProvider unfoldProgressProvider,
|
||||||
|
@NonNull DisplayInsetsController displayInsetsController,
|
||||||
|
@NonNull UnfoldBackgroundController backgroundController,
|
||||||
|
@NonNull Executor executor) {
|
||||||
|
mUnfoldProgressProvider = unfoldProgressProvider;
|
||||||
|
mTransactionPool = transactionPool;
|
||||||
|
mExecutor = executor;
|
||||||
|
mBackgroundController = backgroundController;
|
||||||
|
mDisplayInsetsController = displayInsetsController;
|
||||||
|
mWindowCornerRadiusPx = ScreenDecorationsUtils.getWindowCornerRadius(context);
|
||||||
|
mExpandedTaskBarHeight = context.getResources().getDimensionPixelSize(
|
||||||
|
com.android.internal.R.dimen.taskbar_frame_height);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Initializes the controller, starts listening for the external events
|
||||||
|
*/
|
||||||
|
public void init() {
|
||||||
|
mUnfoldProgressProvider.addListener(mExecutor, this);
|
||||||
|
mDisplayInsetsController.addInsetsChangedListener(DEFAULT_DISPLAY, this);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void insetsChanged(InsetsState insetsState) {
|
||||||
|
mTaskbarInsetsSource = insetsState.getSource(InsetsState.ITYPE_EXTRA_NAVIGATION_BAR);
|
||||||
|
for (int i = mAnimationContextByTaskId.size() - 1; i >= 0; i--) {
|
||||||
|
AnimationContext context = mAnimationContextByTaskId.valueAt(i);
|
||||||
|
context.update();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Called when split screen task appeared
|
||||||
|
* @param taskInfo info for the appeared task
|
||||||
|
* @param leash surface leash for the appeared task
|
||||||
|
*/
|
||||||
|
public void onTaskAppeared(ActivityManager.RunningTaskInfo taskInfo, SurfaceControl leash) {
|
||||||
|
AnimationContext context = new AnimationContext(leash);
|
||||||
|
mAnimationContextByTaskId.put(taskInfo.taskId, context);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Called when a split screen task vanished
|
||||||
|
* @param taskInfo info for the vanished task
|
||||||
|
*/
|
||||||
|
public void onTaskVanished(ActivityManager.RunningTaskInfo taskInfo) {
|
||||||
|
AnimationContext context = mAnimationContextByTaskId.get(taskInfo.taskId);
|
||||||
|
if (context != null) {
|
||||||
|
final SurfaceControl.Transaction transaction = mTransactionPool.acquire();
|
||||||
|
resetSurface(transaction, context);
|
||||||
|
transaction.apply();
|
||||||
|
mTransactionPool.release(transaction);
|
||||||
|
}
|
||||||
|
mAnimationContextByTaskId.remove(taskInfo.taskId);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void onStateChangeProgress(float progress) {
|
||||||
|
if (mAnimationContextByTaskId.size() == 0 || !mBothStagesVisible) return;
|
||||||
|
|
||||||
|
final SurfaceControl.Transaction transaction = mTransactionPool.acquire();
|
||||||
|
mBackgroundController.ensureBackground(transaction);
|
||||||
|
|
||||||
|
for (int i = mAnimationContextByTaskId.size() - 1; i >= 0; i--) {
|
||||||
|
AnimationContext context = mAnimationContextByTaskId.valueAt(i);
|
||||||
|
|
||||||
|
context.mCurrentCropRect.set(RECT_EVALUATOR
|
||||||
|
.evaluate(progress, context.mStartCropRect, context.mEndCropRect));
|
||||||
|
|
||||||
|
transaction.setWindowCrop(context.mLeash, context.mCurrentCropRect)
|
||||||
|
.setCornerRadius(context.mLeash, mWindowCornerRadiusPx);
|
||||||
|
}
|
||||||
|
|
||||||
|
transaction.apply();
|
||||||
|
|
||||||
|
mTransactionPool.release(transaction);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void onStateChangeFinished() {
|
||||||
|
resetTransformations();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Called when split screen visibility changes
|
||||||
|
* @param bothStagesVisible true if both stages of the split screen are visible
|
||||||
|
*/
|
||||||
|
public void onSplitVisibilityChanged(boolean bothStagesVisible) {
|
||||||
|
mBothStagesVisible = bothStagesVisible;
|
||||||
|
if (!bothStagesVisible) {
|
||||||
|
resetTransformations();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Called when split screen stage bounds changed
|
||||||
|
* @param bounds new bounds for this stage
|
||||||
|
*/
|
||||||
|
public void onLayoutChanged(Rect bounds) {
|
||||||
|
mStageBounds.set(bounds);
|
||||||
|
|
||||||
|
for (int i = mAnimationContextByTaskId.size() - 1; i >= 0; i--) {
|
||||||
|
final AnimationContext context = mAnimationContextByTaskId.valueAt(i);
|
||||||
|
context.update();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private void resetTransformations() {
|
||||||
|
final SurfaceControl.Transaction transaction = mTransactionPool.acquire();
|
||||||
|
|
||||||
|
for (int i = mAnimationContextByTaskId.size() - 1; i >= 0; i--) {
|
||||||
|
final AnimationContext context = mAnimationContextByTaskId.valueAt(i);
|
||||||
|
resetSurface(transaction, context);
|
||||||
|
}
|
||||||
|
mBackgroundController.removeBackground(transaction);
|
||||||
|
transaction.apply();
|
||||||
|
|
||||||
|
mTransactionPool.release(transaction);
|
||||||
|
}
|
||||||
|
|
||||||
|
private void resetSurface(SurfaceControl.Transaction transaction, AnimationContext context) {
|
||||||
|
transaction
|
||||||
|
.setWindowCrop(context.mLeash, null)
|
||||||
|
.setCornerRadius(context.mLeash, 0.0F);
|
||||||
|
}
|
||||||
|
|
||||||
|
private class AnimationContext {
|
||||||
|
final SurfaceControl mLeash;
|
||||||
|
final Rect mStartCropRect = new Rect();
|
||||||
|
final Rect mEndCropRect = new Rect();
|
||||||
|
final Rect mCurrentCropRect = new Rect();
|
||||||
|
|
||||||
|
private AnimationContext(SurfaceControl leash) {
|
||||||
|
this.mLeash = leash;
|
||||||
|
update();
|
||||||
|
}
|
||||||
|
|
||||||
|
private void update() {
|
||||||
|
mStartCropRect.set(mStageBounds);
|
||||||
|
|
||||||
|
if (mTaskbarInsetsSource != null) {
|
||||||
|
// Only insets the cropping window with taskbar when taskbar is expanded
|
||||||
|
if (mTaskbarInsetsSource.getFrame().height() >= mExpandedTaskBarHeight) {
|
||||||
|
mStartCropRect.inset(mTaskbarInsetsSource
|
||||||
|
.calculateVisibleInsets(mStartCropRect));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Offset to surface coordinates as layout bounds are in screen coordinates
|
||||||
|
mStartCropRect.offsetTo(0, 0);
|
||||||
|
|
||||||
|
mEndCropRect.set(mStartCropRect);
|
||||||
|
|
||||||
|
int maxSize = Math.max(mEndCropRect.width(), mEndCropRect.height());
|
||||||
|
int margin = (int) (maxSize * CROPPING_START_MARGIN_FRACTION);
|
||||||
|
mStartCropRect.inset(margin, margin, margin, margin);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
Reference in New Issue
Block a user