Android U 分屏——SystemUI侧处理

WMShell相关的dump命令

手机分屏启动应用后运行命令：adb shell dumpsys activity service SystemUIService WMShell
我们可以找到其中分屏的部分，如下图所示：
在这里插入图片描述

分屏的组成

简图

分屏是由上分屏(SideStage)、下分屏(MainStage)以及分割线组成。这里我们主要关注分屏的Stage部分，如下图所示：
在这里插入图片描述
我们这里上分屏是电话，下分屏是短信。
通过adb shell dumpsys activity containers命令可以看层级结构，这里我们看看上下分屏指的是什么在这里插入图片描述
这里Task=331其实就是分屏的RootTask，通过wct.reorder(mRootTaskInfo.token, true);(在system_server进程中)设置的，使其显示到最前面。其下面挂着Task=332(MainStage，下分屏)和Task=333(SideStage，上分屏)，这段代码也就是为了把这两个task下面挂上对应应用的task，即Task=333(SideStage，上分屏)下面挂着应用task=335(电话Task)，Task=332(MainStage，下分屏)下面挂着应用task=334(短信Task)
总之，我们需要分清楚分屏的task和应用的task，不要弄混淆。

注：在android T(13) 中，上分屏为MainStage，下分屏为SideStage

stage的创建

在StageCoordinator构造方法中创建了MainStage和SideStage。
代码路径：frameworks/base/libs/WindowManager/Shell/src/com/android/wm/shell/splitscreen/StageCoordinator.java

protected StageCoordinator(Context context, int displayId, SyncTransactionQueue syncQueue,
            ShellTaskOrganizer taskOrganizer, DisplayController displayController,
            DisplayImeController displayImeController,
            DisplayInsetsController displayInsetsController, Transitions transitions,
            TransactionPool transactionPool,
            IconProvider iconProvider, ShellExecutor mainExecutor,
            Optional<RecentTasksController> recentTasks) {
        ......
        mMainStage = new MainStage(
                mContext,
                mTaskOrganizer,
                mDisplayId,
                mMainStageListener,
                mSyncQueue,
                mSurfaceSession,
                iconProvider);
        mSideStage = new SideStage(
                mContext,
                mTaskOrganizer,
                mDisplayId,
                mSideStageListener,
                mSyncQueue,
                mSurfaceSession,
                iconProvider);
        ......
}

MainStage
代码路径：frameworks/base/libs/WindowManager/Shell/src/com/android/wm/shell/splitscreen/MainStage.java

class MainStage extends StageTaskListener {
    ......
    MainStage(Context context, ShellTaskOrganizer taskOrganizer, int displayId,
            StageListenerCallbacks callbacks, SyncTransactionQueue syncQueue,
            SurfaceSession surfaceSession, IconProvider iconProvider) {
        super(context, taskOrganizer, displayId, callbacks, syncQueue, surfaceSession,
                iconProvider);
    }

SideStage
代码路径：frameworks/base/libs/WindowManager/Shell/src/com/android/wm/shell/splitscreen/SideStage.java

class SideStage extends StageTaskListener {
    ......
    SideStage(Context context, ShellTaskOrganizer taskOrganizer, int displayId,
            StageListenerCallbacks callbacks, SyncTransactionQueue syncQueue,
            SurfaceSession surfaceSession, IconProvider iconProvider) {
        super(context, taskOrganizer, displayId, callbacks, syncQueue, surfaceSession,
                iconProvider);
    }

这里我们可以看到MainStage和SideStage的构造方法都调用其父类构造方法，而他们的父类都是StageTaskListener，所以我们只需要关注StageTaskListener构造方法即可。
代码路径：frameworks/base/libs/WindowManager/Shell/src/com/android/wm/shell/splitscreen/StageTaskListener.java

    StageTaskListener(Context context, ShellTaskOrganizer taskOrganizer, int displayId,
            StageListenerCallbacks callbacks, SyncTransactionQueue syncQueue,
            SurfaceSession surfaceSession, IconProvider iconProvider) {
        mContext = context;
        mCallbacks = callbacks;
        mSyncQueue = syncQueue;
        mSurfaceSession = surfaceSession;
        mIconProvider = iconProvider;
        taskOrganizer.createRootTask(displayId, WINDOWING_MODE_MULTI_WINDOW, this);
    }

这里我们可以看到最关键的创建方法就是createRootTask，传递了当前Display（displayId）、当前窗口模式（WINDOWING_MODE_MULTI_WINDOW）和当前Stage（this）。
代码路径：frameworks/base/libs/WindowManager/Shell/src/com/android/wm/shell/ShellTaskOrganizer.java

    /**
     * Creates a persistent root task in WM for a particular windowing-mode.
     * @param displayId The display to create the root task on.
     * @param windowingMode Windowing mode to put the root task in.
     * @param listener The listener to get the created task callback.
     */
    public void createRootTask(int displayId, int windowingMode, TaskListener listener) {
        createRootTask(displayId, windowingMode, listener, false /* removeWithTaskOrganizer */);
    }

