WMS进阶：多窗口模式与显示管理深度解析

用户启动分屏模式
    ↓
WMS创建分屏TaskFragment
    ↓
应用窗口调整为50%宽度
    ↓
配置变更(Configuration Change)
    ↓
应用重新布局适配分屏
    ↓
两个应用并排显示！

应用层
    ↓
Activity (配置变更、生命周期回调)
    ↓
WindowManager (窗口大小调整)
    ↓
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
系统层
    ↓
WindowManagerService
    ├── TaskFragment (任务片段，分屏的基本单位)
    ├── DisplayContent (显示内容管理)
    └── WindowState (窗口状态)
    ↓
ActivityTaskManagerService
    ├── Task (任务栈)
    ├── TaskDisplayArea (任务显示区域)
    └── SplitScreenController (分屏控制器)
    ↓
SurfaceFlinger (最终渲染)

// frameworks/base/services/core/java/com/android/server/wm/TaskFragment.java
// Android 15: TaskFragment - 分屏的基本单位
 
/**
 * TaskFragment是Activity容器的最小单元
 * 在分屏模式下，一个Task可以包含多个TaskFragment
 */
public class TaskFragment extends WindowContainer<WindowContainer> {
 
    // TaskFragment类型
    static final int TASK_FRAGMENT_TYPE_STANDARD = 0;      // 标准TaskFragment
    static final int TASK_FRAGMENT_TYPE_SPLIT_PRIMARY = 1; // 分屏主区域
    static final int TASK_FRAGMENT_TYPE_SPLIT_SECONDARY = 2; // 分屏副区域
 
    // 当前TaskFragment类型
    private int mTaskFragmentType;
 
    // 父Task
    private Task mTask;
 
    // 包含的Activity列表
    private final ArrayList<ActivityRecord> mChildren = new ArrayList<>();
 
    // TaskFragment的边界(分屏时为屏幕的一半)
    private final Rect mBounds = new Rect();
 
    /**
     * 计算TaskFragment的边界
     */
    void calculateBounds() {
        final DisplayContent displayContent = getDisplayContent();
        final Rect displayBounds = displayContent.getBounds();
 
        switch (mTaskFragmentType) {
            case TASK_FRAGMENT_TYPE_SPLIT_PRIMARY:
                // 主区域：屏幕左半部分
                mBounds.set(
                    displayBounds.left,
                    displayBounds.top,
                    displayBounds.centerX(),
                    displayBounds.bottom
                );
                break;
 
            case TASK_FRAGMENT_TYPE_SPLIT_SECONDARY:
                // 副区域：屏幕右半部分
                mBounds.set(
                    displayBounds.centerX(),
                    displayBounds.top,
                    displayBounds.right,
                    displayBounds.bottom
                );
                break;
 
            case TASK_FRAGMENT_TYPE_STANDARD:
            default:
                // 标准模式：全屏
                mBounds.set(displayBounds);
                break;
        }
 
        // 通知所有子Activity配置变更
        onConfigurationChanged();
    }
}

// frameworks/base/services/core/java/com/android/server/wm/SplitScreenController.java
// Android 15: 分屏控制器
 
public class SplitScreenController {
 
    /**
     * 进入分屏模式
     */
    public boolean enterSplitScreen(Task primaryTask, Task secondaryTask, int splitPosition) {
 
        // 1. 检查设备是否支持分屏
        if (!supportsSplitScreen()) {
            Log.w(TAG, "Device does not support split screen");
            return false;
        }
 
        // 2. 检查应用是否支持分屏
        if (!primaryTask.supportsSplitScreen()) {
            Log.w(TAG, "Primary task does not support split screen");
            return false;
        }
 
        if (!secondaryTask.supportsSplitScreen()) {
            Log.w(TAG, "Secondary task does not support split screen");
            return false;
        }
 
        synchronized (mGlobalLock) {
            // 3. 获取DisplayContent
            final DisplayContent displayContent = primaryTask.getDisplayContent();
 
            // 4. 创建分屏TaskFragment
            TaskFragment primaryFragment = createTaskFragment(
                primaryTask,
                TaskFragment.TASK_FRAGMENT_TYPE_SPLIT_PRIMARY
            );
 
            TaskFragment secondaryFragment = createTaskFragment(
                secondaryTask,
                TaskFragment.TASK_FRAGMENT_TYPE_SPLIT_SECONDARY
            );
 
            // 5. 计算分屏边界
            calculateSplitBounds(primaryFragment, secondaryFragment, splitPosition);
 
            // 6. 触发配置变更
            // Activity会收到onConfigurationChanged()回调
            primaryTask.onConfigurationChanged(primaryFragment.getConfiguration());
            secondaryTask.onConfigurationChanged(secondaryFragment.getConfiguration());
 
            // 7. 更新窗口层级
            displayContent.assignWindowLayers(true);
 
            // 8. 触发动画
            startSplitScreenAnimation(primaryFragment, secondaryFragment);
 
            // 9. 记录分屏状态
            mInSplitScreenMode = true;
            mPrimarySplitTask = primaryTask;
            mSecondarySplitTask = secondaryTask;
 
            return true;
        }
    }
 
    /**
     * 计算分屏边界(支持自定义比例)
     */
    private void calculateSplitBounds(TaskFragment primary, TaskFragment secondary,
            int splitPosition) {
 
        final DisplayContent displayContent = primary.getDisplayContent();
        final Rect displayBounds = displayContent.getBounds();
 
        // splitPosition: 0-100 表示主区域占比
        // 默认50表示平分屏幕
        int dividerPosition = displayBounds.width() * splitPosition / 100;
 
        // 主区域边界
        Rect primaryBounds = new Rect(
            displayBounds.left,
            displayBounds.top,
            displayBounds.left + dividerPosition,
            displayBounds.bottom
        );
        primary.setBounds(primaryBounds);
 
        // 副区域边界
        Rect secondaryBounds = new Rect(
            displayBounds.left + dividerPosition,
            displayBounds.top,
            displayBounds.right,
            displayBounds.bottom
        );
        secondary.setBounds(secondaryBounds);
    }
 
