Launcher 桌面源码笔记一（3D车模桌面）

3D车模通过TaskView显示在Launcher，首先需要知道，为什么要用TaskView，而不是Activity，然后在说加载流程
1、surface比activity等效率更高，特别是针对车模跟地图等重量级场景
2、切换桌面等场景时，可以更精确的控制暂停恢复
3、进程隔离，更精细的生命周期管理跟控制
4、taskView中SurfaceControl的跨进程绑定机制（reparent操作）效率比binder通讯效率更高
android.app.ActivityView（标记为弃用‌）

跟TaskView一样都是Android系统中用于管理多窗口和任务嵌入的组件

1. public class ActivityView extends ViewGroup {
2.     private static final String DISPLAY_NAME = "ActivityViewVirtualDisplay";
3.     private static final String TAG = "ActivityView";
4.     private final SurfaceView mSurfaceView;
5.     private Surface mSurface;
6.     private final SurfaceCallback mSurfaceCallback;
7.     private StateCallback mActivityViewCallback;
8.     private IActivityManager mActivityManager;
9.     private TaskStackListener mTaskStackListener;
11.     public ActivityView(Context context) {
12.         this(context, (AttributeSet)null);
13.     }
15.     public ActivityView(Context context, AttributeSet attrs) {
16.         this(context, attrs, 0);
17.     }
19.     public ActivityView(Context context, AttributeSet attrs, int defStyle) {
20.         super(context, attrs, defStyle);
21.         this.mActivityManager = ActivityManager.getService();
22.         this.mSurfaceView = new SurfaceView(context);
23.         this.mSurfaceCallback = new SurfaceCallback();
24.         this.mSurfaceView.getHolder().addCallback(this.mSurfaceCallback);
25.         this.addView(this.mSurfaceView);
26.     }

复制代码

View Code从源码中看到，继承自ViewGroup，基于SurfaceView实现，在初始化时将 SurfaceView addView到ViewGroup中
ActivityView‌ 直接依赖传统的窗口管理机制，通过 WindowManager 控制嵌入的 Activity 生命周期。
com.android.wm.shell.TaskView

1. public class TaskView extends SurfaceView implements SurfaceHolder.Callback, ShellTaskOrganizer.TaskListener, ViewTreeObserver.OnComputeInternalInsetsListener {
2.     private final ShellTaskOrganizer mTaskOrganizer;
3.     private ActivityManager.RunningTaskInfo mTaskInfo;
4.     private WindowContainerToken mTaskToken;
5.     private SurfaceControl mTaskLeash;
6.     private final SurfaceControl.Transaction mTransaction = new SurfaceControl.Transaction();
8.     public TaskView(Context context, ShellTaskOrganizer organizer, SyncTransactionQueue syncQueue) {
9.         super(context, (AttributeSet)null, 0, 0, true);
10.         this.getHolder().addCallback(this);
11.     }

复制代码

View Code

1. public void onTaskAppeared(ActivityManager.RunningTaskInfo taskInfo, SurfaceControl leash) {
2.         this.mTaskInfo = taskInfo;
3.         this.mTaskToken = taskInfo.token;
4.         this.mTaskLeash = leash;
5.         if (this.mSurfaceCreated) {
6.             this.mTransaction.reparent(this.mTaskLeash, this.getSurfaceControl()).show(this.mTaskLeash).apply();
7.         } else {
8.             this.updateTaskVisibility();
9.         }
11.         this.mTaskOrganizer.setInterceptBackPressedOnTaskRoot(this.mTaskToken, true);
12.         this.onLocationChanged();
13.         if (taskInfo.taskDescription != null) {
14.             int backgroundColor = taskInfo.taskDescription.getBackgroundColor();
15.             this.mSyncQueue.runInSync((t) -> this.setResizeBackgroundColor(t, backgroundColor));
16.         }
18.         if (this.mListener != null) {
19.             int taskId = taskInfo.taskId;
20.             ComponentName baseActivity = taskInfo.baseActivity;
21.             this.mListenerExecutor.execute(() -> this.mListener.onTaskCreated(taskId, baseActivity));
22.         }
24.     }

复制代码

View CodeAndroid 12 引入的替代方案，专为 Android Automotive OS (AAOS) 优化，并扩展了 ShellTaskOrganizer.TaskListener 接口。直接继承自SurfaceView，并且在onTaskAppeared回调中使用了reparent操作，支持动态调整嵌入任务的位置和大小‌。
车模加载流程

车模属于unity交互，在android中提供一个容器用于显示，这里直接使用Activity

1. [/code]View Code新建一个CarLauncherActivity用于显示这个UnityPlayerFragment
2. 3DActivity有了，需要将它显示到launcher桌面（MainActivity），自定义TaskView，用于3D桌面
3. [align=center] [/align][align=center] [/align][code]

复制代码

View Code在MainActivity启动时通过 surfaceCreated 回调，对桌面进行初始化操作

1. public void surfaceCreated(SurfaceHolder holder) {
2.         this.mSurfaceCreated = true;
3.         if (this.mListener != null && !this.mIsInitialized) {
4.             this.mIsInitialized = true;
5.             this.mListenerExecutor.execute(() -> this.mListener.onInitialized());
6.         }
8.         this.mShellExecutor.execute(() -> {
9.             if (this.mTaskToken != null) {
10.                 this.mTransaction.reparent(this.mTaskLeash, this.getSurfaceControl()).show(this.mTaskLeash).apply();
11.                 this.updateTaskVisibility();
12.             }
13.         });
14.     }

复制代码

View Code接下来需要实现嵌入操作，可以看到在首次进入时，会调用 TaskView. Listener的 onInitialized 方法，在回调中需要执行taskview的startActivity进行内嵌

1. public void startActivity(PendingIntent pendingIntent, Intent fillInIntent, ActivityOptions options, Rect launchBounds) {
2.         this.prepareActivityOptions(options, launchBounds);
4.         try {
5.             pendingIntent.send(this.mContext, 0, fillInIntent, (PendingIntent.OnFinished)null, (Handler)null, (String)null, options.toBundle());
6.         } catch (Exception e) {
7.             throw new RuntimeException(e);
8.         }
9.     }

复制代码

View CodestartActivity后会触发状态变更，系统层处理后，在Systemui层通过TaskOrganizer监听状态
android.window.TaskOrganizer

当需要嵌入显示另一个应用的 Activity 时，TaskOrganizer 会提供该任务窗口的 SurfaceControl（称为 "leash"），但是TaskOrganizer位与SystemUI模块，所以需要通过AIDL进行跨进程通讯
首先在launcher模块定义好接口

1. package com.android.wm.shell;
3. import android.view.SurfaceControl;
4. import android.graphics.Rect;
5. import android.window.WindowContainerToken;
6. import com.android.wm.shell.RunningTaskInfo;
8. /**
9. * Interface for ActivityTaskManager/WindowManager to delegate control of tasks.
10. * {@hide}
11. */
12. oneway interface ITaskView {
13.     /**
14.      * Called when a Task is starting and the system would like to show a UI to indicate that an
15.      * application is starting. The client is responsible to add/remove the starting window if it
16.      * has create a starting window for the Task.
17.      *
18.      * @param info The information about the Task that's available
19.      * @param appToken Token of the application being started.
20.      */
22.     /**
23.      * Called when the Task want to remove the starting window.
24.      * @param removalInfo The information used to remove the starting window.
25.      */
27.     /**
28.      * Called when the Task want to copy the splash screen.
29.      */
30.     void copySplashScreenView(int taskId);
32.     /**
33.      * Called when the Task removed the splash screen.
34.      */
35.     void onAppSplashScreenViewRemoved(int taskId);
37.     /**
38.      * A callback when the Task is available for the registered organizer. The client is responsible
39.      * for releasing the SurfaceControl in the callback. For non-root tasks, the leash may initially
40.      * be hidden so it is up to the organizer to show this task.
41.      *
42.      * @param taskInfo The information about the Task that's available
43.      * @param leash A persistent leash for this Task.
44.      */
45.     void onTaskAppeared(in RunningTaskInfo taskInfo, in SurfaceControl leash);
46.     void onTaskVanished(in RunningTaskInfo taskInfo);
48.     /**
49.      * Will fire when core attributes of a Task's info change. Relevant properties include the
50.      * {@link WindowConfiguration.ActivityType} and whether it is resizable.
51.      *
52.      * This is used, for example, during split-screen. The flow for starting is: Something sends an
53.      * Intent with windowingmode. Then WM finds a matching root task and launches the new task into
54.      * it. This causes the root task's info to change because now it has a task when it didn't
55.      * before. The default Divider implementation interprets this as a request to enter
56.      * split-screen mode and will move all other Tasks into the secondary root task. When WM
57.      * applies this change, it triggers an info change in the secondary root task because it now
58.      * has children. The Divider impl looks at the info and can see that the secondary root task
59.      * has adopted an ActivityType of HOME and proceeds to show the minimized dock UX.
60.      */
61.     void onTaskInfoChanged(in RunningTaskInfo taskInfo);
63.     /**
64.      * Called when the task organizer has requested
65.      * {@link ITaskOrganizerController.setInterceptBackPressedOnTaskRoot} to get notified when the
66.      * user has pressed back on the root activity of a task controlled by the task organizer.
67.      */
68.     void onBackPressedOnTaskRoot(in RunningTaskInfo taskInfo);
70.     /**
71.      * Called when the IME has drawn on the organized task.
72.      */
73.     void onImeDrawnOnTask(int taskId);
74. }

复制代码

View Code并且提供Service

1.         <service
2.             android:name="com.test.SharedTaskViewService"
3.             android:enabled="true"
4.             android:exported="true" />
5.     </application>
7. package com.test.taskview;
9. import static android.app.WindowConfiguration.WINDOWING_MODE_MULTI_WINDOW;
11. import android.app.Service;
12. import android.content.Intent;
13. import android.os.Handler;
14. import android.os.IBinder;
15. import android.os.Looper;
16. import android.util.Log;
17. import android.view.SurfaceControl;
19. import com.android.wm.shell.ITaskView;
20. import com.android.wm.shell.ShellTaskOrganizer;
21. import com.android.wm.shell.RunningTaskInfo;
22. import com.android.wm.shell.common.HandlerExecutor;
24. import java.util.concurrent.ConcurrentHashMap;
26. public class SharedTaskViewService extends Service {
27.     private static final String TAG = "SharedTaskViewService";
28.     private ConcurrentHashMap<Integer, Integer> taskIdDisplayMap = new ConcurrentHashMap<>();
29.     private final HandlerExecutor mExecutor = new HandlerExecutor(new Handler(Looper.getMainLooper()));
32.     private int getRealDisplayId(int taskId) {
33.         if (taskIdDisplayMap.containsKey(taskId)) {
34.             Integer val = taskIdDisplayMap.get(taskId);
35.             if (val == null) {
36.                 return -1;
37.             }
38.             return val.intValue();
39.         }
40.         return -2;
41.     }
43.     ITaskView taskView = new ITaskView.Stub() {
44.         public void copySplashScreenView(int taskId) {
46.         }
48.         public void onAppSplashScreenViewRemoved(int taskId) {
50.         }
52.         public void onTaskAppeared(RunningTaskInfo taskInfo, SurfaceControl leash) {
53.             mExecutor.execute(() -> SharedTaskViewService.this.onTaskAppeared(taskInfo, leash));
54.         }
56.         public void onTaskVanished(RunningTaskInfo taskInfo) {
57.             mExecutor.execute(() -> SharedTaskViewService.this.onTaskVanished(taskInfo));
58.         }
61.         public void onTaskInfoChanged(RunningTaskInfo taskInfo) {
62.             mExecutor.execute(() -> SharedTaskViewService.this.onTaskInfoChanged(taskInfo));
63.         }
66.         public void onBackPressedOnTaskRoot(RunningTaskInfo taskInfo) {
68.         }
70.         /**
71.          * Called when the IME has drawn on the organized task.
72.          */
73.         public void onImeDrawnOnTask(int taskId) {
75.         }
76.     };
79.     public void onTaskAppeared(RunningTaskInfo taskInfo, SurfaceControl leash) {
80.         if (SharedTaskManager.getInstance().getListeners() != null) {
81.             if (taskInfo != null && taskInfo.info != null && taskInfo.info.baseIntent != null && taskInfo.info.baseIntent.getComponent() != null) {
82.                 String pkgName = taskInfo.info.baseIntent.getComponent().getPackageName();
83.                 String clsName = taskInfo.info.baseIntent.getComponent().getClassName();
84.                 Log.w(TAG, "onTaskAppeared clsName:" + clsName);
85.                 boolean hasKey = SharedTaskManager.getInstance().getListeners().containsKey(clsName);
86.                 boolean hasTaskLeash = SharedTaskManager.getInstance().hasTaskLeash(clsName);
87.                 if (hasTaskLeash) {
88.                     SharedTaskManager.getInstance().addOrUpdateTaskLeash(clsName, new SharedTaskManager.SharedTaskInfo(leash, taskInfo.info.token));
89.                 }
91.                 if (hasKey) {
92.                     ShellTaskOrganizer.TaskListener taskListener = SharedTaskManager.getInstance().getListeners().get(clsName);
93.                     if (taskListener != null) {
94.                         Logger.w(TAG, "onTaskAppeared:" + pkgName + "displayId:" + taskInfo.info.displayId);
95.                         if (taskInfo.info.displayId == 0 && taskInfo.info.getWindowingMode() == WINDOWING_MODE_MULTI_WINDOW && taskInfo.info.numActivities > 0) {
96.                             taskIdDisplayMap.put(taskInfo.info.taskId, 0);
97.                             taskListener.onTaskAppeared(taskInfo.info, leash);
98.                         }
99.                     }
100.                 } else {
101.                     Log.w(TAG, "onTaskAppeared,no suiteable key in TaskManager.getInstance().getListeners:" + pkgName);
102.                 }
104.             }
105.         }
106.     }
108.     public void onTaskVanished(RunningTaskInfo taskInfo) {
109.         if (SharedTaskManager.getInstance().getListeners() != null) {
110.             if (taskInfo != null && taskInfo.info != null && taskInfo.info.realActivity != null) {
111.                 String pkgName = taskInfo.info.baseIntent.getComponent().getPackageName();
112.                 String clsName = taskInfo.info.baseIntent.getComponent().getClassName();
113.                 boolean hasKey = SharedTaskManager.getInstance().getListeners().containsKey(clsName);
114.                 if (hasKey) {
115.                     ShellTaskOrganizer.TaskListener taskListener = SharedTaskManager.getInstance().getListeners().get(clsName);
116.                     if (taskListener != null) {
117.                         int realDisplayId = getRealDisplayId(taskInfo.info.taskId);
118.                         Logger.w(TAG, "onTaskVanished:" + pkgName + ",displayId:" + taskInfo.info.displayId + ",realDisplayId:" + realDisplayId);
119.                         if (realDisplayId == 0) {
120.                             taskListener.onTaskVanished(taskInfo.info);
121.                         }
122.                     }
123.                 } else {
124.                     Log.w(TAG, "onTaskVanished,no suiteable key in TaskManager.getInstance().getListeners:" + clsName);
125.                 }
126.             }
127.         }
128.     }
131.     public void onTaskInfoChanged(RunningTaskInfo taskInfo) {
132.         if (SharedTaskManager.getInstance().getListeners() != null) {
133.             if (taskInfo != null && taskInfo.info != null && taskInfo.info.realActivity != null) {
134.                 String pkgName = taskInfo.info.baseIntent.getComponent().getPackageName();
135.                 String clsName = taskInfo.info.baseIntent.getComponent().getClassName();
136.                 boolean hasKey = SharedTaskManager.getInstance().getListeners().containsKey(clsName);
137.                 if (hasKey) {
138.                     ShellTaskOrganizer.TaskListener taskListener = SharedTaskManager.getInstance().getListeners().get(clsName);
139.                     if (taskListener != null) {
140.                         Logger.w(TAG, "onTaskInfoChanged:" + taskInfo.info);
141.                         taskListener.onTaskInfoChanged(taskInfo.info);
142.                     }
143.                 } else {
144.                     Log.w(TAG, "onTaskInfoChanged,no suiteable key in TaskManager.getInstance().getListeners:" + clsName);
145.                 }
146.             }
147.         }
148.     }
151.     @Override
152.     public IBinder onBind(Intent intent) {
153.         Logger.w(TAG, "onBind: ");
154.         return (IBinder) taskaskView;
155.     }
157.     @Override
158.     public void onCreate() {
159.         super.onCreate();
160.         Logger.w(TAG, "onCreate: ");
161.     }
163.     @Override
164.     public void onDestroy() {
165.         super.onDestroy();
166.         Logger.w(TAG, "onDestroy: ");
167.     }
168. }

复制代码

View Code 
SystemUI模块需要继承TaskOrganizer，在TaskOrganizer的onTaskAppeared中去同步到Launcher模块

1. private void bind(){
2.         Intent intent = new Intent();
3.         intent.setComponent(new ComponentName(PACKAGE_LAUNCHER, SERVICE_LAUNCHER_TASK_VIEW));
4.         mContext.bindService(intent,connection,Context.BIND_AUTO_CREATE);
5.         Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER, "bind SharedTaskViewService");
6.     }
8. private final ServiceConnection connection = new ServiceConnection() {
9.         @Override
10.         public void onServiceConnected(ComponentName name, IBinder service) {
11.             synchronized (mLock) {
12.                 StringBuilder tempInfoString = new StringBuilder();
13.                 for (TaskAppearedInfo taskAppearedInfo : tempInfoList) {
14.                     tempInfoString.append(getPackageName(taskAppearedInfo.getTaskInfo())).append(",");
15.                 }
16.                 Log.d(TAG, "onServiceConnected name = " + name + ", tempInfoList = " + tempInfoString);
17.                 ProtoLog.v(WM_SHELL_TASK_ORG, "onServiceConnected name = " + name);
18.                 Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER);
19.                 iTaskView = ITaskView.Stub.asInterface(service);
20.                 isConnecting = false;
21.                 if(tempInfoList.size()>0){
22.                     try {
23.                         Log.d(TAG, "tempInfo is not null, notify launcher");
24.                         for (TaskAppearedInfo taskAppearedInfo : tempInfoList) {
25.                             Log.d(TAG, "tempInfo = " + getPackageName(taskAppearedInfo.getTaskInfo()));
26.                             RunningTaskInfo runningTaskInfo = taskAppearedInfo.getTaskInfo();
27.                             if (runningTaskInfo == null || runningTaskInfo.numActivities == 0) {
28.                                 Log.d(TAG, "ignore empty taskInfo " + runningTaskInfo);
29.                             } else {
30.                                 iTaskView.onTaskAppeared(new RunningTaskInfo(taskAppearedInfo.getTaskInfo()), taskAppearedInfo.getLeash());
31.                             }
32.                         }
33.                         tempInfoList.clear();
34.                     } catch (RemoteException e) {
35.                         e.printStackTrace();
36.                     }
37.                 }
38.             }
39.         }
41.         @Override
42.         public void onServiceDisconnected(ComponentName name) {
43.             Log.d(TAG,"onServiceDisconnected componentName="+name);
44.             iTaskView = null;
45.             bind();
46.         }
48.         @Override
49.         public void onBindingDied(ComponentName name) {
50.             Log.d(TAG,"onBindingDied componentName="+name);
51.             iTaskView = null;
52.             bind();
53.         }
54.     };
56. @Override
57.     public void onTaskAppeared(RunningTaskInfo taskInfo, SurfaceControl leash) {
58.         Log.d(TAG, "task appeared " + getPackageName(taskInfo));
59.         synchronized (mLock) {
60.             iTaskView.onTaskAppeared(new RunningTaskInfo(info.getTaskInfo()), info.getLeash());
61.         }
62.     }

复制代码

View Code初始化时通过bind()方法绑定服务，在onTaskAppeared回调中调用服务方法
Launcher在收到AIDL方法onTaskAppeared时会执行 mTransaction.reparent(mTaskLeash, getSurfaceControl()) 显示当前车模桌面
 
 
来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！