    /**
     * Creates a persistent root task in WM for a particular windowing-mode.
     * @param displayId The display to create the root task on.
     * @param windowingMode Windowing mode to put the root task in.
     * @param listener The listener to get the created task callback.
     * @param removeWithTaskOrganizer True if this task should be removed when organizer destroyed.
     */
    public void createRootTask(int displayId, int windowingMode, TaskListener listener,
            boolean removeWithTaskOrganizer) {
        ProtoLog.v(WM_SHELL_TASK_ORG, "createRootTask() displayId=%d winMode=%d listener=%s" ,
                displayId, windowingMode, listener.toString());
        final IBinder cookie = new Binder();
        setPendingLaunchCookieListener(cookie, listener);
        super.createRootTask(displayId, windowingMode, cookie, removeWithTaskOrganizer);
    }

设置了removeWithTaskOrganizer参数为false，继续传递参数调用到其父类TaskOrganizer的createRootTask方法
代码路径：frameworks/base/core/java/android/window/TaskOrganizer.java

    /**
     * Creates a persistent root task in WM for a particular windowing-mode.
     * @param displayId The display to create the root task on.
     * @param windowingMode Windowing mode to put the root task in.
     * @param launchCookie Launch cookie to associate with the task so that is can be identified
     *                     when the {@link ITaskOrganizer#onTaskAppeared} callback is called.
     * @param removeWithTaskOrganizer True if this task should be removed when organizer destroyed.
     * @hide
     */
    @RequiresPermission(android.Manifest.permission.MANAGE_ACTIVITY_TASKS)
    public void createRootTask(int displayId, int windowingMode, @Nullable IBinder launchCookie,
            boolean removeWithTaskOrganizer) {
        try {
            mTaskOrganizerController.createRootTask(displayId, windowingMode, launchCookie,
                    removeWithTaskOrganizer);
        } catch (RemoteException e) {
            throw e.rethrowFromSystemServer();
        }
    }

这里mTaskOrganizerController是ITaskOrganizerController对象，通过跨进程到system_server侧创建Task，其实现方法在TaskOrganizerController中。
代码路径：frameworks/base/services/core/java/com/android/server/wm/TaskOrganizerController.java

    @Override
    public void createRootTask(int displayId, int windowingMode, @Nullable IBinder launchCookie,
            boolean removeWithTaskOrganizer) {
        enforceTaskPermission("createRootTask()");
        final long origId = Binder.clearCallingIdentity();
        try {
            synchronized (mGlobalLock) {
                //获取当前DisplayContent
                DisplayContent display = mService.mRootWindowContainer.getDisplayContent(displayId);
                if (display == null) {
                    ProtoLog.e(WM_DEBUG_WINDOW_ORGANIZER,
                            "createRootTask unknown displayId=%d", displayId);
                    return;
                }

                createRootTask(display, windowingMode, launchCookie, removeWithTaskOrganizer);
            }
        } finally {
            Binder.restoreCallingIdentity(origId);
        }
    }

    @VisibleForTesting
    Task createRootTask(DisplayContent display, int windowingMode, @Nullable IBinder launchCookie) {
        return createRootTask(display, windowingMode, launchCookie,
                false /* removeWithTaskOrganizer */);
    }

    Task createRootTask(DisplayContent display, int windowingMode, @Nullable IBinder launchCookie,
            boolean removeWithTaskOrganizer) {
        ProtoLog.v(WM_DEBUG_WINDOW_ORGANIZER, "Create root task displayId=%d winMode=%d",
                display.mDisplayId, windowingMode);
        // We want to defer the task appear signal until the task is fully created and attached to
        // to the hierarchy so that the complete starting configuration is in the task info we send
        // over to the organizer.
        //创建Task
        final Task task = new Task.Builder(mService)
                .setWindowingMode(windowingMode)
                .setIntent(new Intent())
                .setCreatedByOrganizer(true)
                .setDeferTaskAppear(true)
                .setLaunchCookie(launchCookie)
                .setParent(display.getDefaultTaskDisplayArea())
                .setRemoveWithTaskOrganizer(removeWithTaskOrganizer)
                .build();
        task.setDeferTaskAppear(false /* deferTaskAppear */);
        return task;
    }

这个方法很简单，就是获取了当前DisplayContent，然后创建了Task。这里还设置setCreatedByOrganizer(true)，表示是通过TaskOrganizer的方式创建的。

分屏流程中的关键方法

设置分屏task

以前面设置分屏task方法为例