    /**
     * 检查应用是否支持分屏
     */
    private boolean supportsSplitScreen() {
        // 1. 检查屏幕尺寸(最小宽度要求)
        Configuration config = mContext.getResources().getConfiguration();
        if (config.smallestScreenWidthDp < 600) {
            // 小于600dp不支持分屏(通常是手机)
            return false;
        }
 
        // 2. 检查系统属性
        if (!Settings.Global.getInt(mContext.getContentResolver(),
                Settings.Global.DEVELOPMENT_FORCE_RESIZABLE_ACTIVITIES, 0) == 1) {
            // 开发者选项未启用强制分屏
        }
 
        return true;
    }
}

<!-- AndroidManifest.xml -->
<activity
    android:name=".MainActivity"
    android:resizeableActivity="true"
    android:supportsPictureInPicture="true">
 
    <!-- 最小宽高限制(可选) -->
    <layout
        android:defaultWidth="600dp"
        android:defaultHeight="400dp"
        android:minWidth="300dp"
        android:minHeight="200dp" />
</activity>

// 应用层代码
public class MainActivity extends Activity {
 
    @Override
    public void onConfigurationChanged(Configuration newConfig) {
        super.onConfigurationChanged(newConfig);
 
        // 1. 检查是否进入多窗口模式
        boolean isInMultiWindowMode = isInMultiWindowMode();
 
        // 2. 检查屏幕尺寸变化
        int screenWidth = newConfig.screenWidthDp;
        int screenHeight = newConfig.screenHeightDp;
 
        Log.d(TAG, "Multi-window mode: " + isInMultiWindowMode +
            ", Size: " + screenWidth + "x" + screenHeight);
 
        // 3. 调整UI布局
        if (isInMultiWindowMode) {
            // 分屏模式：紧凑布局
            switchToCompactLayout();
        } else {
            // 全屏模式：标准布局
            switchToStandardLayout();
        }
    }
 
    @Override
    public void onMultiWindowModeChanged(boolean isInMultiWindowMode,
            Configuration newConfig) {
        super.onMultiWindowModeChanged(isInMultiWindowMode, newConfig);
 
        // 多窗口模式变更回调
        if (isInMultiWindowMode) {
            Log.d(TAG, "Entered multi-window mode");
        } else {
            Log.d(TAG, "Exited multi-window mode");
        }
    }
 
    /**
     * 紧凑布局(分屏模式)
     */
    private void switchToCompactLayout() {
        // 隐藏侧边栏
        findViewById(R.id.sidebar).setVisibility(View.GONE);
 
        // 列表显示更紧凑
        RecyclerView recyclerView = findViewById(R.id.recycler_view);
        recyclerView.setLayoutManager(new LinearLayoutManager(this));
 
        // 调整字体大小
        TextView title = findViewById(R.id.title);
        title.setTextSize(TypedValue.COMPLEX_UNIT_SP, 18);
    }
 
    /**
     * 标准布局(全屏模式)
     */
    private void switchToStandardLayout() {
        // 显示侧边栏
        findViewById(R.id.sidebar).setVisibility(View.VISIBLE);
 
        // 列表显示网格布局
        RecyclerView recyclerView = findViewById(R.id.recycler_view);
        recyclerView.setLayoutManager(new GridLayoutManager(this, 2));
 
        // 恢复字体大小
        TextView title = findViewById(R.id.title);
        title.setTextSize(TypedValue.COMPLEX_UNIT_SP, 24);
    }
}

// frameworks/base/libs/WindowManager/Shell/src/com/android/wm/shell/splitscreen/SplitScreenDivider.java
// Android 15: 分屏分隔条
 
public class SplitScreenDivider {
 
    // 分隔条宽度
    private static final int DIVIDER_WIDTH_DP = 8;
 
    // 分隔条位置(0-100)
    private int mDividerPosition = 50; // 默认平分
 
    /**
     * 处理分隔条拖动
     */
    public void onDragDivider(MotionEvent event) {
        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
                // 开始拖动
                mDragging = true;
                mStartPosition = mDividerPosition;
                break;
 
            case MotionEvent.ACTION_MOVE:
                // 拖动中
                float deltaX = event.getX() - mStartX;
                int newPosition = calculateNewPosition(deltaX);
 
                // 限制最小/最大比例
                newPosition = Math.max(30, Math.min(70, newPosition));
 
                if (newPosition != mDividerPosition) {
                    mDividerPosition = newPosition;
                    // 实时更新分屏边界
                    updateSplitBounds(newPosition);
                }
                break;
 
            case MotionEvent.ACTION_UP:
                // 结束拖动
                mDragging = false;
                // 触发重新布局
                finalizeSplitPosition();
                break;
        }
    }
 
    /**
     * 更新分屏边界
     */
    private void updateSplitBounds(int dividerPosition) {
        // 通知SplitScreenController更新边界
        mSplitScreenController.onDividerPositionChanged(dividerPosition);
 
        // 触发Configuration Change
        // Activity会收到onConfigurationChanged()回调
    }
}

// frameworks/base/services/core/java/com/android/server/wm/PinnedTaskController.java
// Android 15: 画中画控制器
 
public class PinnedTaskController {
 
    // PIP窗口的默认大小(占屏幕宽度的比例)
    private static final float PIP_DEFAULT_SIZE_PERCENT = 0.25f;
 
    // PIP窗口的最小/最大尺寸
    private static final int PIP_MIN_WIDTH_DP = 100;
    private static final int PIP_MIN_HEIGHT_DP = 100;
    private static final int PIP_MAX_WIDTH_DP = 500;
    private static final int PIP_MAX_HEIGHT_DP = 500;
 
    /**
     * 进入PIP模式
     */
    public boolean enterPictureInPicture(Task task, PictureInPictureParams params) {
 
        // 1. 检查应用是否支持PIP
        if (!task.supportsPictureInPicture()) {
            Log.w(TAG, "Task does not support PIP");
            return false;
        }
 
        // 2. 检查用户是否禁用了PIP
        if (!isPictureInPictureAllowed(task)) {
            Log.w(TAG, "PIP is not allowed for this task");
            return false;
        }
 
        synchronized (mGlobalLock) {
            // 3. 计算PIP窗口边界
            Rect pipBounds = calculatePipBounds(params);
 
            // 4. 设置Task为PIP模式
            task.setWindowingMode(WINDOWING_MODE_PINNED);
            task.setBounds(pipBounds);
 
            // 5. 更新Z-order(PIP窗口应该在最上层)
            task.getDisplayContent().positionChildAt(POSITION_TOP, task, false);
 
            // 6. 触发进入PIP动画
            startEnterPipAnimation(task, pipBounds);
 
            // 7. 通知Activity进入PIP
            task.forAllActivities(activity -> {
                activity.pictureInPictureArgs = params;
                activity.setState(PAUSED, "enterPictureInPicture");
                // Activity会收到onPictureInPictureModeChanged(true)回调
            });
 
            // 8. 记录PIP状态
            mPinnedTask = task;
 
            return true;
        }
    }
 
