Android 12系统源码_多窗口模式（二）系统实现分屏的功能原理 ...

泉缘泉  金牌会员 | 2024-12-6 16:20:33 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 867|帖子 867|积分 2611

媒介

上一篇我们具体分析了系统处于多窗口模式下，Android应用和多窗口模式相干方法的调用次序，对于应用如何适配多窗口模式有了一个开端的熟悉，本篇文章我们将会联合Android12系统源码，具体来梳理一下系统是如何触发多窗口分屏模式，以及实现多窗口分屏模式功能的原理。
一、Launcher3触发分屏

1、Android12的分屏模式触发入口，默认是在最近任务列表中的，而最近任务列表是包含在Launcher3内里的，当我们在最近任务列表中点击分屏按钮后，会先触发Launcher进入分屏的一系列悬浮动画以及初始的图标分屏。



以上步骤都属于Launcher的业务逻辑。
2、接下来我们联合系统源码来简朴看下Launcher3模块是如何触发分屏功能的。
   packages/apps/Launcher3/quickstep/src/com/android/launcher3/uioverrides/QuickstepLauncher.java
  1. public class QuickstepLauncher extends BaseQuickstepLauncher {
  3.     @Override
  4.     public void onStateSetEnd(LauncherState state) {
  5.         super.onStateSetEnd(state);
  6.         switch (state.ordinal) {
  7.                         ...代码省略...
  8.             case QUICK_SWITCH_STATE_ORDINAL: {
  9.                 RecentsView rv = getOverviewPanel();
  10.                 TaskView tasktolaunch = rv.getTaskViewAt(0);
  11.                 if (tasktolaunch != null) {
  12.                         //调用TaskView的launchTask方法
  13.                     tasktolaunch.launchTask(success -> {
  14.                         if (!success) {
  15.                             getStateManager().goToState(OVERVIEW);
  16.                         } else {
  17.                             getStateManager().moveToRestState();
  18.                         }
  19.                     });
  20.                 } else {
  21.                     getStateManager().goToState(NORMAL);
  22.                 }
  23.                 break;
  24.             }
  25.         }
  26.     }
  28. }
复制代码
  package/apps/Launcher3/quickstep/src/com/android/quickstep/views/GroupedTaskView.java
  1. public class GroupedTaskView extends TaskView {
  3.     @Nullable
  4.     @Override
  5.     public RunnableList launchTaskAnimated() {
  6.         if (mTask == null || mSecondaryTask == null) {
  7.             return null;
  8.         }
  10.         RunnableList endCallback = new RunnableList();
  11.         RecentsView recentsView = getRecentsView();
  12.         // Callbacks run from remote animation when recents animation not currently running
  13.         //调用RecentsView的getSplitPlaceholder方法，获取SplitSelectStateController对象实例，调用launchTasks方法
  14.         recentsView.getSplitPlaceholder().launchTasks(this /*groupedTaskView*/,
  15.                 success -> endCallback.executeAllAndDestroy(),
  16.                 false /* freezeTaskList */);
  18.         // Callbacks get run from recentsView for case when recents animation already running
  19.         recentsView.addSideTaskLaunchCallback(endCallback);
  20.         return endCallback;
  21.     }
  23.     @Override
  24.     public void launchTask(@NonNull Consumer<Boolean> callback, boolean freezeTaskList) {
  25.          //调用RecentsView的getSplitPlaceholder方法，获取SplitSelectStateController对象实例，调用launchTasks方法
  26.         getRecentsView().getSplitPlaceholder().launchTasks(mTask, mSecondaryTask,
  27.                 STAGE_POSITION_TOP_OR_LEFT, callback, freezeTaskList,
  28.                 getSplitRatio());
  29.     }
  30. }
复制代码
  package/apps/Launcher3/quickstep/src/com/android/quickstep/views/RecentsView.java
  1. public abstract class RecentsView<ACTIVITY_TYPE extends StatefulActivity<STATE_TYPE>,
  2.         STATE_TYPE extends BaseState<STATE_TYPE>> extends PagedView implements Insettable,
  3.         TaskThumbnailCache.HighResLoadingState.HighResLoadingStateChangedCallback,
  4.         TaskVisualsChangeListener, SplitScreenBounds.OnChangeListener {
  5.     public SplitSelectStateController getSplitPlaceholder() {
  6.         return mSplitSelectStateController;
  7.     }
  8. }
复制代码
  package/apps/Launcher3/quickstep/src/com/android/quickstep/util/SplitSelectStateController.java
  1. public class SplitSelectStateController {
  3.     public void launchTasks(Task task1, Task task2, @StagePosition int stagePosition,
  4.             Consumer<Boolean> callback, boolean freezeTaskList, float splitRatio) {
  5.         // Assume initial task is for top/left part of screen
  6.         final int[] taskIds = stagePosition == STAGE_POSITION_TOP_OR_LEFT
  7.                 ? new int[]{task1.key.id, task2.key.id}
  8.                 : new int[]{task2.key.id, task1.key.id};
  9.         if (TaskAnimationManager.ENABLE_SHELL_TRANSITIONS) {
  10.             RemoteSplitLaunchTransitionRunner animationRunner =
  11.                     new RemoteSplitLaunchTransitionRunner(task1, task2);
  12.             mSystemUiProxy.startTasks(taskIds[0], null /* mainOptions */, taskIds[1],
  13.                     null /* sideOptions */, STAGE_POSITION_BOTTOM_OR_RIGHT, splitRatio,
  14.                     new RemoteTransitionCompat(animationRunner, MAIN_EXECUTOR,
  15.                             ActivityThread.currentActivityThread().getApplicationThread()));
  16.         } else {
  17.             RemoteSplitLaunchAnimationRunner animationRunner =
  18.                     new RemoteSplitLaunchAnimationRunner(task1, task2, callback);
  19.             //转场动画
  20.             final RemoteAnimationAdapter adapter = new RemoteAnimationAdapter(
  21.                     RemoteAnimationAdapterCompat.wrapRemoteAnimationRunner(animationRunner),
  22.                     300, 150,
  23.                     ActivityThread.currentActivityThread().getApplicationThread());
  24.             ActivityOptions mainOpts = ActivityOptions.makeBasic();
  25.             if (freezeTaskList) {
  26.                 mainOpts.setFreezeRecentTasksReordering();
  27.             }
  28.             //调用SystemUiProxy的startTasksWithLegacyTransition方法
  29.             mSystemUiProxy.startTasksWithLegacyTransition(taskIds[0], mainOpts.toBundle(),
  30.                     taskIds[1], null /* sideOptions */, STAGE_POSITION_BOTTOM_OR_RIGHT,
  31.                     splitRatio, adapter);
  32.         }
  33.     }
  34. }