        //设置分屏Options
        addActivityOptions(options1, mSideStage);
        //添加启动分屏task（system_server进程）
        wct.startTask(taskId1, options1);

mSideStage为SideStage对象，MainStage和SideStage，他们都是继承StageTaskListener。
并且其后会调用WindowContainerTransaction的startTask方法启动分屏的task，这里是在system_server进程中进行的。

设置分屏Options

代码路径：frameworks/base/libs/WindowManager/Shell/src/com/android/wm/shell/splitscreen/StageCoordinator.java

    private void addActivityOptions(Bundle opts, @Nullable StageTaskListener launchTarget) {
        if (launchTarget != null) {
            //设置sideStage的WindowContainerToken，也就是上分屏的task的token
            //设置mainStage的WindowContainerToken，也就是下分屏的task的token
            opts.putParcelable(KEY_LAUNCH_ROOT_TASK_TOKEN, launchTarget.mRootTaskInfo.token);
        }
        // Put BAL flags to avoid activity start aborted. Otherwise, flows like shortcut to split
        // will be canceled.
        //允许其使用pendingInetent方式启动
        opts.putBoolean(KEY_PENDING_INTENT_BACKGROUND_ACTIVITY_ALLOWED, true);
        opts.putBoolean(KEY_PENDING_INTENT_BACKGROUND_ACTIVITY_ALLOWED_BY_PERMISSION, true);
    }

launchTarget.mRootTaskInfo.token是WindowContainerToken对象，这里就是设置上分屏的task的token（sideStage的WindowContainerToken）到传递进来的Bundle对象中。

后续在system_server侧会通过ActivityOptions构造方法设置sideStage的WindowContainerToken。
代码路径：frameworks/base/core/java/android/app/ActivityOptions.java

    public ActivityOptions(Bundle opts) {
        super(opts);
        ......
        mLaunchRootTask = opts.getParcelable(KEY_LAUNCH_ROOT_TASK_TOKEN, android.window.WindowContainerToken.class);
        ......
    }

在ActivityOptions构造方法中，会取出之前存放的WindowContainerToken对象赋值给mLaunchRootTask。
即把sideStage的WindowContainerToken设置为mLaunchRootTask，mainStage也是同理。

添加启动分屏应用task（system_server进程）

代码路径：frameworks/base/core/java/android/window/WindowContainerTransaction.java

    /**
     * Starts a task by id. The task is expected to already exist (eg. as a recent task).
     * @param taskId Id of task to start.
     * @param options bundle containing ActivityOptions for the task's top activity.
     * @hide
     */
    @NonNull
    public WindowContainerTransaction startTask(int taskId, @Nullable Bundle options) {
        mHierarchyOps.add(HierarchyOp.createForTaskLaunch(taskId, options));
        return this;
    }

通过应用taskId来启动应用task，此时只是将该应用task以及之前设置的options设置到层级结构树中，尚未提交事务，真正的添加在后续通过SplitTransitions.startEnterTransition（涉及RemoteTransition的情况，我们这里从多任务启动分屏就是这种情况）或者SyncTransactionQueue（涉及RemoteAnimationAdapter的情况）提交事务到系统侧才会真正的启动。

设置分屏位置

setSideStagePosition(splitPosition, wct);
代码路径：frameworks/base/libs/WindowManager/Shell/src/com/android/wm/shell/splitscreen/StageCoordinator.java

    void setSideStagePosition(@SplitPosition int sideStagePosition,
            @Nullable WindowContainerTransaction wct) {
        //传递参数updateBounds为true
        setSideStagePosition(sideStagePosition, true /* updateBounds */, wct);
    }

    private void setSideStagePosition(@SplitPosition int sideStagePosition, boolean updateBounds,
            @Nullable WindowContainerTransaction wct) {
        //mSideStagePosition默认为SPLIT_POSITION_BOTTOM_OR_RIGHT，下分屏位置
        //mSideStagePosition与传递过来的sideStagePosition相同，则不修改
        if (mSideStagePosition == sideStagePosition) return;
        //不同时，将mSideStagePosition赋值为传递过来的sideStagePosition
        mSideStagePosition = sideStagePosition;
        sendOnStagePositionChanged();
        //mSideStageListener.mVisible判断分屏的可见性
        //updateBounds传递了true
        if (mSideStageListener.mVisible && updateBounds) {
            if (wct == null) {
                // onLayoutChanged builds/applies a wct with the contents of updateWindowBounds.
                //如果WindowContainerTransaction为空(这里一般不为空)
                //这个方法会创建一个WindowContainerTransaction对象
                //然后再调用updateWindowBounds方法
                onLayoutSizeChanged(mSplitLayout);
            } else {
                //更新窗口bounds，后续会讲
                updateWindowBounds(mSplitLayout, wct);
                //没有实际意义
                sendOnBoundsChanged();
            }
        }
    }

mSideStagePosition

这个方法主要就是SideStage的分屏位置进行设置

private int mSideStagePosition = SPLIT_POSITION_BOTTOM_OR_RIGHT;

其中mSideStagePosition从代码中可以发现默认值为SPLIT_POSITION_BOTTOM_OR_RIGHT，即值为1

之前桌面流程中传递过来的值是0，即sideStagePosition值为0，在上分屏显示。

mSideStageListener.mVisible分屏可见性