    /**
     * 计算PIP窗口边界
     */
    private Rect calculatePipBounds(PictureInPictureParams params) {
        final DisplayContent displayContent = mDisplayContent;
        final Rect displayBounds = displayContent.getBounds();
 
        // 1. 获取PIP宽高比(应用指定或默认16:9)
        Rational aspectRatio = params.getAspectRatio();
        if (aspectRatio == null) {
            aspectRatio = new Rational(16, 9);
        }
 
        // 2. 计算PIP窗口大小
        int pipWidth = (int) (displayBounds.width() * PIP_DEFAULT_SIZE_PERCENT);
        int pipHeight = (int) (pipWidth / aspectRatio.floatValue());
 
        // 3. 限制最小/最大尺寸
        pipWidth = Math.max(PIP_MIN_WIDTH_DP, Math.min(PIP_MAX_WIDTH_DP, pipWidth));
        pipHeight = Math.max(PIP_MIN_HEIGHT_DP, Math.min(PIP_MAX_HEIGHT_DP, pipHeight));
 
        // 4. 计算PIP位置(默认右下角)
        int pipX = displayBounds.right - pipWidth - PIP_MARGIN_DP;
        int pipY = displayBounds.bottom - pipHeight - PIP_MARGIN_DP;
 
        // 5. 应用用户自定义位置(如果有)
        if (params.hasSourceBoundsHint()) {
            Rect sourceHint = params.getSourceRectHint();
            pipX = sourceHint.left;
            pipY = sourceHint.top;
        }
 
        return new Rect(pipX, pipY, pipX + pipWidth, pipY + pipHeight);
    }
 
    /**
     * PIP进入动画
     */
    private void startEnterPipAnimation(Task task, Rect pipBounds) {
        // 从全屏缩放到PIP大小
        final Rect startBounds = task.getBounds();
 
        // 创建缩放动画
        Animation scaleAnim = new ScaleAnimation(
            1.0f, pipBounds.width() / (float) startBounds.width(),  // X缩放
            1.0f, pipBounds.height() / (float) startBounds.height(), // Y缩放
            startBounds.centerX(), startBounds.centerY()
        );
 
        // 创建移动动画
        Animation translateAnim = new TranslateAnimation(
            0, pipBounds.centerX() - startBounds.centerX(), // X移动
            0, pipBounds.centerY() - startBounds.centerY()  // Y移动
        );
 
        // 组合动画
        AnimationSet animSet = new AnimationSet(true);
        animSet.addAnimation(scaleAnim);
        animSet.addAnimation(translateAnim);
        animSet.setDuration(300); // 300ms
        animSet.setInterpolator(new DecelerateInterpolator());
 
        // 应用动画
        task.startAnimation(animSet);
    }
 
    /**
     * 退出PIP模式
     */
    public void exitPictureInPicture(Task task) {
        synchronized (mGlobalLock) {
            // 1. 恢复全屏模式
            task.setWindowingMode(WINDOWING_MODE_FULLSCREEN);
 
            final DisplayContent displayContent = task.getDisplayContent();
            task.setBounds(displayContent.getBounds());
 
            // 2. 触发退出PIP动画
            startExitPipAnimation(task);
 
            // 3. 通知Activity退出PIP
            task.forAllActivities(activity -> {
                activity.pictureInPictureArgs = null;
                activity.setState(RESUMED, "exitPictureInPicture");
                // Activity会收到onPictureInPictureModeChanged(false)回调
            });
 
            // 4. 清除PIP状态
            mPinnedTask = null;
        }
    }
}

// 应用层代码
public class VideoPlayerActivity extends Activity {
 
    /**
     * 进入PIP模式
     */
    private void enterPipMode() {
        // 1. 构建PIP参数
        PictureInPictureParams params = new PictureInPictureParams.Builder()
            .setAspectRatio(new Rational(16, 9))  // 16:9宽高比
            .setSourceRectHint(calculateVideoRect()) // 视频位置提示(用于动画)
            .setActions(buildPipActions())           // PIP控制按钮
            .build();
 
        // 2. 请求进入PIP
        enterPictureInPictureMode(params);
    }
 
    /**
     * 构建PIP控制按钮
     */
    private List<RemoteAction> buildPipActions() {
        List<RemoteAction> actions = new ArrayList<>();
 
        // 播放/暂停按钮
        actions.add(new RemoteAction(
            Icon.createWithResource(this, R.drawable.ic_pause),
            "Pause",
            "Pause video",
            createPendingIntent(ACTION_PAUSE)
        ));
 
        // 下一个视频按钮
        actions.add(new RemoteAction(
            Icon.createWithResource(this, R.drawable.ic_next),
            "Next",
            "Next video",
            createPendingIntent(ACTION_NEXT)
        ));
 
        return actions;
    }
 
    @Override
    public void onPictureInPictureModeChanged(boolean isInPictureInPictureMode,
            Configuration newConfig) {
        super.onPictureInPictureModeChanged(isInPictureInPictureMode, newConfig);
 
        if (isInPictureInPictureMode) {
            // 进入PIP模式
            // 隐藏控制栏
            findViewById(R.id.control_bar).setVisibility(View.GONE);
 
            // 隐藏非视频内容
            findViewById(R.id.video_info).setVisibility(View.GONE);
 
            // 保持视频播放
            mVideoView.play();
 
        } else {
            // 退出PIP模式
            // 显示控制栏
            findViewById(R.id.control_bar).setVisibility(View.VISIBLE);
 
            // 显示视频信息
            findViewById(R.id.video_info).setVisibility(View.VISIBLE);
        }
    }
 
    @Override
    public void onUserLeaveHint() {
        super.onUserLeaveHint();
 
        // 用户按Home键或切换应用时自动进入PIP
        if (mVideoView.isPlaying()) {
            enterPipMode();
        }
    }
}