复制代码
  packages/apps/Launcher3/quickstep/src/com/android/quickstep/SystemUiProxy.java
  1. public class SystemUiProxy implements ISystemUiProxy,
  2.         SysUINavigationMode.NavigationModeChangeListener {
  3.       
  4.     public static final MainThreadInitializedObject<SystemUiProxy> INSTANCE =new MainThreadInitializedObject<>(SystemUiProxy::new);
  5.    
  6.     private ISplitScreen mSplitScreen;
  7.    
  8.     public void setProxy(ISystemUiProxy proxy, IPip pip, ISplitScreen splitScreen,
  9.             IOneHanded oneHanded, IShellTransitions shellTransitions,
  10.             IStartingWindow startingWindow, IRecentTasks recentTasks,
  11.             ISmartspaceTransitionController smartSpaceTransitionController) {
  12.         ...代码省略...
  13.         mSplitScreen = splitScreen;
  14.         ...代码省略...
  15.     ｝
  16.     /**
  17.      * 分屏模式同时打开多个任务
  18.      */
  19.     public void startTasksWithLegacyTransition(int mainTaskId, Bundle mainOptions, int sideTaskId,
  20.             Bundle sideOptions, @SplitConfigurationOptions.StagePosition int sidePosition,
  21.             float splitRatio, RemoteAnimationAdapter adapter) {
  22.         if (mSystemUiProxy != null) {
  23.             try {
  24.                  //调用ISplitScreen的startTasksWithLegacyTransition方法触发分屏
  25.                 mSplitScreen.startTasksWithLegacyTransition(mainTaskId, mainOptions, sideTaskId,
  26.                         sideOptions, sidePosition, splitRatio, adapter);
  27.             } catch (RemoteException e) {
  28.                 Log.w(TAG, "Failed call startTasksWithLegacyTransition");
  29.             }
  30.         }
  31.     }
  32.         
  33. }
复制代码
通过梳理以上代码，可以发现Launche3终极是通过调用SystemUiProxy的startTasksWithLegacyTransition方法触发分屏的，而该方法内部又进一步调用了范例为ISplitScreen的mSplitScreen对象的startTasksWithLegacyTransition方法。
3、SystemUiProxy的内部属性对象mSplitScreen最初是在TouchInteractionService的内部类TISBinder的onInitialize方法中被赋值的。
   packages/apps/Launcher3/quickstep/src/com/android/quickstep/TouchInteractionService.java
  1. public class TouchInteractionService extends Service
  2.         implements ProtoTraceable<LauncherTraceProto.Builder> {
  3.   
  4.     private final TISBinder mTISBinder = new TISBinder();
  5.             
  6.     public class TISBinder extends IOverviewProxy.Stub {
  8.         @BinderThread
  9.         public void onInitialize(Bundle bundle) {
  10.             ISystemUiProxy proxy = ISystemUiProxy.Stub.asInterface(
  11.                     bundle.getBinder(KEY_EXTRA_SYSUI_PROXY));
  12.             IPip pip = IPip.Stub.asInterface(bundle.getBinder(KEY_EXTRA_SHELL_PIP));
  13.             //触发分屏就是调用的这个对象的方法
  14.             ISplitScreen splitscreen = ISplitScreen.Stub.asInterface(bundle.getBinder(
  15.                     KEY_EXTRA_SHELL_SPLIT_SCREEN));
  16.             IOneHanded onehanded = IOneHanded.Stub.asInterface(
  17.                     bundle.getBinder(KEY_EXTRA_SHELL_ONE_HANDED));
  18.             IShellTransitions shellTransitions = IShellTransitions.Stub.asInterface(
  19.                     bundle.getBinder(KEY_EXTRA_SHELL_SHELL_TRANSITIONS));
  20.             IStartingWindow startingWindow = IStartingWindow.Stub.asInterface(
  21.                     bundle.getBinder(KEY_EXTRA_SHELL_STARTING_WINDOW));
  22.             ISmartspaceTransitionController smartspaceTransitionController =
  23.                     ISmartspaceTransitionController.Stub.asInterface(
  24.                             bundle.getBinder(KEY_EXTRA_SMARTSPACE_TRANSITION_CONTROLLER));
  25.             IRecentTasks recentTasks = IRecentTasks.Stub.asInterface(
  26.                     bundle.getBinder(KEY_EXTRA_RECENT_TASKS));
  27.             MAIN_EXECUTOR.execute(() -> {
  28.                     //调用SystemUiProxy的setProxy方法
  29.                 SystemUiProxy.INSTANCE.get(TouchInteractionService.this).setProxy(proxy, pip,
  30.                         splitscreen, onehanded, shellTransitions, startingWindow, recentTasks,
  31.                         smartspaceTransitionController);
  32.                 TouchInteractionService.this.initInputMonitor();
  33.                 preloadOverview(true /* fromInit */);
  34.             });
  35.             sIsInitialized = true;
  36.         }
  37.      }
  38.      
  39.      @Override
  40.     public IBinder onBind(Intent intent) {
  41.         Log.d(TAG, "Touch service connected: user=" + getUserId());
  42.         return mTISBinder;
  43.     }
  44. }      
复制代码
  packages/apps/Launcher3/quickstep/AndroidManifest.xml
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"
  3.      xmlns:tools="http://schemas.android.com/tools"
  4.      package="com.android.launcher3">
  5.    
  6.     <application android:backupAgent="com.android.launcher3.LauncherBackupAgent">
  8.         <service android:name="com.android.quickstep.TouchInteractionService"
  9.              android:permission="android.permission.STATUS_BAR_SERVICE"
  10.              android:directBootAware="true"
  11.              android:exported="true">
  12.             <intent-filter>
  13.                 <action android:name="android.intent.action.QUICKSTEP_SERVICE"/>
  14.             </intent-filter>
  15.         </service>
  16.         
  17.     </application>
  19. </manifest>
复制代码
TouchInteractionService是Launcher的一个服务，内部类TISBinder就是其他模块绑定TouchInteractionService服务时间所返回的IBinder范例的实例对象。
二、SystemUI触发分屏

1、默认情况下，SystemUI模块对Launcher3模块的TouchInteractionService服务举行了绑定。
   frameworks/base/packages/SystemUI/src/com/android/systemui/recents/OverviewProxyService.java
  1. public class OverviewProxyService extends CurrentUserTracker implements
  2.         CallbackController<OverviewProxyListener>, NavigationModeController.ModeChangedListener,
  3.         Dumpable {
  4.    
  5.         private final Optional<SplitScreen> mSplitScreenOptional;//触发分屏模式的关键对象
  7.         //唤起Launcher3模块TouchInteractionService的Action
  8.         private static final String ACTION_QUICKSTEP = "android.intent.action.QUICKSTEP_SERVICE";
  9.         //唤起Launcher3模块TouchInteractionService的Intent
  10.         private final Intent mQuickStepIntent;
  11.         //远程IPC通信是实现类
  12.         private IOverviewProxy mOverviewProxy;
  13.         private boolean mBound;
  14.         
  15.         public OverviewProxyService(Context context, CommandQueue commandQueue,
  16.                                     Lazy<NavigationBarController> navBarControllerLazy,
  17.                                     Lazy<Optional<StatusBar>> statusBarOptionalLazy,
  18.                                     NavigationModeController navModeController,
  19.                                     NotificationShadeWindowController statusBarWinController, SysUiState sysUiState,
  20.                                     Optional<Pip> pipOptional,
  21.                                     Optional<LegacySplitScreen> legacySplitScreenOptional,
  22.                                     Optional<SplitScreen> splitScreenOptional,
  23.                                     Optional<OneHanded> oneHandedOptional,
  24.                                     Optional<RecentTasks> recentTasks,
  25.                                     Optional<StartingSurface> startingSurface,
  26.                                     BroadcastDispatcher broadcastDispatcher,
  27.                                     ShellTransitions shellTransitions,
  28.                                     ScreenLifecycle screenLifecycle,
  29.                                     SmartspaceTransitionController smartspaceTransitionController,
  30.                                     UiEventLogger uiEventLogger,
  31.                                     DumpManager dumpManager) {
  32.             super(broadcastDispatcher);
  33.             ...代码省略...
  34.             //获取最近应用列表组件名称，其实就是Launcher3的包名
  35.             mRecentsComponentName = ComponentName.unflattenFromString(context.getString(
  36.                     com.android.internal.R.string.config_recentsComponentName));
  37.             //创建最近应用列表Activity的意图对象
  38.             mQuickStepIntent = new Intent(ACTION_QUICKSTEP).setPackage(mRecentsComponentName.getPackageName());
  39.             ...代码省略...
  40.             startConnectionToCurrentUser();
  41.             ...代码省略...
  42.         }
  43.         
  44.         //成功绑定服务所返回的ServiceConnection对象
  45.         private final ServiceConnection mOverviewServiceConnection = new ServiceConnection() {
  46.             @Override
  47.             public void onServiceConnected(ComponentName name, IBinder service) {
  48.                            ...代码省略...
  49.                     mCurrentBoundedUserId = getCurrentUserId();
  50.                     //为mOverviewProxy赋值
  51.                     mOverviewProxy = IOverviewProxy.Stub.asInterface(service);
  52.        
  53.                     Bundle params = new Bundle();
  54.                     params.putBinder(KEY_EXTRA_SYSUI_PROXY, mSysUiProxy.asBinder());
  55.                     params.putFloat(KEY_EXTRA_WINDOW_CORNER_RADIUS, mWindowCornerRadius);
  56.                     params.putBoolean(KEY_EXTRA_SUPPORTS_WINDOW_CORNERS, mSupportsRoundedCornersOnWindows);
  57.        
  58.                     mPipOptional.ifPresent((pip) -> params.putBinder(
  59.                             KEY_EXTRA_SHELL_PIP,
  60.                             pip.createExternalInterface().asBinder()));
  61.                     //关键对象，Optional对象的的ifPresent方法会判断该对象内部的SplitScreen实例对象是否为空，
  62.                     //不为空则执行回调方法，也就是把splitscreen对象实例存放到params里面。
  63.                     mSplitScreenOptional.ifPresent((splitscreen) -> params.putBinder(
  64.                             KEY_EXTRA_SHELL_SPLIT_SCREEN,
  65.                             splitscreen.createExternalInterface().asBinder()));
  66.                     mOneHandedOptional.ifPresent((onehanded) -> params.putBinder(
  67.                             KEY_EXTRA_SHELL_ONE_HANDED,
  68.                             onehanded.createExternalInterface().asBinder()));
  69.                     params.putBinder(KEY_EXTRA_SHELL_SHELL_TRANSITIONS,
  70.                             mShellTransitions.createExternalInterface().asBinder());
  71.                     mStartingSurface.ifPresent((startingwindow) -> params.putBinder(
  72.                             KEY_EXTRA_SHELL_STARTING_WINDOW,
  73.                             startingwindow.createExternalInterface().asBinder()));
  74.                     params.putBinder(
  75.                             KEY_EXTRA_SMARTSPACE_TRANSITION_CONTROLLER,
  76.                             mSmartspaceTransitionController.createExternalInterface().asBinder());
  77.                     mRecentTasks.ifPresent(recentTasks -> params.putBinder(
  78.                             KEY_EXTRA_RECENT_TASKS,
  79.                             recentTasks.createExternalInterface().asBinder()));
  80.        
  81.                     try {
  82.                             //调用mOverviewProxy的onInitialize，为相关参数进行服务
  83.                         mOverviewProxy.onInitialize(params);
  84.                     } catch (RemoteException e) {
  85.                         mCurrentBoundedUserId = -1;
  86.                         Log.e(TAG_OPS, "ServiceConnection Failed to call onInitialize()", e);
  87.                     }
  88.                     dispatchNavButtonBounds();
  90.                     // Force-update the systemui state flags
  91.                     updateSystemUiStateFlags();
  92.                     notifySystemUiStateFlags(mSysUiState.getFlags());
  93.        
  94.                     notifyConnectionChanged();
  95.             }
  96.             
  97.         };
  98.    
  99.             public void startConnectionToCurrentUser() {
  100.                 if (mHandler.getLooper() != Looper.myLooper()) {
  101.                     mHandler.post(mConnectionRunnable);
  102.                 } else {
  103.                     internalConnectToCurrentUser();
  104.                 }
  105.             }
  107.         private void internalConnectToCurrentUser() {
  108.             ...代码省略...      
  109.             Intent launcherServiceIntent = new Intent(ACTION_QUICKSTEP)
  110.                     .setPackage(mRecentsComponentName.getPackageName());
  111.             try {
  112.                 //绑定服务
  113.                 mBound = mContext.bindServiceAsUser(launcherServiceIntent,
  114.                         mOverviewServiceConnection,
  115.                         Context.BIND_AUTO_CREATE | Context.BIND_FOREGROUND_SERVICE_WHILE_AWAKE,
  116.                         UserHandle.of(getCurrentUserId()));
  117.             } catch (SecurityException e) {
  118.                 Log.e(TAG_OPS, "Unable to bind because of security error", e);
  119.             }
  120.             ...代码省略...
  121.         }
  122.    
  123.         public IOverviewProxy getProxy() {
  124.             return mOverviewProxy;
  125.         }        
  126.                            
  127.     }
复制代码
SystemUI模块的OverviewProxyService类的构造方法会对Launche3模块的TouchInteractionService服务举行绑定，并把调用该服务返回的Binder对象的onInitialize，将Launcher3模块必要的相干参数传了过去，这样Launch3模块才能拿到ISplitScreen的实例对象，通过调用该实例对象的startTasksWithLegacyTransition方法，终极触发分屏模式。那么问题有来了，OverviewProxyService内里的ISplitScreen对象实例是如何被赋值的？
2、重新再来看下OverviewProxyService的构造方法，这次我们重点关注一下mSplitScreenOptional这个对象。
  1. public class OverviewProxyService extends CurrentUserTracker implements
  2.         CallbackController<OverviewProxyListener>, NavigationModeController.ModeChangedListener,
  3.         Dumpable {
  4.    
  5.     private final Optional<SplitScreen> mSplitScreenOptional;//触发分屏模式的关键对象
  6.    
  7.     @Inject//Dagger2框架注解
  8.     public OverviewProxyService(Context context, CommandQueue commandQueue,
  9.             Lazy<NavigationBarController> navBarControllerLazy,
  10.             Lazy<Optional<StatusBar>> statusBarOptionalLazy,
  11.             NavigationModeController navModeController,
  12.             NotificationShadeWindowController statusBarWinController, SysUiState sysUiState,
  13.             Optional<Pip> pipOptional,
  14.             Optional<LegacySplitScreen> legacySplitScreenOptional,
  15.             Optional<SplitScreen> splitScreenOptional,
  16.             Optional<OneHanded> oneHandedOptional,
  17.             Optional<RecentTasks> recentTasks,
  18.             Optional<StartingSurface> startingSurface,
  19.             BroadcastDispatcher broadcastDispatcher,
  20.             ShellTransitions shellTransitions,
  21.             ScreenLifecycle screenLifecycle,
  22.             SmartspaceTransitionController smartspaceTransitionController,
  23.             UiEventLogger uiEventLogger,
  24.             DumpManager dumpManager) {
  25.         super(broadcastDispatcher);
  26.         ...代码省略...
  27.         mSplitScreenOptional = splitScreenOptional;//为mSplitScreenOptional赋值
  28.         ...代码省略...
  29.     }
  31.     private final ServiceConnection mOverviewServiceConnection = new ServiceConnection() {
  32.             @Override
  33.             public void onServiceConnected(ComponentName name, IBinder service) {
  34.                            ...代码省略...
  35.                     mSplitScreenOptional.ifPresent((splitscreen) -> params.putBinder(
  36.                             KEY_EXTRA_SHELL_SPLIT_SCREEN,
  37.                             //这里调用splitscreen的createExternalInterface方法
  38.                             splitscreen.createExternalInterface().asBinder()));
  39.                   ...代码省略...
  40.                     }
  41.             }
  42. }
复制代码
OverviewProxyService的构造方法有一个关键注解 @Inject，这个注解是Dagger2的框架注解，该框架会根据我们的配置，当我们必要在某个对象的构造方法中传入特定参数对象的时间，只要添加@Inject注解，该框架会自动帮我们创建参数对象并传入。关于这个框架的原理，我在Android 12系统源码_SystemUI（一）SystemUI的启动流程这篇博客具体分析过，这里不做过多解释。
3、由于后续会多次提到Optional这种范例的数据范例，这里我们必要先简朴看下这个类的相干代码。
  1. public final class Optional<T> {
  3.     private static final Optional<?> EMPTY = new Optional<>();
  4.         //内部包含的真正对象
  5.     private final T value;
  6.    
  7.     private Optional(T value) {
  8.         this.value = Objects.requireNonNull(value);
  9.     }
  10.    
  11.     //如果内部对象不为空，则执行consumer方法
  12.     public void ifPresent(Consumer<? super T> consumer) {
  13.         if (value != null)
  14.             consumer.accept(value);
  15.     }
  17.         //如果内部对象为空，则返回空对象，执行mapper方法，并将该方法返回的对象封装成Optional<T>类型返回。
  18.     public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {
  19.         Objects.requireNonNull(mapper);
  20.         if (!isPresent())
  21.             return empty();
  22.         else {
  23.             return Optional.ofNullable(mapper.apply(value));
  24.         }
  25.     }
  26. }
复制代码
4、关于Optional这个对象的dagger2框架的配置信息，SystemUI配置在WMComponent这个接口内里的。
   frameworks/base/packages/SystemUI/src/com/android/systemui/dagger/WMComponent.java
  1. import com.android.wm.shell.dagger.WMShellModule;
  3. @WMSingleton//单例
  4. @Subcomponent(modules = {WMShellModule.class})//需要进一步结合WMShellModule做分析
  5. public interface WMComponent {
  7.     /**
  8.      * Initializes all the WMShell components before starting any of the SystemUI components.
  9.      * 在初始化SystemUI组件之前，优先初始化WMShell模块的所有组件
  10.      */
  11.     default void init() {
  12.             //调用ShellInit的init，这个方法需要额外关注一下，后续我们会再次提到
  13.         getShellInit().init();
  14.     }
  16.         //获取ShellInit对象实例
  17.     @WMSingleton
  18.     ShellInit getShellInit();
  20.         //获取Optional<SplitScreen>对象实例
  21.     @WMSingleton
  22.     Optional<SplitScreen> getSplitScreen();
  24. }
复制代码


  • 有了以上配置信息，SystemUI模块的任何类的构造方法只要加上 @Inject注解，我们就可以在该对象的构造方法中拿到WMComponent 中返回的对象实例了。
  • 联合getShellInit方法和init方法我们可以知道，SystemUI模块在初始化该模块的SystemUI组件之前，会先初始化WMShell模块的组件，这就意味着SystemUI模块的组件都能拿到WMShell模块的组件，并调用对应的组件所提供的功能。
  • 而Optional到底是如何被创建出来的，这就必要我们进一步查看WMComponent的类注解@Subcomponent指向的WMShellModule这个类的相干代码了。
三、WMShell模块触发分屏

1、SystemUI模块终极是通过WindowManager模块下的Shell模块触发分屏功能的，来看下前面SystemUI模块中dagger2注解框架引用到的WMShellModule这个类。
   frameworks/base/libs/WindowManager/Shell/src/com/android/wm/shell/dagger/WMShellModule.java
  1. import com.android.wm.shell.splitscreen.SplitScreenController;
  3. @Module(includes = WMShellBaseModule.class)//需要进一步结合WMShellBaseModule做分析
  4. public class WMShellModule {
  6.     @WMSingleton
  7.     @Provides
  8.     @DynamicOverride
  9.     static SplitScreenController provideSplitScreenController(
  10.             ShellTaskOrganizer shellTaskOrganizer,
  11.             SyncTransactionQueue syncQueue, Context context,
  12.             RootTaskDisplayAreaOrganizer rootTaskDisplayAreaOrganizer,
  13.             @ShellMainThread ShellExecutor mainExecutor,
  14.             DisplayImeController displayImeController,
  15.             DisplayInsetsController displayInsetsController, Transitions transitions,
  16.             TransactionPool transactionPool, IconProvider iconProvider,
  17.             Optional<RecentTasksController> recentTasks,
  18.             Provider<Optional<StageTaskUnfoldController>> stageTaskUnfoldControllerProvider) {
  19.         //创建SplitScreenController对象实例
  20.         return new SplitScreenController(shellTaskOrganizer, syncQueue, context,
  21.                 rootTaskDisplayAreaOrganizer, mainExecutor, displayImeController,
  22.                 displayInsetsController, transitions, transactionPool, iconProvider,
  23.                 recentTasks, stageTaskUnfoldControllerProvider);
  24.     }
  25.    
  26.     //这个方法我们需要关注一下，后面会提到
  27.     @WMSingleton
  28.     @Provides
  29.     static ShellInit provideShellInit(ShellInitImpl impl) {
  30.             //调用ShellInitImpl的asShellInit方法返回ShellInit对象实例
  31.         return impl.asShellInit();
  32.     }
  34.     @WMSingleton
  35.     @Provides
  36.     static ShellInitImpl provideShellInitImpl(DisplayController displayController,
  37.             DisplayImeController displayImeController,
  38.             DisplayInsetsController displayInsetsController,
  39.             DragAndDropController dragAndDropController,
  40.             ShellTaskOrganizer shellTaskOrganizer,
  41.             Optional<BubbleController> bubblesOptional,
  42.             Optional<SplitScreenController> splitScreenOptional,
  43.             Optional<AppPairsController> appPairsOptional,
  44.             Optional<PipTouchHandler> pipTouchHandlerOptional,
  45.             FullscreenTaskListener fullscreenTaskListener,
  46.             Optional<FullscreenUnfoldController> appUnfoldTransitionController,
  47.             Optional<FreeformTaskListener> freeformTaskListener,
  48.             Optional<RecentTasksController> recentTasksOptional,
  49.             Transitions transitions,
  50.             StartingWindowController startingWindow,
  51.             @ShellMainThread ShellExecutor mainExecutor) {
  52.         //创建ShellInitImpl的对象实例
  53.         return new ShellInitImpl(displayController,
  54.                 displayImeController,
  55.                 displayInsetsController,
  56.                 dragAndDropController,
  57.                 shellTaskOrganizer,
  58.                 bubblesOptional,
  59.                 splitScreenOptional,
  60.                 appPairsOptional,
  61.                 pipTouchHandlerOptional,
  62.                 fullscreenTaskListener,
  63.                 appUnfoldTransitionController,
  64.                 freeformTaskListener,
  65.                 recentTasksOptional,
  66.                 transitions,
  67.                 startingWindow,
  68.                 mainExecutor);
  69.     }
  70. }
复制代码
由于WMShellModule的类注解有依赖@Module(includes = WMShellBaseModule.class)，要想完全搞明确Optional对象实例是如何被创建的，我们必要进一步联合WMShellBaseModule做分析。
2、WMShellBaseModule的关键代码如下所示。
   frameworks/base/libs/WindowManager/Shell/src/com/android/wm/shell/dagger/WMShellBaseModule.java
  1. @Module(includes = WMShellConcurrencyModule.class)
  2. public abstract class WMShellBaseModule {
  4.     @WMSingleton
  5.     @Provides
  6.     static Optional<SplitScreen> provideSplitScreen(
  7.             Optional<SplitScreenController> splitScreenController) {
  8.             //结合前面Optional<T>这个类的代码可以知道，调用splitScreenController对象的asSplitScreen方法，并将该方法返回的SplitScreen对                        象实例封装成Optional<SplitScreen>类型的对象再返回。
  9.         return splitScreenController.map((controller) -> controller.asSplitScreen());
  10.     }
  12.     @WMSingleton
  13.     @Provides
  14.     static Optional<SplitScreenController> providesSplitScreenController(
  15.             @DynamicOverride Optional<SplitScreenController> splitscreenController,
  16.             Context context) {
  17.          //AMS是否支持多窗口模式，支持才返回SplitScreenController对象实例，否则返回空
  18.         if (ActivityTaskManager.supportsSplitScreenMultiWindow(context)) {
  19.             return splitscreenController;
  20.         }
  21.         return Optional.empty();
  22.     }
  23. }
复制代码


  • WMShellBaseModule的provideSplitScreen方法先是获取SplitScreenController对象实例，该对象是通过WMShellModule的provideSplitScreenController方法创建，但是会经过providesSplitScreenController做一层封装，只有当系统开启了支持多窗口模式的开关，也就是AMS支持多窗口模式的时间，才能拿到该对象实例，否则拿到的都是空
  • provideSplitScreen方法在得到该对象实例后，通过调用该对象的asSplitScreen方法，得到了SplitScreen对象实例，但是终极返回的是封装成Optional范例的对象实例返回的。
    到这里我们终于可以确定是SplitScreenController的asSplitScreen方法创建了SplitScreen对象实例。
3、接下来我们继续来梳理一下ISplitScreen和SplitScreenController类相干的代码。
   frameworks/base/libs/WindowManager/Shell/src/com/android/wm/shell/splitscreen/ISplitScreen.aidl
  1. interface ISplitScreen {
  3.     oneway void registerSplitScreenListener(in ISplitScreenListener listener) = 1;
  4.    
  5.     oneway void unregisterSplitScreenListener(in ISplitScreenListener listener) = 2;
  7.     oneway void setSideStageVisibility(boolean visible) = 3;
  9.     oneway void removeFromSideStage(int taskId) = 4;
  11.     oneway void exitSplitScreen(int toTopTaskId) = 5;
  13.     oneway void exitSplitScreenOnHide(boolean exitSplitScreenOnHide) = 6;
  14.    
  15.     oneway void startTask(int taskId, int position, in Bundle options) = 7;
  16.    
  17.     oneway void startShortcut(String packageName, String shortcutId, int position,
  18.             in Bundle options, in UserHandle user) = 8;
  20.     oneway void startIntent(in PendingIntent intent, in Intent fillInIntent, int position,
  21.             in Bundle options) = 9;
  22.             
  23.     oneway void startTasks(int mainTaskId, in Bundle mainOptions, int sideTaskId,
  24.             in Bundle sideOptions, int sidePosition, float splitRatio,
  25.             in RemoteTransition remoteTransition) = 10;
  26.             
  27.      oneway void startTasksWithLegacyTransition(int mainTaskId, in Bundle mainOptions,
  28.                             int sideTaskId, in Bundle sideOptions, int sidePosition,
  29.                             float splitRatio, in RemoteAnimationAdapter adapter) = 11;
  32. }
复制代码
  frameworks/base/libs/WindowManager/Shell/src/com/android/wm/shell/splitscreen/SplitScreenController.java
  1. public class SplitScreenController implements DragAndDropPolicy.Starter, RemoteCallable<SplitScreenController> {
  3.         private final SplitScreenImpl mImpl = new SplitScreenImpl();
  4.    
  5.     private StageCoordinator mStageCoordinator;
  6.    
  7.         public SplitScreenController(ShellTaskOrganizer shellTaskOrganizer,
  8.             SyncTransactionQueue syncQueue, Context context,
  9.             RootTaskDisplayAreaOrganizer rootTDAOrganizer,
  10.             ShellExecutor mainExecutor, DisplayImeController displayImeController,
  11.             DisplayInsetsController displayInsetsController,
  12.             Transitions transitions, TransactionPool transactionPool, IconProvider iconProvider,
  13.             Optional<RecentTasksController> recentTasks,
  14.             Provider<Optional<StageTaskUnfoldController>> unfoldControllerProvider) {
  15.                 ...代码省略...
  16.     }
  17.    
  18.     public SplitScreen asSplitScreen() {
  19.         return mImpl;
  20.     }
  21.        
  22.         //这个方法最初是被ShellInitImpl调用的
  23.     public void onOrganizerRegistered() {
  24.         if (mStageCoordinator == null) {
  25.             //创建触发分屏功能的重要对象StageCoordinator的实例。
  26.             mStageCoordinator = new StageCoordinator(mContext, DEFAULT_DISPLAY, mSyncQueue,
  27.                     mRootTDAOrganizer, mTaskOrganizer, mDisplayImeController,
  28.                     mDisplayInsetsController, mTransitions, mTransactionPool, mLogger,
  29.                     mIconProvider, mRecentTasksOptional, mUnfoldControllerProvider);
  30.         }
  31.     }   
  33.     //SplitScreen是一个接口，具体实现是内部类SplitScreenImpl
  34.     @ExternalThread
  35.     private class SplitScreenImpl implements SplitScreen {
  36.         private ISplitScreenImpl mISplitScreen;
  37.         private final ArrayMap<SplitScreenListener, Executor> mExecutors = new ArrayMap<>();
  38.         private final SplitScreen.SplitScreenListener mListener = new SplitScreenListener() {
  39.       
  40.             @Override
  41.             public void onStagePositionChanged(int stage, int position) {
  42.                               ...代码省略...
  43.             }
  45.             @Override
  46.             public void onTaskStageChanged(int taskId, int stage, boolean visible) {
  47.                               ...代码省略...
  48.             }
  50.             @Override
  51.             public void onSplitVisibilityChanged(boolean visible) {
  52.                               ...代码省略...
  53.             }
  54.         };
  56.         @Override
  57.         public ISplitScreen createExternalInterface() {
  58.             if (mISplitScreen != null) {
  59.                 mISplitScreen.invalidate();
  60.             }
  61.             mISplitScreen = new ISplitScreenImpl(SplitScreenController.this);
  62.                    //返回实现了ISplitScreen接口的对象实例
  63.             return mISplitScreen;
  64.         }
  66.     }
  68.         //ISplitScreen是一个aidl，内部类ISplitScreenImpl实现了ISplitScreen的接口方法。
  69.     @BinderThread
  70.     private static class ISplitScreenImpl extends ISplitScreen.Stub {
  71.         private SplitScreenController mController;
  72.         private final SingleInstanceRemoteListener<SplitScreenController,
  73.                 ISplitScreenListener> mListener;
  74.         private final SplitScreen.SplitScreenListener mSplitScreenListener =
  75.                 new SplitScreen.SplitScreenListener() {
  76.                     @Override
  77.                     public void onStagePositionChanged(int stage, int position) {
  78.                         mListener.call(l -> l.onStagePositionChanged(stage, position));
  79.                     }
  81.                     @Override
  82.                     public void onTaskStageChanged(int taskId, int stage, boolean visible) {
  83.                         mListener.call(l -> l.onTaskStageChanged(taskId, stage, visible));
  84.                     }
  85.                 };
  87.         public ISplitScreenImpl(SplitScreenController controller) {
  88.             mController = controller;
  89.             mListener = new SingleInstanceRemoteListener<>(controller,
  90.                     c -> c.registerSplitScreenListener(mSplitScreenListener),
  91.                     c -> c.unregisterSplitScreenListener(mSplitScreenListener));
  92.         }
  94.         void invalidate() {
  95.             mController = null;
  96.         }
  98.         @Override
  99.         public void startTasksWithLegacyTransition(int mainTaskId, @Nullable Bundle mainOptions,
  100.                 int sideTaskId, @Nullable Bundle sideOptions, @SplitPosition int sidePosition,
  101.                 float splitRatio, RemoteAnimationAdapter adapter) {
  102.             //这里显示进行权限确认，然后会调用StageCoordinator的startTasksWithLegacyTransition方法。
  103.             executeRemoteCallWithTaskPermission(mController, "startTasks",
  104.                     (controller) -> controller.mStageCoordinator.startTasksWithLegacyTransition(
  105.                             mainTaskId, mainOptions, sideTaskId, sideOptions, sidePosition,
  106.                             splitRatio, adapter));
  107.         }
  108.     }
  110. }
复制代码


  • SplitScreenController的asSplitScreen方法返回了该类的一个内部对象SplitScreenImpl，SplitScreenImpl实现了SplitScreen这个接口的相干方法。
  • 前面第二节第1步OverviewProxyService类中我们有提到，SystemUI在成功绑定Launcher3模块的TouchInteractionService服务的时间，调用了SplitScreen 的createExternalInterface方法，联合这里我们可以知道此方法返回ISplitScreenImpl对象实例，此对象实现了ISplitScreen.aidl文件中声明的接口方法，Launcher3终极得以跨进程调用ISplitScreenImpl的startTasksWithLegacyTransition方法，终极触发分屏模式。
  • ISplitScreenImpl的startTasksWithLegacyTransition方法内部先是做了个权限判断，终极是调用了SplitScreenController的范例为StageCoordinator的内部对象mStageCoordinator的startTasksWithLegacyTransition方法。
  • SplitScreenController的内部属性对象mStageCoordinator是在onOrganizerRegistered方法中被赋值的，该方法最初是被ShellInitImpl对象触发的。
4、来看下ShellInitImpl的相干代码。
   frameworks/base/libs/WindowManager/Shell/src/com/android/wm/shell/ShellInitImpl.java
  1. public class ShellInitImpl {
  2.     private static final String TAG = ShellInitImpl.class.getSimpleName();
  4.     private final Optional<SplitScreenController> mSplitScreenOptional;
  6.     private final InitImpl mImpl = new InitImpl();
  8.     public ShellInitImpl(
  9.             DisplayController displayController,
  10.             DisplayImeController displayImeController,
  11.             DisplayInsetsController displayInsetsController,
  12.             DragAndDropController dragAndDropController,
  13.             ShellTaskOrganizer shellTaskOrganizer,
  14.             Optional<BubbleController> bubblesOptional,
  15.             Optional<SplitScreenController> splitScreenOptional,
  16.             Optional<AppPairsController> appPairsOptional,
  17.             Optional<PipTouchHandler> pipTouchHandlerOptional,
  18.             FullscreenTaskListener fullscreenTaskListener,
  19.             Optional<FullscreenUnfoldController> fullscreenUnfoldTransitionController,
  20.             Optional<FreeformTaskListener> freeformTaskListenerOptional,
  21.             Optional<RecentTasksController> recentTasks,
  22.             Transitions transitions,
  23.             StartingWindowController startingWindow,
  24.             ShellExecutor mainExecutor) {
  25.                 ...代码省略...
  26.         mSplitScreenOptional = splitScreenOptional;
  27.                 ...代码省略...
  28.     }
  30.     public ShellInit asShellInit() {
  31.         return mImpl;
  32.     }
  34.     private void init() {
  35.                 ...代码省略...
  36.         mSplitScreenOptional.ifPresent(SplitScreenController::onOrganizerRegistered);
  37.                 ...代码省略...
  38.     }
  40.     @ExternalThread
  41.     private class InitImpl implements ShellInit {
  42.         @Override
  43.         public void init() {
  44.             try {
  45.                     //进一步调用ShellInitImpl的Init方法。
  46.                 mMainExecutor.executeBlocking(() -> ShellInitImpl.this.init());
  47.             } catch (InterruptedException e) {
  48.                 throw new RuntimeException("Failed to initialize the Shell in 2s", e);
  49.             }
  50.         }
  51.     }
  52. }
复制代码
四、SystemUI模块初始化分屏组件

1、前面第三节第1步WMShellModule类中，我们有提到过和ShellInitImpl对象创建有关的代码。
  1. import com.android.wm.shell.splitscreen.SplitScreenController;
  3. @Module(includes = WMShellBaseModule.class)
  4. public class WMShellModule {
  5.    
  6.     @WMSingleton
  7.     @Provides
  8.     static ShellInit provideShellInit(ShellInitImpl impl) {
  9.             //调用ShellInitImpl的asShellInit方法返回ShellInit对象实例
  10.         return impl.asShellInit();
  11.     }
  12.    
  13.     @WMSingleton
  14.     @Provides
  15.     static ShellInitImpl provideShellInitImpl(DisplayController displayController,
  16.             DisplayImeController displayImeController,
  17.             DisplayInsetsController displayInsetsController,
  18.             DragAndDropController dragAndDropController,
  19.             ShellTaskOrganizer shellTaskOrganizer,
  20.             Optional<BubbleController> bubblesOptional,
  21.             Optional<SplitScreenController> splitScreenOptional,
  22.             Optional<AppPairsController> appPairsOptional,
  23.             Optional<PipTouchHandler> pipTouchHandlerOptional,
  24.             FullscreenTaskListener fullscreenTaskListener,
  25.             Optional<FullscreenUnfoldController> appUnfoldTransitionController,
  26.             Optional<FreeformTaskListener> freeformTaskListener,
  27.             Optional<RecentTasksController> recentTasksOptional,
  28.             Transitions transitions,
  29.             StartingWindowController startingWindow,
  30.             @ShellMainThread ShellExecutor mainExecutor) {
  31.         //创建ShellInitImpl的对象实例
  32.         return new ShellInitImpl(displayController,
  33.                 displayImeController,
  34.                 displayInsetsController,
  35.                 dragAndDropController,
  36.                 shellTaskOrganizer,
  37.                 bubblesOptional,
  38.                 splitScreenOptional,
  39.                 appPairsOptional,
  40.                 pipTouchHandlerOptional,
  41.                 fullscreenTaskListener,
  42.                 appUnfoldTransitionController,
  43.                 freeformTaskListener,
  44.                 recentTasksOptional,
  45.                 transitions,
  46.                 startingWindow,
  47.                 mainExecutor);
  48.     }
  49. }
复制代码
2、前面第二节第4步WMComponent类中，我们有提到SystemUI模块在初始化SystemUI模块的组件之前，会先初始化WMShell模块的所有组件，这自然也包罗分屏组件。
  1. @WMSingleton//单例
  2. @Subcomponent(modules = {WMShellModule.class})
  3. public interface WMComponent {
  5.     /**
  6.      * Initializes all the WMShell components before starting any of the SystemUI components.
  7.      * 在初始化SystemUI组件之前，优先初始化WMShell模块的所有组件
  8.      */
  9.     default void init() {
  10.             //调用ShellInit的init
  11.         getShellInit().init();
  12.     }
  14.         //获取ShellInit对象实例
  15.     @WMSingleton
  16.     ShellInit getShellInit();
  18. }
复制代码
WMComponent的init方法先是通过getShellInit方法获取到ShellInit对象实例，InitImpl实现了ShellInit这个接口，
并实现了init方法，该方法会进一步调用ShellInitImpl的init方法，终极会触发SplitScreenController的onOrganizerRegistered方法。
3、SplitScreenController的onOrganizerRegistered方法会创建控制分屏功能的分屏组件StageCoordinator的对象实例。
  1. public class SplitScreenController implements DragAndDropPolicy.Starter, RemoteCallable<SplitScreenController> {
  3.     private StageCoordinator mStageCoordinator;
  4.    
  5.         //这个方法最初是被ShellInitImpl调用的
  6.     public void onOrganizerRegistered() {
  7.         if (mStageCoordinator == null) {
  8.             //创建触发分屏功能的重要对象StageCoordinator的实例。
  9.             mStageCoordinator = new StageCoordinator(mContext, DEFAULT_DISPLAY, mSyncQueue,
  10.                     mRootTDAOrganizer, mTaskOrganizer, mDisplayImeController,
  11.                     mDisplayInsetsController, mTransitions, mTransactionPool, mLogger,
  12.                     mIconProvider, mRecentTasksOptional, mUnfoldControllerProvider);
  13.         }
  14.     }   
  15. }
复制代码
4、StageCoordinator的构造方法如下所示。
  1. class StageCoordinator implements SplitLayout.SplitLayoutHandler,
  2.         RootTaskDisplayAreaOrganizer.RootTaskDisplayAreaListener, Transitions.TransitionHandler {
  4.     StageCoordinator(Context context, int displayId, SyncTransactionQueue syncQueue,
  5.             RootTaskDisplayAreaOrganizer rootTDAOrganizer, ShellTaskOrganizer taskOrganizer,
  6.             DisplayImeController displayImeController,
  7.             DisplayInsetsController displayInsetsController, Transitions transitions,
  8.             TransactionPool transactionPool, SplitscreenEventLogger logger,
  9.             Provider<Optional<StageTaskUnfoldController>> unfoldControllerProvider) {
  10.         mContext = context;
  11.         mDisplayId = displayId;
  12.         mSyncQueue = syncQueue;
  13.         mRootTDAOrganizer = rootTDAOrganizer;
  14.         mTaskOrganizer = taskOrganizer;
  15.         mLogger = logger;
  16.         mMainUnfoldController = unfoldControllerProvider.get().orElse(null);
  17.         mSideUnfoldController = unfoldControllerProvider.get().orElse(null);
  18.                 //分屏对象
  19.         mMainStage = new MainStage(
  20.                 mTaskOrganizer,
  21.                 mDisplayId,
  22.                 mMainStageListener,
  23.                 mSyncQueue,
  24.                 mSurfaceSession,
  25.                 mMainUnfoldController);
  26.          //分屏对象
  27.         mSideStage = new SideStage(
  28.                 mContext,
  29.                 mTaskOrganizer,
  30.                 mDisplayId,
  31.                 mSideStageListener,
  32.                 mSyncQueue,
  33.                 mSurfaceSession,
  34.                 mSideUnfoldController);
  35.         mDisplayImeController = displayImeController;
  36.         mDisplayInsetsController = displayInsetsController;
  37.         mDisplayInsetsController.addInsetsChangedListener(mDisplayId, mSideStage);
  38.         mRootTDAOrganizer.registerListener(displayId, this);
  39.         final DeviceStateManager deviceStateManager =
  40.                 mContext.getSystemService(DeviceStateManager.class);
  41.         deviceStateManager.registerCallback(taskOrganizer.getExecutor(),
  42.                 new DeviceStateManager.FoldStateListener(mContext, this::onFoldedStateChanged));
  43.         mSplitTransitions = new SplitScreenTransitions(transactionPool, transitions,
  44.                 mOnTransitionAnimationComplete);
  45.         transitions.addHandler(this);
  46.     }
  48. }
复制代码
由此可知，SystemUI在进程初始化阶段就已经准备好分屏所必要的 MainStage和SideStage 对象，这两个对象很紧张，分别负责分屏的一边，对象内部会创建一个 RootTask 节点了（这里利用了WindowOrganizer框架的能力），这个RootTask就是分屏的关键，通过把应用的Task节点挂载到RootTask下，然后修改RootTask节点的Bounds来改变应用显示的巨细。
五、WMShell模块触发分屏

1、前面第三步第4节我们有做过分析，Launcher3经过层层调用，终极是调用StageCoordinator的startTasksWithLegacyTransition方法触发分屏功能的，继续来看下StageCoordinator的startTasksWithLegacyTransition方法。
  1. class StageCoordinator implements SplitLayout.SplitLayoutHandler,
  2.         RootTaskDisplayAreaOrganizer.RootTaskDisplayAreaListener, Transitions.TransitionHandler {
  3.    
  4.     private final ShellTaskOrganizer mTaskOrganizer;
  5.      
  6.     StageCoordinator(Context context, int displayId, SyncTransactionQueue syncQueue,
  7.             RootTaskDisplayAreaOrganizer rootTDAOrganizer, ShellTaskOrganizer taskOrganizer,
  8.             DisplayImeController displayImeController,
  9.             DisplayInsetsController displayInsetsController, Transitions transitions,
  10.             TransactionPool transactionPool, SplitscreenEventLogger logger,
  11.             IconProvider iconProvider,
  12.             Optional<RecentTasksController> recentTasks,
  13.             Provider<Optional<StageTaskUnfoldController>> unfoldControllerProvider) {
  14.         mContext = context;
  15.         mDisplayId = displayId;
  16.         mSyncQueue = syncQueue;
  17.         mRootTDAOrganizer = rootTDAOrganizer;
  18.         mTaskOrganizer = taskOrganizer;//为mTaskOrganizer赋值
  19.              ...代码省略...
  20.     }
  22.     //Launcher3其实是调用了这个方法触发分屏模式的
  23.     void startTasksWithLegacyTransition(int mainTaskId, @Nullable Bundle mainOptions,
  24.             int sideTaskId, @Nullable Bundle sideOptions, @SplitPosition int sidePosition,
  25.             float splitRatio, RemoteAnimationAdapter adapter) {
  26.         // Init divider first to make divider leash for remote animation target.
  27.         setDividerVisibility(true /* visible */);//设置分屏中间的分割线View可见
  28.         // Set false to avoid record new bounds with old task still on top;
  29.         mShouldUpdateRecents = false;
  30.         final WindowContainerTransaction wct = new WindowContainerTransaction();
  31.         final WindowContainerTransaction evictWct = new WindowContainerTransaction();
  32.         prepareEvictChildTasks(SPLIT_POSITION_TOP_OR_LEFT, evictWct);
  33.         prepareEvictChildTasks(SPLIT_POSITION_BOTTOM_OR_RIGHT, evictWct);
  34.         // Need to add another wrapper here in shell so that we can inject the divider bar
  35.         // and also manage the process elevation via setRunningRemote
  36.         IRemoteAnimationRunner wrapper = new IRemoteAnimationRunner.Stub() {
  37.             @Override
  38.             public void onAnimationStart(@WindowManager.TransitionOldType int transit,
  39.                     RemoteAnimationTarget[] apps,
  40.                     RemoteAnimationTarget[] wallpapers,
  41.                     RemoteAnimationTarget[] nonApps,
  42.                     final IRemoteAnimationFinishedCallback finishedCallback) {
  43.                 mIsDividerRemoteAnimating = true;
  44.                 RemoteAnimationTarget[] augmentedNonApps =
  45.                         new RemoteAnimationTarget[nonApps.length + 1];
  46.                 for (int i = 0; i < nonApps.length; ++i) {
  47.                     augmentedNonApps[i] = nonApps[i];
  48.                 }
  49.                 augmentedNonApps[augmentedNonApps.length - 1] = getDividerBarLegacyTarget();
  51.                 IRemoteAnimationFinishedCallback wrapCallback =
  52.                         new IRemoteAnimationFinishedCallback.Stub() {
  53.                             @Override
  54.                             public void onAnimationFinished() throws RemoteException {
  55.                                 mIsDividerRemoteAnimating = false;
  56.                                 mShouldUpdateRecents = true;
  57.                                 mSyncQueue.queue(evictWct);
  58.                                 mSyncQueue.runInSync(t -> applyDividerVisibility(t));
  59.                                 finishedCallback.onAnimationFinished();
  60.                             }
  61.                         };
  62.                 try {
  63.                     try {
  64.                         ActivityTaskManager.getService().setRunningRemoteTransitionDelegate(
  65.                                 adapter.getCallingApplication());
  66.                     } catch (SecurityException e) {
  67.                         Slog.e(TAG, "Unable to boost animation thread. This should only happen"
  68.                                 + " during unit tests");
  69.                     }
  70.                     adapter.getRunner().onAnimationStart(transit, apps, wallpapers,
  71.                             augmentedNonApps, wrapCallback);
  72.                 } catch (RemoteException e) {
  73.                     Slog.e(TAG, "Error starting remote animation", e);
  74.                 }
  75.             }
  77.             @Override
  78.             public void onAnimationCancelled() {
  79.                 mIsDividerRemoteAnimating = false;
  80.                 mShouldUpdateRecents = true;
  81.                 mSyncQueue.queue(evictWct);
  82.                 mSyncQueue.runInSync(t -> applyDividerVisibility(t));
  83.                 try {
  84.                     adapter.getRunner().onAnimationCancelled();
  85.                 } catch (RemoteException e) {
  86.                     Slog.e(TAG, "Error starting remote animation", e);
  87.                 }
  88.             }
  89.         };
  90.         RemoteAnimationAdapter wrappedAdapter = new RemoteAnimationAdapter(
  91.                 wrapper, adapter.getDuration(), adapter.getStatusBarTransitionDelay());
  93.         if (mainOptions == null) {
  94.             mainOptions = ActivityOptions.makeRemoteAnimation(wrappedAdapter).toBundle();
  95.         } else {
  96.             ActivityOptions mainActivityOptions = ActivityOptions.fromBundle(mainOptions);
  97.             mainActivityOptions.update(ActivityOptions.makeRemoteAnimation(wrappedAdapter));
  98.             mainOptions = mainActivityOptions.toBundle();
  99.         }
  101.         sideOptions = sideOptions != null ? sideOptions : new Bundle();
  102.         setSideStagePosition(sidePosition, wct);
  104.         mSplitLayout.setDivideRatio(splitRatio);
  105.         if (mMainStage.isActive()) {
  106.             mMainStage.moveToTop(getMainStageBounds(), wct);
  107.         } else {
  108.             // Build a request WCT that will launch both apps such that task 0 is on the main stage
  109.             // while task 1 is on the side stage.
  110.             // 设置mMainStage对应的RootTask的Bounds，并将其移动到最前面
  111.             mMainStage.activate(getMainStageBounds(), wct, false /* reparent */);
  112.         }
  113.         // 设置mSideStage对应的RootTask的Bounds，并将其移动到最前面
  114.         mSideStage.moveToTop(getSideStageBounds(), wct);
  116.         // Make sure the launch options will put tasks in the corresponding split roots
  117.         // 配置launch task的option，让分屏应用的task启动到RootTask节点之下
  118.         addActivityOptions(mainOptions, mMainStage);
  119.         addActivityOptions(sideOptions, mSideStage);
  121.         // Add task launch requests
  122.         // 启动分屏应用，启动方式和从任务管理器启动是一样的，startActivityFromRecents
  123.         wct.startTask(mainTaskId, mainOptions);
  124.         wct.startTask(sideTaskId, sideOptions);
  126.         // Using legacy transitions, so we can't use blast sync since it conflicts.
  127.         // 所有修改封装到WindowContainerTransaction中然后通过WindowOrganizer框架完成上面的变化
  128.         mTaskOrganizer.applyTransaction(wct);
  129.     }
  131. }
复制代码


  • 显示分屏中间的View
  • 设置mMainStage对应的RootTask的Bounds并移动到最前面
  • 设置mSideStage对应的RootTask的Bounds并移动到最前面
  • 启动分屏应用，让分屏应用的task启动到RootTask节点之下，启动方式和从任务管理器启动是一样的，Framework侧对应的就是startActivityFromRecents方法
2、继续来看下ShellTaskOrganizer的applyTransaction方法。
   frameworks/base/libs/WindowManager/Shell/src/com/android/wm/shell/ShellTaskOrganizer.java
  1. public class ShellTaskOrganizer extends TaskOrganizer implements
  2.         CompatUIController.CompatUICallback {
  3. }
复制代码
  frameworks/base/core/java/android/window/TaskOrganizer.java
  1. public class TaskOrganizer extends WindowOrganizer {
  3. }
复制代码
  frameworks/base/core/java/android/window/TaskOrganizer.java
  1. public class WindowOrganizer {
  2.         //applyTransaction是ShellTaskOrganizer的父类方法
  3.     public void applyTransaction(@NonNull WindowContainerTransaction t) {
  4.         try {
  5.             if (!t.isEmpty()) {
  6.                     //调用IWindowOrganizerController的applyTransaction方法
  7.                 getWindowOrganizerController().applyTransaction(t);
  8.             }
  9.         } catch (RemoteException e) {
  10.             throw e.rethrowFromSystemServer();
  11.         }
  12.     }
  13.    
  14.     static IWindowOrganizerController getWindowOrganizerController() {
  15.         return IWindowOrganizerControllerSingleton.get();
  16.     }
  17.    
  18.     private static final Singleton<IWindowOrganizerController> IWindowOrganizerControllerSingleton =
  19.         new Singleton<IWindowOrganizerController>() {
  20.             @Override
  21.             protected IWindowOrganizerController create() {
  22.                 try {
  23.                     return ActivityTaskManager.getService().getWindowOrganizerController();
  24.                 } catch (RemoteException e) {
  25.                     return null;
  26.                 }
  27.             }
  28.         };
  29. }
复制代码
applyTransaction方法终极是其父类WindowOrganizer的方法，该方法先是获取到WindowOrganizerController的实例对象，然后调用该对象的applySyncTransaction方法。
3、IWindowOrganizerController是一个aidl，该接口的具体实现类是WindowOrganizerController。
   frameworks/base/core/java/android/window/IWindowOrganizerController.aidl
  2. interface IWindowOrganizerController {
  4.     int applySyncTransaction(in WindowContainerTransaction t,
  5.             in IWindowContainerTransactionCallback callback);
  7. }
复制代码
  frameworks/base/services/core/java/com/android/server/wm/WindowOrganizerController.java
  1. class WindowOrganizerController extends IWindowOrganizerController.Stub
  2.     implements BLASTSyncEngine.TransactionReadyListener {
  3.    
  4.      @Override
  5.     public int applySyncTransaction(WindowContainerTransaction t,
  6.             IWindowContainerTransactionCallback callback) {
  7.         if (t == null) {
  8.             throw new IllegalArgumentException("Null transaction passed to applySyncTransaction");
  9.         }
  10.         enforceTaskPermission("applySyncTransaction()");
  11.         final CallerInfo caller = new CallerInfo();
  12.         final long ident = Binder.clearCallingIdentity();
  13.         try {
  14.             synchronized (mGlobalLock) {
  15.                 int syncId = -1;
  16.                 if (callback != null) {
  17.                     syncId = startSyncWithOrganizer(callback);
  18.                 }
  19.                 applyTransaction(t, syncId, null /*transition*/, caller);
  20.                 if (syncId >= 0) {
  21.                     setSyncReady(syncId);
  22.                 }
  23.                 return syncId;
  24.             }
  25.         } finally {
  26.             Binder.restoreCallingIdentity(ident);
  27.         }
  28.     }
  30. }
复制代码
这里还是运用了WindowOrganizer框架的能力，把所有修改点封装到 WindowContainerTransaction中，然后通过mTaskOrganizer.applyTransaction(wct); 转交给Framework，Framework剖析WindowContainerTransaction，然后实行对应的厘革
我们可以看看WindowContainerTransaction的内容

   Android12上两个应用都得是从任务管理器中起 startActivityFromRecents
在Android13上支持通过wct.sendPendingIntent(pendingIntent, fillInIntent, sideOptions)新起一个应用。
  六、通过命令行触发分屏

1、除了调用WMShell模块组件提供的方法触发分屏意外，我们还可以通过命令行来触发分屏。
  1. // taskId 可以通过adb shell am stack list 来查看应用对应的taskId
  2. // SideStagePosition 0 代表左边， 1 代表右边
  3. adb shell dumpsys activity service SystemUIService WMShell moveToSideStage <taskId> <SideStagePosition>
复制代码
命令行会把taskId对应的task挂载到SideStage对应的RootTask下，然后SideStage监听到task厘革，然后就会激活MainStage，然后申请分屏操纵。
2、这部分代码如下。
   frameworks/base/libs/WindowManager/Shell/src/com/android/wm/shell/splitscreen/StageCoordinator.java
  1. class StageCoordinator implements SplitLayout.SplitLayoutHandler,
  2.         RootTaskDisplayAreaOrganizer.RootTaskDisplayAreaListener, Transitions.TransitionHandler {
  4. private void onStageHasChildrenChanged(StageListenerImpl stageListener) {
  5.         final boolean hasChildren = stageListener.mHasChildren;
  6.         final boolean isSideStage = stageListener == mSideStageListener;
  7.         if (!hasChildren) {
  8.             if (isSideStage && mMainStageListener.mVisible) {
  9.                 // Exit to main stage if side stage no longer has children.
  10.                 exitSplitScreen(mMainStage, EXIT_REASON_APP_FINISHED);
  11.             } else if (!isSideStage && mSideStageListener.mVisible) {
  12.                 // Exit to side stage if main stage no longer has children.
  13.                 exitSplitScreen(mSideStage, EXIT_REASON_APP_FINISHED);
  14.             }
  15.         } else if (isSideStage) {
  16.                 //SideStage对应的RootTask监听到task变化，然后就会触发分屏操作
  17.             final WindowContainerTransaction wct = new WindowContainerTransaction();
  18.             //Make sure the main stage is active.
  19.             //这里的reparent是关键，为true后会把后台的Task作为分屏的一部分，如果没有后台task，不能触发分屏
  20.             mMainStage.activate(getMainStageBounds(), wct, true /* reparent */);
  21.             mSideStage.moveToTop(getSideStageBounds(), wct);
  22.             mSyncQueue.queue(wct);
  23.             mSyncQueue.runInSync(t -> updateSurfaceBounds(mSplitLayout, t));
  24.         }
  25.         if (mMainStageListener.mHasChildren && mSideStageListener.mHasChildren) {
  26.             mShouldUpdateRecents = true;
  27.             updateRecentTasksSplitPair();
  28.             if (!mLogger.hasStartedSession()) {
  29.                 mLogger.logEnter(mSplitLayout.getDividerPositionAsFraction(),
  30.                         getMainStagePosition(), mMainStage.getTopChildTaskUid(),
  31.                         getSideStagePosition(), mSideStage.getTopChildTaskUid(),
  32.                         mSplitLayout.isLandscape());
  33.             }
  34.         }
  35.     }
  37. }
复制代码
这里必要注意 mMainStage.activate(getMainStageBounds(), wct, true /* reparent */ ); 这里的reparent是关键，为true后会把后台的Task作为分屏的一部分，如果没有后台task，不能触发分屏，而且命令行分屏由于缺少了Launcher3的加入，缺少分屏之前的动画，效果上就是直接硬切的。
参考文档：https://juejin.cn/post/7346977510514884619

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

泉缘泉

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

挺好的 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表