  1. 多任务中进入分屏时，会在shell动画流程中最后调用StageCoordinator.finishEnterSplitScreen去调用StageCoordinator.setSplitsVisible设置分屏可见性为true。
  2. HOME键退出分屏时，会在远程动画流程中（涉及APP的切换）最后调用通过StageCoordinator.onRecentsInSplitAnimationFinish去调用StageCoordinator.setSplitsVisible设置分屏可见性为false。
  3. 返回键退出分屏时，会在shell动画流程中最后调用StageCoordinator.prepareDismissAnimation去调用StageCoordinator.setSplitsVisible设置分屏可见性为false。

不管是哪种方式，最终都会通过StageCoordinator.setSplitsVisible设置分屏可见性。

onLayoutSizeChanged(mSplitLayout);

在多任务启动分屏流程中，WindowContainerTransaction对象不会为空，因此不会走到该流程。
这个方法主要是创建一个WindowContainerTransaction对象，并调用updateWindowBounds方法更新bounds，在没有更新bounds的情况下清除一些状态。
具体见分屏分割线相关 (留坑，尚未更新)

updateWindowBounds(mSplitLayout, wct);

见后文【更新分屏task的bound】

sendOnBoundsChanged();

这个方法本地验证注释过，没有发现什么影响。这里把这段代码上库时的注释放出来，仅供参考。

Adds real unfold animation for split-screen tasks when
doing the Shell unfold transition.
The approach is similar to full-screen tasks:
we animate the surfaces using shell transition
only when unfolding, when folding we are doing
it in the old way (by directly accessing
the surfaces from TaskOrganizer).

Refactored the previous fullscreen/splitscreen unfold
controllers flow to have one controller where we can
register diferrent 'animators'. This controller listens
to all task events in the shell task organizer.

简单分析下这个方法：

    private void sendOnBoundsChanged() {
        if (mSplitLayout == null) return;
        for (int i = mListeners.size() - 1; i >= 0; --i) {
            mListeners.get(i).onSplitBoundsChanged(mSplitLayout.getRootBounds(),
                    getMainStageBounds(), getSideStageBounds());
        }
    }

从这个方法中我们可以看到，主要就是调用了onSplitBoundsChanged。

	@ExternalThread
	public interface SplitScreen {
	    ......
	    interface SplitScreenListener {
	        default void onStagePositionChanged(@StageType int stage, @SplitPosition int position) {}
	        default void onTaskStageChanged(int taskId, @StageType int stage, boolean visible) {}
	        default void onSplitBoundsChanged(Rect rootBounds, Rect mainBounds, Rect sideBounds) {}
	        default void onSplitVisibilityChanged(boolean visible) {}
	    }
	    ......
	}

onSplitBoundsChanged是SplitScreen.SplitScreenListener的接口方法，需要找到其实现在哪。
因此先来看看前面的mListeners里面存放是什么

	private final List<SplitScreen.SplitScreenListener> mListeners = new ArrayList<>();

	void registerSplitScreenListener(SplitScreen.SplitScreenListener listener) {
        if (mListeners.contains(listener)) return;
        mListeners.add(listener);
        sendStatusToListener(listener);
    }

存放的是注册的SplitScreen.SplitScreenListener对象，这里添加的listener指的就是ISplitScreenImpl中创建的对象，我们找到其中创建的对象。