// frameworks/base/services/core/java/com/android/server/wm/FreeformWindowController.java
// Android 15: 自由窗口控制器
 
public class FreeformWindowController {
 
    /**
     * 进入自由窗口模式
     */
    public boolean enterFreeformMode(Task task, Rect bounds) {
 
        // 1. 检查设备是否支持自由窗口
        if (!supportsFreeform()) {
            Log.w(TAG, "Device does not support freeform");
            return false;
        }
 
        synchronized (mGlobalLock) {
            // 2. 设置Task为自由窗口模式
            task.setWindowingMode(WINDOWING_MODE_FREEFORM);
 
            // 3. 设置窗口边界
            if (bounds == null) {
                // 未指定边界，使用默认大小和位置
                bounds = calculateDefaultFreeformBounds(task);
            }
            task.setBounds(bounds);
 
            // 4. 添加窗口装饰(标题栏、边框、调整按钮)
            addFreeformDecorations(task);
 
            // 5. 触发配置变更
            task.onConfigurationChanged();
 
            // 6. 更新Z-order
            task.getDisplayContent().assignWindowLayers(true);
 
            return true;
        }
    }
 
    /**
     * 计算默认自由窗口边界
     */
    private Rect calculateDefaultFreeformBounds(Task task) {
        final DisplayContent displayContent = task.getDisplayContent();
        final Rect displayBounds = displayContent.getBounds();
 
        // 默认大小：屏幕的60%
        int width = (int) (displayBounds.width() * 0.6f);
        int height = (int) (displayBounds.height() * 0.6f);
 
        // 默认位置：居中并略微偏移(支持多个自由窗口)
        int x = (displayBounds.width() - width) / 2 + mFreeformWindowCount * 40;
        int y = (displayBounds.height() - height) / 2 + mFreeformWindowCount * 40;
 
        return new Rect(x, y, x + width, y + height);
    }
 
    /**
     * 添加窗口装饰(标题栏、边框)
     */
    private void addFreeformDecorations(Task task) {
        // 1. 创建标题栏窗口
        WindowState captionWindow = new WindowState(
            mService,
            task.getSession(),
            null, // IWindow
            task.getWindowToken(),
            null, // parent
            0,    // appOp
            new WindowManager.LayoutParams(
                WindowManager.LayoutParams.MATCH_PARENT,
                CAPTION_HEIGHT_DP,
                WindowManager.LayoutParams.TYPE_APPLICATION,
                WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE,
                PixelFormat.TRANSLUCENT
            ),
            View.VISIBLE,
            task.getOwnerUid(),
            task.getOwnerPid(),
            false // canAddInternalSystemWindow
        );
 
        // 2. 设置标题栏内容
        // - 应用图标
        // - 应用名称
        // - 最小化按钮
        // - 最大化按钮
        // - 关闭按钮
 
        // 3. 创建边框窗口(8个：上下左右 + 4个角)
        createResizeBorders(task);
 
        // 4. 关联到Task
        task.mCaptionWindow = captionWindow;
    }
 
    /**
     * 处理自由窗口调整大小
     */
    public void onResizeFreeformWindow(Task task, Rect newBounds) {
        synchronized (mGlobalLock) {
            // 1. 限制最小/最大尺寸
            int minWidth = task.getMinWidth();
            int minHeight = task.getMinHeight();
            int maxWidth = task.getMaxWidth();
            int maxHeight = task.getMaxHeight();
 
            int width = Math.max(minWidth, Math.min(maxWidth, newBounds.width()));
            int height = Math.max(minHeight, Math.min(maxHeight, newBounds.height()));
 
            // 2. 更新Task边界
            Rect finalBounds = new Rect(
                newBounds.left,
                newBounds.top,
                newBounds.left + width,
                newBounds.top + height
            );
            task.setBounds(finalBounds);
 
            // 3. 触发配置变更
            task.onConfigurationChanged();
 
            // 4. 通知Activity大小变更
            task.forAllActivities(activity -> {
                activity.ensureActivityConfiguration(false /* ignoreVisibility */);
            });
        }
    }
}

// Android 15新增：桌面模式(Desktop Mode)
 
/**
 * 桌面模式：增强的自由窗口体验
 */
public class DesktopModeController {
 
    /**
     * 启用桌面模式
     */
    public void enableDesktopMode() {
        // 1. 启用窗口装饰
        Settings.Global.putInt(mContext.getContentResolver(),
            Settings.Global.ENABLE_FREEFORM_SUPPORT, 1);
 
        // 2. 启用任务栏
        Settings.Global.putInt(mContext.getContentResolver(),
            Settings.Global.ENABLE_TASKBAR, 1);
 
        // 3. 启用应用切换器(类似Alt+Tab)
        mWindowManager.setDesktopModeEnabled(true);
 
        // 4. 调整默认窗口大小
        // 桌面模式下窗口更小，允许并排显示多个窗口
    }
 
    /**
     * 窗口吸附(Snap)功能
     */
    public void snapWindow(Task task, int snapPosition) {
        final DisplayContent displayContent = task.getDisplayContent();
        final Rect displayBounds = displayContent.getBounds();
 
        Rect snapBounds;
        switch (snapPosition) {
            case SNAP_LEFT:
                // 吸附到左半屏
                snapBounds = new Rect(
                    displayBounds.left,
                    displayBounds.top,
                    displayBounds.centerX(),
                    displayBounds.bottom
                );
                break;
 
            case SNAP_RIGHT:
                // 吸附到右半屏
                snapBounds = new Rect(
                    displayBounds.centerX(),
                    displayBounds.top,
                    displayBounds.right,
                    displayBounds.bottom
                );
                break;
 
            case SNAP_MAXIMIZE:
                // 最大化
                snapBounds = new Rect(displayBounds);
                break;
 
            default:
                return;
        }
 
        // 应用吸附动画
        animateWindowSnap(task, task.getBounds(), snapBounds);
    }
}

// frameworks/base/services/core/java/com/android/server/wm/DisplayContent.java
// Android 15: DisplayContent - 显示内容管理
 
public class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowContainer> {
 
    // 显示屏ID
    private final int mDisplayId;
 
    // 显示屏信息
    private final Display mDisplay;
    private final DisplayInfo mDisplayInfo = new DisplayInfo();
 
    // 该显示屏上的所有Task
    private final ArrayList<Task> mTasks = new ArrayList<>();
 
    // 显示屏状态
    private static final int DISPLAY_STATE_ON = 0;
    private static final int DISPLAY_STATE_OFF = 1;
    private static final int DISPLAY_STATE_DOZE = 2;
    private int mDisplayState = DISPLAY_STATE_ON;
 
    /**
     * 添加Task到显示屏
     */
    void addTask(Task task, int position) {
        if (task.getDisplayContent() != null) {
            throw new IllegalArgumentException("Task already has a display");
        }
 
        // 1. 添加到Task列表
        mTasks.add(position, task);
 
        // 2. 设置Task的DisplayContent
        task.onDisplayChanged(this);
 
        // 3. 触发布局计算
        assignWindowLayers(true);
 
        // 4. 更新焦点
        updateFocusedWindowLocked(UPDATE_FOCUS_NORMAL, false);
    }
 
    /**
     * 移除Task
     */
    void removeTask(Task task) {
        if (!mTasks.remove(task)) {
            return;
        }
 
        // 1. 清除Task的DisplayContent
        task.onDisplayChanged(null);
 
        // 2. 更新焦点
        updateFocusedWindowLocked(UPDATE_FOCUS_NORMAL, false);
    }
 
    /**
     * 获取显示屏边界
     */
    public Rect getBounds() {
        return new Rect(0, 0, mDisplayInfo.logicalWidth, mDisplayInfo.logicalHeight);
    }
 
    /**
     * 处理显示屏旋转
     */
    void updateRotation(int rotation) {
        if (mDisplayInfo.rotation == rotation) {
            return;
        }
 
        // 1. 更新旋转角度
        int oldRotation = mDisplayInfo.rotation;
        mDisplayInfo.rotation = rotation;
 
        // 2. 更新显示尺寸(90度和270度旋转时宽高互换)
        if ((rotation + oldRotation) % 2 != 0) {
            int temp = mDisplayInfo.logicalWidth;
            mDisplayInfo.logicalWidth = mDisplayInfo.logicalHeight;
            mDisplayInfo.logicalHeight = temp;
        }
 
        // 3. 触发所有Task的配置变更
        for (Task task : mTasks) {
            task.onConfigurationChanged();
        }
 
        // 4. 触发旋转动画
        startRotationAnimation(oldRotation, rotation);
    }
}

// frameworks/base/services/core/java/com/android/server/wm/RootWindowContainer.java
// Android 15: 根窗口容器 - 管理所有显示屏
 
public class RootWindowContainer extends WindowContainer<DisplayContent> {
 
    // 所有DisplayContent (DisplayId → DisplayContent)
    private final SparseArray<DisplayContent> mDisplayContents = new SparseArray<>();
 
    // 默认显示屏ID
    private static final int DEFAULT_DISPLAY = Display.DEFAULT_DISPLAY; // 0
 
    /**
     * 创建新的显示屏
     */
    DisplayContent createDisplayContent(Display display) {
        final int displayId = display.getDisplayId();
 
        // 1. 检查显示屏是否已存在
        if (mDisplayContents.get(displayId) != null) {
            throw new IllegalArgumentException("Display already exists: " + displayId);
        }
 
        // 2. 创建DisplayContent
        DisplayContent displayContent = new DisplayContent(display, mService);
 
        // 3. 添加到映射表
        mDisplayContents.put(displayId, displayContent);
 
        // 4. 添加到子容器列表
        addChild(displayContent, POSITION_BOTTOM);
 
        // 5. 触发配置初始化
        displayContent.onDisplayChanged(displayContent.mDisplay);
 
        return displayContent;
    }
 
    /**
     * 移除显示屏
     */
    void removeDisplayContent(int displayId) {
        final DisplayContent displayContent = mDisplayContents.get(displayId);
        if (displayContent == null) {
            return;
        }
 
        // 1. 移除所有Task
        displayContent.removeAllTasks();
 
        // 2. 从映射表移除
        mDisplayContents.remove(displayId);
 
        // 3. 从子容器列表移除
        removeChild(displayContent);
 
        // 4. 销毁DisplayContent
        displayContent.dispose();
    }
 
    /**
     * 获取DisplayContent
     */
    DisplayContent getDisplayContent(int displayId) {
        return mDisplayContents.get(displayId);
    }
 
    /**
     * 获取默认显示屏
     */
    DisplayContent getDefaultDisplay() {
        return getDisplayContent(DEFAULT_DISPLAY);
    }
 
    /**
     * 在指定显示屏上启动Activity
     */
    void startActivityOnDisplay(Intent intent, int displayId, int userId) {
        // 1. 获取DisplayContent
        DisplayContent displayContent = getDisplayContent(displayId);
        if (displayContent == null) {
            Log.e(TAG, "Display not found: " + displayId);
            return;
        }
 
        // 2. 创建Task
        Task task = displayContent.createTask(intent, userId);
 
        // 3. 启动Activity
        mActivityTaskManager.startActivity(
            task,
            intent,
            userId,
            displayId
        );
    }
}

// 应用层代码：实现投屏功能
public class ScreenMirrorActivity extends Activity {
 
    private DisplayManager mDisplayManager;
    private VirtualDisplay mVirtualDisplay;
 
    /**
     * 开始投屏到第二显示屏
     */
    private void startMirroring() {
        mDisplayManager = getSystemService(DisplayManager.class);
 
        // 1. 获取所有显示屏
        Display[] displays = mDisplayManager.getDisplays();
 
        // 2. 找到第二显示屏(外接显示器/电视)
        Display secondaryDisplay = null;
        for (Display display : displays) {
            if (display.getDisplayId() != Display.DEFAULT_DISPLAY) {
                secondaryDisplay = display;
                break;
            }
        }
 
        if (secondaryDisplay == null) {
            Log.w(TAG, "No secondary display found");
            return;
        }
 
        // 3. 在第二显示屏上创建Presentation
        Presentation presentation = new Presentation(this, secondaryDisplay);
        presentation.setContentView(R.layout.mirror_content);
        presentation.show();
 
        Log.d(TAG, "Mirroring to display: " + secondaryDisplay.getName());
    }
 
    /**
     * Presentation：在第二显示屏上显示的窗口
     */
    private class MirrorPresentation extends Presentation {
 
        public MirrorPresentation(Context outerContext, Display display) {
            super(outerContext, display);
        }
 
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.mirror_layout);
 