    private static class ISplitScreenImpl extends ISplitScreen.Stub
            implements ExternalInterfaceBinder {
        private SplitScreenController mController;
        private final SingleInstanceRemoteListener<SplitScreenController,
                ISplitScreenListener> mListener;
        private final SplitScreen.SplitScreenListener mSplitScreenListener =
                new SplitScreen.SplitScreenListener() {
                    @Override
                    public void onStagePositionChanged(int stage, int position) {
                        mListener.call(l -> l.onStagePositionChanged(stage, position));
                    }

                    @Override
                    public void onTaskStageChanged(int taskId, int stage, boolean visible) {
                        mListener.call(l -> l.onTaskStageChanged(taskId, stage, visible));
                    }
                };

        public ISplitScreenImpl(SplitScreenController controller) {
            mController = controller;
            mListener = new SingleInstanceRemoteListener<>(controller,
                    c -> c.registerSplitScreenListener(mSplitScreenListener),
                    c -> c.unregisterSplitScreenListener(mSplitScreenListener));
        }

        ......

        @Override
        public void registerSplitScreenListener(ISplitScreenListener listener) {
            executeRemoteCallWithTaskPermission(mController, "registerSplitScreenListener",
                    (controller) -> mListener.register(listener));
        }
        ......
}

这里(controller) -> mListener.register(listener));实际上就是调用的c -> c.registerSplitScreenListener(mSplitScreenListener)。
也就是说在registerSplitScreenListener的实现中mListeners.add(listener);，其中的listener指的就是这里的mSplitScreenListener。
但是我们可以看到mSplitScreenListener中并没有实现接口中的onSplitBoundsChanged方法，因此什么都没有做。
且本地验证SplitScreen接口中其他的实现也没有在设置分屏位置场景调用，感兴趣的可以研究补充。
具体流程不在赘述，附registerSplitScreenListener调用堆栈流程

registerSplitScreenListener: listener:com.android.wm.shell.splitscreen.SplitScreenController$ISplitScreenImpl$1@ef57f97
registerSplitScreenListener: java.lang.Exception
registerSplitScreenListener: 	at com.android.wm.shell.splitscreen.StageCoordinator.registerSplitScreenListener(go/retraceme e9084556ee5ba06aeb29383d2803776323e77195400e5ee36c8cd4861c083ef6:1662)
registerSplitScreenListener: 	at com.android.wm.shell.splitscreen.SplitScreenController.registerSplitScreenListener(go/retraceme e9084556ee5ba06aeb29383d2803776323e77195400e5ee36c8cd4861c083ef6:451)
registerSplitScreenListener: 	at com.android.wm.shell.splitscreen.SplitScreenController$ISplitScreenImpl.lambda$new$0(go/retraceme e9084556ee5ba06aeb29383d2803776323e77195400e5ee36c8cd4861c083ef6:1074)
registerSplitScreenListener: 	at com.android.wm.shell.splitscreen.SplitScreenController$ISplitScreenImpl.$r8$lambda$LTc1wMcZo9Of3RPyGCWtg6YiS5s(go/retraceme e9084556ee5ba06aeb29383d2803776323e77195400e5ee36c8cd4861c083ef6:0)
registerSplitScreenListener: 	at com.android.wm.shell.splitscreen.SplitScreenController$ISplitScreenImpl$$ExternalSyntheticLambda15.accept(go/retraceme e9084556ee5ba06aeb29383d2803776323e77195400e5ee36c8cd4861c083ef6:0)
registerSplitScreenListener: 	at com.android.wm.shell.common.SingleInstanceRemoteListener.register(go/retraceme e9084556ee5ba06aeb29383d2803776323e77195400e5ee36c8cd4861c083ef6:97)
registerSplitScreenListener: 	at com.android.wm.shell.splitscreen.SplitScreenController$ISplitScreenImpl.lambda$registerSplitScreenListener$2(go/retraceme e9084556ee5ba06aeb29383d2803776323e77195400e5ee36c8cd4861c083ef6:1091)
registerSplitScreenListener: 	at com.android.wm.shell.splitscreen.SplitScreenController$ISplitScreenImpl.$r8$lambda$3asGbaEmeTX8SI0BiI_eYjbgpQA(go/retraceme e9084556ee5ba06aeb29383d2803776323e77195400e5ee36c8cd4861c083ef6:0)
registerSplitScreenListener: 	at com.android.wm.shell.splitscreen.SplitScreenController$ISplitScreenImpl$$ExternalSyntheticLambda11.accept(go/retraceme e9084556ee5ba06aeb29383d2803776323e77195400e5ee36c8cd4861c083ef6:0)
registerSplitScreenListener: 	at com.android.wm.shell.common.ExecutorUtils.lambda$executeRemoteCallWithTaskPermission$1(go/retraceme e9084556ee5ba06aeb29383d2803776323e77195400e5ee36c8cd4861c083ef6:60)
registerSplitScreenListener: 	at com.android.wm.shell.common.ExecutorUtils.$r8$lambda$s8eUOdyrqpqzzyFwAMGxO-MaCg4(go/retraceme e9084556ee5ba06aeb29383d2803776323e77195400e5ee36c8cd4861c083ef6:0)
registerSplitScreenListener: 	at com.android.wm.shell.common.ExecutorUtils$$ExternalSyntheticLambda1.run(go/retraceme e9084556ee5ba06aeb29383d2803776323e77195400e5ee36c8cd4861c083ef6:0)
registerSplitScreenListener: 	at android.os.Handler.handleCallback(Handler.java:958)
registerSplitScreenListener: 	at android.os.Handler.dispatchMessage(Handler.java:99)
registerSplitScreenListener: 	at android.os.Looper.loopOnce(Looper.java:205)
registerSplitScreenListener: 	at android.os.Looper.loop(Looper.java:294)
registerSplitScreenListener: 	at android.os.HandlerThread.run(HandlerThread.java:67)

设置分屏比例

mSplitLayout.setDivideRatio(splitRatio);