            // 显示镜像内容
            VideoView videoView = findViewById(R.id.video_view);
            videoView.setVideoURI(Uri.parse("..."));
            videoView.start();
        }
    }
}

// frameworks/base/services/core/java/com/android/server/display/VirtualDisplayAdapter.java
// Android 15: 虚拟显示适配器
 
public class VirtualDisplayAdapter extends DisplayAdapter {
 
    /**
     * 创建虚拟显示
     */
    public int createVirtualDisplay(IVirtualDisplayCallback callback,
            IMediaProjection projection, String packageName, String name,
            int width, int height, int densityDpi, Surface surface, int flags) {
 
        // 1. 权限检查
        if (projection == null) {
            // 需要CAPTURE_VIDEO_OUTPUT或CAPTURE_SECURE_VIDEO_OUTPUT权限
            mContext.enforceCallingOrSelfPermission(
                Manifest.permission.CAPTURE_VIDEO_OUTPUT,
                "Creating a virtual display requires CAPTURE_VIDEO_OUTPUT permission"
            );
        }
 
        // 2. 创建VirtualDisplay
        VirtualDisplayDevice device = new VirtualDisplayDevice(
            callback, projection, packageName, name,
            width, height, densityDpi, surface, flags
        );
 
        synchronized (getSyncRoot()) {
            // 3. 添加到设备列表
            mVirtualDisplayDevices.add(device);
 
            // 4. 通知DisplayManager
            sendDisplayDeviceEventLocked(device, DISPLAY_DEVICE_EVENT_ADDED);
 
            return device.getDisplayId();
        }
    }
 
    /**
     * 销毁虚拟显示
     */
    public void releaseVirtualDisplay(int displayId) {
        synchronized (getSyncRoot()) {
            VirtualDisplayDevice device = findVirtualDisplayDevice(displayId);
            if (device != null) {
                // 1. 移除设备
                mVirtualDisplayDevices.remove(device);
 
                // 2. 通知DisplayManager
                sendDisplayDeviceEventLocked(device, DISPLAY_DEVICE_EVENT_REMOVED);
 
                // 3. 销毁设备
                device.destroy();
            }
        }
    }
}

// 应用层代码：实现录屏功能
public class ScreenRecorderService extends Service {
 
    private MediaProjection mMediaProjection;
    private VirtualDisplay mVirtualDisplay;
    private MediaRecorder mMediaRecorder;
 
    /**
     * 开始录屏
     */
    public void startRecording(Intent data, int resultCode) {
        // 1. 创建MediaProjection
        MediaProjectionManager projectionManager =
            getSystemService(MediaProjectionManager.class);
        mMediaProjection = projectionManager.getMediaProjection(resultCode, data);
 
        // 2. 初始化MediaRecorder
        mMediaRecorder = new MediaRecorder();
        mMediaRecorder.setVideoSource(MediaRecorder.VideoSource.SURFACE);
        mMediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4);
        mMediaRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.H264);
        mMediaRecorder.setVideoSize(1080, 1920);
        mMediaRecorder.setVideoFrameRate(30);
        mMediaRecorder.setVideoBitRate(5 * 1024 * 1024); // 5Mbps
        mMediaRecorder.setOutputFile(getOutputFile());
 
        try {
            mMediaRecorder.prepare();
        } catch (IOException e) {
            Log.e(TAG, "Failed to prepare MediaRecorder", e);
            return;
        }
 
        // 3. 获取MediaRecorder的Surface
        Surface surface = mMediaRecorder.getSurface();
 
        // 4. 创建VirtualDisplay
        mVirtualDisplay = mMediaProjection.createVirtualDisplay(
            "ScreenRecorder",
            1080, 1920, // 宽高
            getResources().getDisplayMetrics().densityDpi,
            DisplayManager.VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR, // 自动镜像主屏幕
            surface,
            null, // callback
            null  // handler
        );
 
        // 5. 开始录制
        mMediaRecorder.start();
 
        Log.d(TAG, "Screen recording started");
    }
 
    /**
     * 停止录屏
     */
    public void stopRecording() {
        if (mMediaRecorder != null) {
            mMediaRecorder.stop();
            mMediaRecorder.release();
            mMediaRecorder = null;
        }
 
        if (mVirtualDisplay != null) {
            mVirtualDisplay.release();
            mVirtualDisplay = null;
        }
 
        if (mMediaProjection != null) {
            mMediaProjection.stop();
            mMediaProjection = null;
        }
 
        Log.d(TAG, "Screen recording stopped");
    }
 
    private File getOutputFile() {
        String timestamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date());
        String filename = "screen_record_" + timestamp + ".mp4";
        return new File(getExternalFilesDir(null), filename);
    }
}

// frameworks/base/services/core/java/com/android/server/display/WifiDisplayAdapter.java
// Android 15: Wifi Display(Miracast)适配器
 
public class WifiDisplayAdapter extends DisplayAdapter {
 
    /**
     * 连接到Wifi Display设备
     */
    public void connectWifiDisplay(String deviceAddress) {
        // 1. 建立Wifi P2P连接
        mWifiP2pManager.connect(mChannel, deviceAddress, new WifiP2pManager.ActionListener() {
            @Override
            public void onSuccess() {
                // 2. 连接成功，创建RTSP会话
                createRtspSession(deviceAddress);
            }
 
            @Override
            public void onFailure(int reason) {
                Log.e(TAG, "Failed to connect to Wifi Display: " + reason);
            }
        });
    }
 
    /**
     * 创建RTSP会话(投屏协议)
     */
    private void createRtspSession(String deviceAddress) {
        // 1. 创建VirtualDisplay
        mVirtualDisplay = mDisplayManager.createVirtualDisplay(
            "WifiDisplay",
            1920, 1080, // 1080p
            getResources().getDisplayMetrics().densityDpi,
            null, // surface (稍后设置)
            DisplayManager.VIRTUAL_DISPLAY_FLAG_PRESENTATION |
            DisplayManager.VIRTUAL_DISPLAY_FLAG_SECURE
        );
 
        // 2. 创建MediaCodec编码器(H264)
        MediaCodec encoder = MediaCodec.createEncoderByType("video/avc");
        MediaFormat format = MediaFormat.createVideoFormat("video/avc", 1920, 1080);
        format.setInteger(MediaFormat.KEY_BIT_RATE, 8 * 1024 * 1024); // 8Mbps
        format.setInteger(MediaFormat.KEY_FRAME_RATE, 60);
        format.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 1);
        encoder.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
 