    /** Updates divide position and split bounds base on the ratio within root bounds. */
    public void setDivideRatio(float ratio) {
        final int position = isLandscape()
                ? mRootBounds.left + (int) (mRootBounds.width() * ratio)
                : mRootBounds.top + (int) (mRootBounds.height() * ratio);
        final DividerSnapAlgorithm.SnapTarget snapTarget =
                mDividerSnapAlgorithm.calculateNonDismissingSnapTarget(position);
        setDividePosition(snapTarget.position, false /* applyLayoutChange */);
    }

这里会先根据ratio计算出一个位置position,但是这个position并不是直接的SnapTarget的position，需要把这个position传递到calculateNonDismissingSnapTarget方法计算出SnapTarget，然后在使用SnapTarget的position。
具体见分屏分割线相关 (留坑，尚未更新)

更新分屏task的bounds

updateWindowBounds(mSplitLayout, wct);

传递上下分屏task信息

代码路径：frameworks/base/libs/WindowManager/Shell/src/com/android/wm/shell/splitscreen/StageCoordinator.java

    /**
     * Populates `wct` with operations that match the split windows to the current layout.
     * To match relevant surfaces, make sure to call updateSurfaceBounds after `wct` is applied
     *
     * @return true if stage bounds actually .
     */
    private boolean updateWindowBounds(SplitLayout layout, WindowContainerTransaction wct) {
        final StageTaskListener topLeftStage =
                mSideStagePosition == SPLIT_POSITION_TOP_OR_LEFT ? mSideStage : mMainStage;
        final StageTaskListener bottomRightStage =
                mSideStagePosition == SPLIT_POSITION_TOP_OR_LEFT ? mMainStage : mSideStage;
        return layout.applyTaskChanges(wct, topLeftStage.mRootTaskInfo,
                bottomRightStage.mRootTaskInfo);
    }

这个方法传递了上下屏task信息后，要对这些task的bound进行修改。
注意：这里传递的是SideStage和MainStage这个两个上下分屏容器task信息，而非这个两个Stage下面的挂着的应用的task信息。
layout.applyTaskChanges方法传递了WindowContainerTransaction对象和上下分屏的task信息。

设置bounds

代码路径：frameworks/base/libs/WindowManager/Shell/src/com/android/wm/shell/common/split/SplitLayout.java

    public boolean applyTaskChanges(WindowContainerTransaction wct,
            ActivityManager.RunningTaskInfo task1, ActivityManager.RunningTaskInfo task2) {
        boolean boundsChanged = false;
        if (!mBounds1.equals(mWinBounds1) || !task1.token.equals(mWinToken1)) {
            //设置bounds
            wct.setBounds(task1.token, mBounds1);
            wct.setSmallestScreenWidthDp(task1.token, getSmallestWidthDp(mBounds1));
            //记录新的bounds
            mWinBounds1.set(mBounds1);
            mWinToken1 = task1.token;
            boundsChanged = true;
        }
        if (!mBounds2.equals(mWinBounds2) || !task2.token.equals(mWinToken2)) {
            //设置bounds
            wct.setBounds(task2.token, mBounds2);
            wct.setSmallestScreenWidthDp(task2.token, getSmallestWidthDp(mBounds2));
            //记录新的bounds
            mWinBounds2.set(mBounds2);
            mWinToken2 = task2.token;
            boundsChanged = true;
        }
        return boundsChanged;
    }

这个方法主要就是设置新bounds，并把新的bounds记录到Rect对象中。
这里通过WindowContainerTransaction对象对bounds进行设置。

设置bounds的实现(system_server侧)

    /**
     * Resize a container.
     */
    @NonNull
    public WindowContainerTransaction setBounds(
            @NonNull WindowContainerToken container,@NonNull Rect bounds) {
        Change chg = getOrCreateChange(container.asBinder());
        chg.mConfiguration.windowConfiguration.setBounds(bounds);
        chg.mConfigSetMask |= ActivityInfo.CONFIG_WINDOW_CONFIGURATION;
        chg.mWindowSetMask |= WindowConfiguration.WINDOW_CONFIG_BOUNDS;
        return this;
    }