        // 3. 获取编码器的输入Surface
        Surface inputSurface = encoder.createInputSurface();
 
        // 4. 将VirtualDisplay输出到编码器
        mVirtualDisplay.setSurface(inputSurface);
 
        // 5. 启动编码器
        encoder.start();
 
        // 6. 建立RTSP连接并流式传输编码数据
        startRtspStreaming(deviceAddress, encoder);
    }
 
    /**
     * 通过RTSP流式传输编码后的视频数据
     */
    private void startRtspStreaming(String deviceAddress, MediaCodec encoder) {
        // 1. 创建RTSP客户端
        RtspClient rtspClient = new RtspClient(deviceAddress, 7236);
        rtspClient.connect();
 
        // 2. 从编码器读取编码后的数据
        new Thread(() -> {
            MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
            while (true) {
                int outputBufferId = encoder.dequeueOutputBuffer(bufferInfo, 10000);
                if (outputBufferId >= 0) {
                    ByteBuffer outputBuffer = encoder.getOutputBuffer(outputBufferId);
 
                    // 3. 通过RTSP发送到显示设备
                    rtspClient.sendVideoData(outputBuffer, bufferInfo);
 
                    encoder.releaseOutputBuffer(outputBufferId, false);
                }
            }
        }).start();
    }
}

// Android 15新增：大屏设备优化
 
/**
 * 智能布局管理器
 */
public class SmartLayoutManager {
 
    /**
     * 根据屏幕大小自动选择最佳布局
     */
    public void applySmartLayout(Activity activity) {
        Configuration config = activity.getResources().getConfiguration();
 
        // 获取屏幕尺寸分类
        int screenLayout = config.screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK;
 
        if (screenLayout == Configuration.SCREENLAYOUT_SIZE_XLARGE) {
            // 超大屏(平板/折叠屏展开)
            // 推荐：分屏模式或自由窗口
            if (config.screenWidthDp >= 900) {
                // 宽度≥900dp，推荐三栏布局
                activity.setContentView(R.layout.activity_main_three_pane);
            } else {
                // 推荐两栏布局
                activity.setContentView(R.layout.activity_main_two_pane);
            }
 
        } else if (screenLayout == Configuration.SCREENLAYOUT_SIZE_LARGE) {
            // 大屏(7寸平板)
            // 推荐：两栏布局或分屏
            activity.setContentView(R.layout.activity_main_two_pane);
 
        } else {
            // 标准屏幕(手机)
            // 标准单栏布局
            activity.setContentView(R.layout.activity_main);
        }
    }
}

// Android 15新增：桌面模式完整体验
 
/**
 * 桌面模式特性
 */
public class DesktopModeFeatures {
 
    /**
     * 1. 任务栏(Taskbar)
     */
    public void showTaskbar() {
        // 类似Windows任务栏
        // - 显示所有运行中的应用图标
        // - 支持快速切换应用
        // - 支持固定常用应用
    }
 
    /**
     * 2. 窗口吸附(Window Snapping)
     */
    public void enableWindowSnapping() {
        // 拖动窗口到屏幕边缘自动吸附
        // - 左/右边缘：占据半屏
        // - 顶部：最大化
        // - 四个角：占据1/4屏幕
    }
 
    /**
     * 3. 应用切换器(Alt+Tab)
     */
    public void showAppSwitcher() {
        // 键盘快捷键切换应用
        // - Alt+Tab：顺序切换
        // - Alt+Shift+Tab：反向切换
        // - Alt+F4：关闭当前窗口
    }
 
    /**
     * 4. 窗口最小化到任务栏
     */
    public void minimizeToTaskbar(Task task) {
        // 最小化窗口不销毁Activity
        // 图标显示在任务栏
        // 点击恢复窗口
    }
 
    /**
     * 5. 多桌面/虚拟桌面
     */
    public void createVirtualDesktop() {
        // 类似macOS的Spaces
        // 用户可创建多个虚拟桌面
        // 每个桌面显示不同的应用窗口
    }
}

// 笔记应用主Activity
public class NoteActivity extends Activity {
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
 
        // 根据屏幕大小选择布局
        if (isInMultiWindowMode()) {
            // 分屏模式：紧凑布局
            setContentView(R.layout.activity_note_compact);
        } else {
            // 全屏模式：标准布局
            setContentView(R.layout.activity_note_standard);
        }
    }
 
    @Override
    public void onMultiWindowModeChanged(boolean isInMultiWindowMode,
            Configuration newConfig) {
        super.onMultiWindowModeChanged(isInMultiWindowMode, newConfig);
 
        if (isInMultiWindowMode) {
            // 切换到紧凑布局
            switchToCompactMode();
        } else {
            // 切换到标准布局
            switchToStandardMode();
        }
    }
 
    /**
     * 紧凑模式(分屏)
     */
    private void switchToCompactMode() {
        // 1. 隐藏侧边栏
        findViewById(R.id.sidebar).setVisibility(View.GONE);
 
        // 2. 工具栏显示精简按钮
        Toolbar toolbar = findViewById(R.id.toolbar);
        toolbar.getMenu().clear();
        toolbar.inflateMenu(R.menu.menu_note_compact);
 
        // 3. 编辑器宽度占满
        EditText editor = findViewById(R.id.editor);
        ViewGroup.LayoutParams params = editor.getLayoutParams();
        params.width = ViewGroup.LayoutParams.MATCH_PARENT;
        editor.setLayoutParams(params);
    }
 
    /**
     * 标准模式(全屏)
     */
    private void switchToStandardMode() {
        // 1. 显示侧边栏
        findViewById(R.id.sidebar).setVisibility(View.VISIBLE);
 
        // 2. 工具栏显示完整按钮
        Toolbar toolbar = findViewById(R.id.toolbar);
        toolbar.getMenu().clear();
        toolbar.inflateMenu(R.menu.menu_note_standard);
 
        // 3. 编辑器宽度限制
        EditText editor = findViewById(R.id.editor);
        ViewGroup.LayoutParams params = editor.getLayoutParams();
        params.width = dpToPx(800); // 最大宽度800dp
        editor.setLayoutParams(params);
    }
}