    /**
     * Set the smallestScreenWidth of a container.
     */
    @NonNull
    public WindowContainerTransaction setSmallestScreenWidthDp(
            @NonNull WindowContainerToken container, int widthDp) {
        Change cfg = getOrCreateChange(container.asBinder());
        cfg.mConfiguration.smallestScreenWidthDp = widthDp;
        cfg.mConfigSetMask |= ActivityInfo.CONFIG_SMALLEST_SCREEN_SIZE;
        return this;
    }

这里就是把设置的bounds保存到Change对象中，后续提交WindowContainerTransaction后，在system_server侧便会进行真正的处理。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/981745.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

一键安装Nginx部署脚本之Linux在线安装Nginx，脚本化自动化执行服务器部署（附执行脚本下载）

一键安装Nginx部署脚本之Linux在线安装Nginx，脚本化自动化执行服务器部署（附执行脚本下载）

相关链接 一键安装Nginx部署脚本之Linux在线安装Nginx一键安装Redis部署脚本之Linux在线安装Redis一键安装Mysql部署脚本之Linux在线安装Mysql一键安装JAVA部署脚本之Linux在线安装JDKXshell客户端免费版无需注册XFtp客户端免费版无需注册 前言 简化服务器部署操作&#xff0…
阅读更多...
yum源选要配置华为云的源，阿里云用不了的情况

yum源选要配置华为云的源，阿里云用不了的情况

curl -O /etc/yum.repos.d/CentOS-Base.repo https://repo.huaweicloud.com/repository/conf/CentOS-7-reg.repo
阅读更多...
软考中级-数据库-3.2 数据结构-数组和矩阵

软考中级-数据库-3.2 数据结构-数组和矩阵

数组 一维数组是长度固定的线性表&#xff0c;数组中的每个数据元素类型相同。n维数组是定长线性表在维数上的扩张&#xff0c;即线性表中的元素又是一个线性表。 例如一维数组a[5][a1,a2,a3,a4,a5] 二维数组a[2][3]是一个2行2列的数组 第一行[a11,a12,a13] 第二行[a21,a22,a23…
阅读更多...
微服务组件详解——sentinel

微服务组件详解——sentinel

1.启动sentinel&#xff1a; 下载jar sentinel-dashboard-1.8.0.jar 使用以下命令直接运行 jar 包&#xff08;JDK 版本必须≥ 1.8&#xff09;&#xff1a; java -Dserver.port9999 -jar D:\sentinel-dashboard-1.8.0.jar 控制台访问地址&#xff1a;http://localhost:9999…
阅读更多...
网络安全清单

网络安全清单

&#x1f345; 点击文末小卡片 &#xff0c;免费获取网络安全全套资料&#xff0c;资料在手&#xff0c;涨薪更快 自主访问控(DAC:Discretionary Access Control) 自主访问控制(DAC)是一个访问控制服务&#xff0c;其执行一个基于系统实体身份的安全政策和它们的授权来访问系统…
阅读更多...
unity学习62，尝试做第一个小游戏项目：flappy bird

unity学习62，尝试做第一个小游戏项目：flappy bird

目录 学习参考 1 创建1个unity 2D项目 1.1 2D项目模板选择 1.1.1 2D(built-in-Render pipeline) 1.1.2 universe 2D 1.1.3 这次选择 2D(built-in-Render pipeline) 1.2 创建项目 1.2.1 注意点 1.2.2 如果想修改项目名 2 导入美术资源包 2.1 下载一个flappy bird的…
阅读更多...
tauri2+typescript+vue+vite+leaflet等的简单联合使用（一）

tauri2+typescript+vue+vite+leaflet等的简单联合使用（一）

项目目标 主要的目的是学习tauri。 流程 1、搭建项目 2、简单的在项目使用leaflet 3、打包 准备项目 环境准备 废话不多说&#xff0c;直接开始 需要有准备能运行Rust的环境和Node&#xff0c;对于Rust可以参考下面这位大佬的文章&#xff0c;Node不必细说。 Rust 和…
阅读更多...
【FastGPT】如何新增用户修改密码

【FastGPT】如何新增用户修改密码

【FastGPT】如何新增用户&修改密码 摘要查看运行中的容器进入mongo容器登录mongo数据库切换数据库查询用户集合数据新增用户查询团队表数据创建团队查询团队成员集合数据把用户加入团队FastGPT用户密码的加密规则介绍加密算法Java版参考代码&单元测试代码修改密码 摘要…
阅读更多...
复试准备日常

复试准备日常

实验室目前投了 aiot 这周四 感知计算面试3.5号下午2点开始&#xff08;面完了他问我有没有项目&#xff09; 532图像处理实验室&#xff08;我的项目大多也是图像处理的&#xff09;&#xff08;预计下周末&#xff09;提前到3.4号下午6点 我不在第一批里面 软专不知道要几个 …
阅读更多...
HiRT：利用分层机器人Transformer 增强机器人控制

HiRT：利用分层机器人Transformer 增强机器人控制

25年2月来自清华、伯克利分校和上海姚期智研究院的论文“HiRT: Enhancing Robotic Control with Hierarchical Robot Transformers”。 大型视觉-语言-动作 (VLA) 模型利用强大的预训练视觉-语言模型 (VLM) 后端&#xff0c;由于其深刻的泛化能力而在机器人控制方面显示出良好…
阅读更多...
Netty笔记3：NIO编程

Netty笔记3：NIO编程

Netty笔记1&#xff1a;线程模型 Netty笔记2&#xff1a;零拷贝 Netty笔记3&#xff1a;NIO编程 Netty笔记4&#xff1a;Epoll Netty笔记5&#xff1a;Netty开发实例 Netty笔记6&#xff1a;Netty组件 Netty笔记7&#xff1a;ChannelPromise通知处理 Netty笔记8&#xf…
阅读更多...
MySQL-高级查询

MySQL-高级查询

查询处理 排序&#xff08;默认不是按主键排序的&#xff09; order by 字段1[&#xff0c;字段2] [asc|desc] 默认是升序排序也可以指定 select 列表中列的序号进行排序如果是多个字段&#xff0c;那么在上一个字段排序完的基础上排序下一个 限制数量 limit 行数&#xff0…
阅读更多...
解决各大浏览器中http地址无权限调用麦克风摄像头问题（包括谷歌，Edge，360，火狐）后续会陆续补充

解决各大浏览器中http地址无权限调用麦克风摄像头问题（包括谷歌，Edge，360，火狐）后续会陆续补充

项目场景&#xff1a; 在各大浏览器中http地址调用电脑麦克风摄像头会没有权限&#xff0c;http协议无法使用多媒体设备 原因分析&#xff1a; 为了用户的隐私安全&#xff0c;http协议无法使用多媒体设备。因为像摄像头和麦克风属于可能涉及重大隐私问题的API&#xff0c;ge…
阅读更多...
权限系统设计方案实践（Spring Security + RBAC 模型）

权限系统设计方案实践（Spring Security + RBAC 模型）

前言 权限系统设计基本上是所有项目中都会涉及的一个重要部分。通过权限系统&#xff0c;我们将对用户角色、功能模块访问进行限制&#xff0c;从而保证系统安全性。本文将介绍中大型项目中常用的一套权限系统设计方案&#xff0c;通过 SpringSecurity 安全管理框架&#xff0c…
阅读更多...
数学软件Matlab下载｜支持Win+Mac网盘资源分享

数学软件Matlab下载｜支持Win+Mac网盘资源分享

如大家所了解的&#xff0c;Matlab与Maple、Mathematica并称为三大数学软件。Matlab应用广泛&#xff0c;常被用于数据分析、无线通信、深度学习、图像处理与计算机视觉、信号处理、量化金融与风险管理、机器人&#xff0c;控制系统等领域。 Matlab将数值分析、矩阵计算、科学…
阅读更多...
植物大战僵尸杂交版v3.3最新版本（附下载链接）

植物大战僵尸杂交版v3.3最新版本（附下载链接）

B站游戏作者潜艇伟伟迷于12月21日更新了植物大战僵尸杂交版3.3版本&#xff01;&#xff01;&#xff01;&#xff0c;有b站账户的记得要给作者三连关注一下呀&#xff01; 不多废话下载链接放上&#xff1a; 夸克网盘链接&#xff1a;&#xff1a;https://pan.quark.cn/s/6f2a…
阅读更多...
GPU、NPU与LPU：大语言模型（LLM）硬件加速器全面对比分析

GPU、NPU与LPU：大语言模型（LLM）硬件加速器全面对比分析

引言&#xff1a;大语言模型计算基础设施的演进 随着大语言模型&#xff08;LLM&#xff09;的快速发展与广泛应用&#xff0c;高性能计算硬件已成为支撑LLM训练与推理的关键基础设施。目前市场上主要有三类处理器用于加速LLM相关任务&#xff1a;GPU&#xff08;图形处理单元…
阅读更多...
计算机网络数据传输探秘：包裹如何在数字世界旅行？

计算机网络数据传输探秘：包裹如何在数字世界旅行？

计算机网络数据传输探秘：包裹如何在数字世界旅行？ 一、从快递网络看数据传输本质 想象你网购了一件商品： 打包：商家用纸箱包装，贴上地址标签（数据封装）运输：包裹经过网点→分拣中心→运输车（网络节点与链路）签收：快递员核对信息后交付（数据校验与接收）数据的网络…
阅读更多...
VirtualBox虚拟机MacOS从Big Sur升级到Sequoia（失败）

VirtualBox虚拟机MacOS从Big Sur升级到Sequoia（失败）

VirtualBox虚拟机里安装好Big Sur版本&#xff0c;尝试升级到Sequoia&#xff0c;但是最终失败了。 软件升级 直接在系统偏好-软件更新里可以看到提示&#xff0c;提示可以升级到15版本Sequoia 点击同意&#xff0c;看能不能升级到Sequoia吧。升级前先用时光做了备份。 升级…
阅读更多...
从数据到决策，永洪科技助力良信电器“智”领未来

从数据到决策，永洪科技助力良信电器“智”领未来

在数字经济浪潮汹涌的时代&#xff0c;数字化转型已成为企业增强竞争力、实现可持续发展的必由之路。良信电器&#xff0c;作为国内知名的电气设备制造企业&#xff0c;积极响应时代号召&#xff0c;携手永洪科技&#xff0c;共同开启了数字化转型的新篇章。 上海良信电器股份有…
阅读更多...
最新文章

Copyright @ 2022~2023