<!-- AndroidManifest.xml -->
<activity
    android:name=".NoteActivity"
    android:resizeableActivity="true"
    android:supportsPictureInPicture="true">
 
    <!-- 自由窗口大小限制 -->
    <layout
        android:defaultWidth="600dp"
        android:defaultHeight="800dp"
        android:minWidth="300dp"
        android:minHeight="400dp"
        android:gravity="center" />
</activity>

// 应用层代码：支持自由窗口拖拽调整
public class NoteActivity extends Activity {
 
    @Override
    public void onConfigurationChanged(Configuration newConfig) {
        super.onConfigurationChanged(newConfig);
 
        // 根据窗口大小调整UI
        int width = newConfig.screenWidthDp;
        int height = newConfig.screenHeightDp;
 
        if (width < 400 || height < 500) {
            // 窗口太小，显示简化UI
            showSimplifiedUI();
        } else if (width < 600) {
            // 中等窗口，显示标准UI
            showStandardUI();
        } else {
            // 大窗口，显示完整UI
            showFullUI();
        }
    }
}

// 视频笔记Activity
public class VideoNoteActivity extends Activity {
 
    /**
     * 进入画中画模式
     */
    private void enterPipMode() {
        // 1. 计算视频区域
        Rect videoRect = calculateVideoRect();
 
        // 2. 构建PIP参数
        PictureInPictureParams params = new PictureInPictureParams.Builder()
            .setAspectRatio(new Rational(16, 9))
            .setSourceRectHint(videoRect)
            .setActions(buildPipActions()) // 播放/暂停/关闭按钮
            .build();
 
        // 3. 请求进入PIP
        enterPictureInPictureMode(params);
    }
 
    @Override
    public void onPictureInPictureModeChanged(boolean isInPictureInPictureMode,
            Configuration newConfig) {
        super.onPictureInPictureModeChanged(isInPictureInPictureMode, newConfig);
 
        if (isInPictureInPictureMode) {
            // PIP模式：仅显示视频
            findViewById(R.id.note_editor).setVisibility(View.GONE);
            findViewById(R.id.toolbar).setVisibility(View.GONE);
        } else {
            // 全屏模式：显示完整UI
            findViewById(R.id.note_editor).setVisibility(View.VISIBLE);
            findViewById(R.id.toolbar).setVisibility(View.VISIBLE);
        }
    }
}

// 笔记投屏到第二屏幕
public class NotePresentationManager {
 
    private DisplayManager mDisplayManager;
    private Presentation mPresentation;
 
    /**
     * 投屏笔记到第二显示屏
     */
    public void presentNoteToSecondaryDisplay(String noteContent) {
        mDisplayManager = mContext.getSystemService(DisplayManager.class);
 
        // 1. 获取所有显示屏
        Display[] displays = mDisplayManager.getDisplays();
 
        // 2. 找到第二显示屏
        Display secondaryDisplay = null;
        for (Display display : displays) {
            if (display.getDisplayId() != Display.DEFAULT_DISPLAY) {
                secondaryDisplay = display;
                break;
            }
        }
 
        if (secondaryDisplay == null) {
            Log.w(TAG, "No secondary display found");
            return;
        }
 
        // 3. 创建Presentation
        mPresentation = new NotePresentation(mContext, secondaryDisplay, noteContent);
        mPresentation.show();
    }
 
    /**
     * 笔记Presentation
     */
    private class NotePresentation extends Presentation {
 
        private String mNoteContent;
 
        public NotePresentation(Context outerContext, Display display, String noteContent) {
            super(outerContext, display);
            mNoteContent = noteContent;
        }
 
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.presentation_note);
 
            // 显示笔记内容(大字体，适合投影)
            TextView contentView = findViewById(R.id.content);
            contentView.setText(mNoteContent);
            contentView.setTextSize(TypedValue.COMPLEX_UNIT_SP, 48);
        }
    }
}

进入PIP → 计算窗口边界 → 设置PINNED模式 → 播放动画 → 通知Activity
退出PIP → 恢复FULLSCREEN模式 → 播放动画 → 通知Activity

RootWindowContainer
    ├── DisplayContent (Display 0 - 主屏幕)
    │   └── Task列表
    ├── DisplayContent (Display 1 - 外接显示器)
    │   └── Task列表
    └── DisplayContent (Display 2 - 虚拟显示)
        └── Task列表

# WMS多窗口实现
frameworks/base/services/core/java/com/android/server/wm/
├── TaskFragment.java                # 任务片段(分屏基本单位)
├── SplitScreenController.java       # 分屏控制器
├── PinnedTaskController.java        # 画中画控制器
├── FreeformWindowController.java    # 自由窗口控制器
├── DisplayContent.java              # 显示内容管理
├── RootWindowContainer.java         # 根窗口容器
└── Task.java                        # 任务栈
 
# 显示管理
frameworks/base/services/core/java/com/android/server/display/
├── DisplayManagerService.java       # 显示管理服务
├── VirtualDisplayAdapter.java       # 虚拟显示适配器
├── WifiDisplayAdapter.java          # Wifi Display(Miracast)
└── DisplayDevice.java               # 显示设备
 
# 多窗口Shell库
frameworks/base/libs/WindowManager/Shell/src/com/android/wm/shell/
├── splitscreen/                     # 分屏模式
│   ├── SplitScreenController.java
│   └── SplitScreenDivider.java
└── pip/                             # 画中画
    ├── PipController.java
    └── PipAnimationController.java

# 分屏模式
adb shell wm set-multi-window-config --supportsNonResizable true  # 强制支持分屏
adb shell dumpsys activity activities | grep "split"              # 查看分屏状态
 
# 画中画
adb shell dumpsys activity activities | grep "PINNED"             # 查看PIP窗口
 
# 自由窗口
adb shell settings put global enable_freeform_support 1           # 启用自由窗口
adb shell settings put global force_resizable_activities 1        # 强制应用可调整大小
 
# 显示管理
adb shell dumpsys display                                         # 查看所有显示屏
adb shell wm size                                                 # 查看屏幕分辨率
adb shell wm density                                              # 查看屏幕密度
 
# 虚拟显示
adb shell dumpsys display | grep "VirtualDisplay"                # 查看虚拟显示
 
# 桌面模式(Android 15+)
adb shell settings put global enable_desktop_mode 1               # 启用桌面模式
adb shell settings put global enable_taskbar 1                    # 启用任务栏