AndroidQ SystemUI之插件化机制Plugin

这篇文章接着上一篇SystemUI之启动未分析完的SystemUI插件化机制相关的代码

SystemUI插件

SystemUI插件提供了一种快速创建SystemUI功能原型的简便方法，可以在运行时更改SystemUI的行为。通过创建插件实现SysUI中使用的一组基本接口来完成，然后可以比当前更快的速度迭代由该接口控制的部分代码。

简单来说就是可以快速替换SystemUI原有的组件，也叫hook，我们就来分析下其中的原理

SystemUIApplication.startServicesIfNeeded

private void startServicesIfNeeded(String[] services) {//省略上一篇文章分析过的代码.....Dependency.get(InitController.class).executePostInitTasks();log.traceEnd();final Handler mainHandler = new Handler(Looper.getMainLooper());//调用addPluginListener传入了三个参数，PluginListener，//OverlayPlugin.class，和一个boolean值trueDependency.get(PluginManager.class).addPluginListener(new PluginListener<OverlayPlugin>() {private ArraySet<OverlayPlugin> mOverlays = new ArraySet<>();@Overridepublic void onPluginConnected(OverlayPlugin plugin, Context pluginContext) {mainHandler.post(new Runnable() {@Overridepublic void run() {StatusBar statusBar = getComponent(StatusBar.class);if (statusBar != null) {plugin.setup(statusBar.getStatusBarWindow(),statusBar.getNavigationBarView(), new Callback(plugin));}}});}@Overridepublic void onPluginDisconnected(OverlayPlugin plugin) {mainHandler.post(new Runnable() {@Overridepublic void run() {mOverlays.remove(plugin);Dependency.get(StatusBarWindowController.class).setForcePluginOpen(mOverlays.size() != 0);}});}class Callback implements OverlayPlugin.Callback {private final OverlayPlugin mPlugin;Callback(OverlayPlugin plugin) {mPlugin = plugin;}@Overridepublic void onHoldStatusBarOpenChange() {if (mPlugin.holdStatusBarOpen()) {mOverlays.add(mPlugin);} else {mOverlays.remove(mPlugin);}mainHandler.post(new Runnable() {@Overridepublic void run() {Dependency.get(StatusBarWindowController.class).setStateListener(b -> mOverlays.forEach(o -> o.setCollapseDesired(b)));Dependency.get(StatusBarWindowController.class).setForcePluginOpen(mOverlays.size() != 0);}});}}}, OverlayPlugin.class, true /* Allow multiple plugins */);mServicesStarted = true;}

Dependency是定义在config_systemUIServiceComponents这个config文件中的，在startServicesIfNeeded中会遍历此config定义的所有SystemUI重要类，调用它们的Start方法:

Dependency.start

@Overridepublic void start() {// TODO: Think about ways to push these creation rules out of Dependency to cut down// on imports.mProviders.put(TIME_TICK_HANDLER, mTimeTickHandler::get);mProviders.put(BG_LOOPER, mBgLooper::get);mProviders.put(BG_HANDLER, mBgHandler::get);mProviders.put(MAIN_HANDLER, mMainHandler::get);mProviders.put(ActivityStarter.class, mActivityStarter::get);mProviders.put(ActivityStarterDelegate.class, mActivityStarterDelegate::get);mProviders.put(AsyncSensorManager.class, mAsyncSensorManager::get);mProviders.put(BluetoothController.class, mBluetoothController::get);mProviders.put(SensorPrivacyManager.class, mSensorPrivacyManager::get);mProviders.put(LocationController.class, mLocationController::get);mProviders.put(RotationLockController.class, mRotationLockController::get);mProviders.put(NetworkController.class, mNetworkController::get);mProviders.put(ZenModeController.class, mZenModeController::get);mProviders.put(HotspotController.class, mHotspotController::get);mProviders.put(CastController.class, mCastController::get);mProviders.put(FlashlightController.class, mFlashlightController::get);mProviders.put(KeyguardMonitor.class, mKeyguardMonitor::get);mProviders.put(UserSwitcherController.class, mUserSwitcherController::get);mProviders.put(UserInfoController.class, mUserInfoController::get);mProviders.put(BatteryController.class, mBatteryController::get);......sDependency = this;}

我们可以看到，start方法中将很多的类添加到了mProviders中，接着看：

Dependency.get

private static Dependency sDependency;
@Deprecatedpublic static <T> T get(Class<T> cls) {return sDependency.getDependency(cls);}protected final <T> T getDependency(Class<T> cls) {return getDependencyInner(cls);}private synchronized <T> T getDependencyInner(Object key) {@SuppressWarnings("unchecked")T obj = (T) mDependencies.get(key);if (obj == null) {obj = createDependency(key);mDependencies.put(key, obj);}return obj;}

get方法最终通过mDependencies.get来获取对象，mDependencies是个ArrayMap，如果没有获取到就调用createDependency创建对象，创建之后放入mDependencies中

createDependency

@VisibleForTestingprotected <T> T createDependency(Object cls) {@SuppressWarnings("unchecked")LazyDependencyCreator<T> provider = mProviders.get(cls);if (provider == null) {throw new IllegalArgumentException("Unsupported dependency " + cls+ ". " + mProviders.size() + " providers known.");}return provider.createDependency();}

此方法通过mProviders.get来获取对象，mProviders中的类就是在Start方法中添加的，所以能够直接获取，Dependency中用到了dagger框架的Lazy，Provider等机制。

addPluginListener

所以我们在看到Dependency.get(T.class)时就可以简单认为是获取T的实现类
接着SystemUIApplication的startServicesIfNeeded方法添加插件监听，这里实际调用PluginManagerImpl的addPluginListener方法，此方法接收三个参数：一个PluginListener接口，一个Class对象，一个boolean值

PluginManagerImpl中的addPluginListener有几个重载，为了好说明，我给它们编了个号

 （1）public <T extends Plugin> void addPluginListener(PluginListener<T> listener, Class<?> cls) {addPluginListener(listener, cls, false);}(2）public <T extends Plugin> void addPluginListener(PluginListener<T> listener, Class<?> cls,boolean allowMultiple) {addPluginListener(PluginManager.Helper.getAction(cls), listener, cls, allowMultiple);}(3）public <T extends Plugin> void addPluginListener(String action, PluginListener<T> listener,Class<?> cls) {addPluginListener(action, listener, cls, false);}(4）public <T extends Plugin> void addPluginListener(String action, PluginListener<T> listener,Class cls, boolean allowMultiple) {android.util.Log.d("djtang","addPluginListener...action = :"+action+",name = :"+cls.getName());mPluginPrefs.addAction(action);PluginInstanceManager p = mFactory.createPluginInstanceManager(mContext, action, listener,allowMultiple, mLooper, cls, this);p.loadAll();mPluginMap.put(listener, p);startListening();}

PluginListener

我们先来看下PluginListener这个接口，这是个泛型接口，其中T必须是Plugin的子类，此接口提供两个生命周期方法，插件连接时调用onPluginConnected，断开连接调用
onPluginDisconnected

public interface PluginListener<T extends Plugin> {void onPluginConnected(T plugin, Context pluginContext);default void onPluginDisconnected(T plugin) {}
}

从上面代码我们知道，Dependency.get(PluginManager.class).addPluginListener调用的是（2）号重载方法，获取了一个Action后调用了（4）号方法，看下Action是啥：

PluginManager.Helper.getAction(cls)

public interface PluginManager {class Helper {public static <P> String getAction(Class<P> cls) {//获取ProvidesInterface的注解信息ProvidesInterface info = cls.getDeclaredAnnotation(ProvidesInterface.class);if (info == null) {throw new RuntimeException(cls + " doesn't provide an interface");}if (TextUtils.isEmpty(info.action())) {throw new RuntimeException(cls + " doesn't provide an action");}//获取ProvidesInterface注解的actionreturn info.action();}
}

通过getDeclaredAnnotation方法获取注解，ProvidesInterface这是个注解类，每个继承Plugin的类包含一个ProvidesInterface，这个注解类包含两项，version和action

public @interface ProvidesInterface {int version();String action() default "";}

用法如下：

@ProvidesInterface(action = MyPlugin.ACTION, version = MyPlugin.VERSION)
public interface MyPlugin extends Plugin {String ACTION = "com.android.systemui.action.PLUGIN_MY_PLUGIN";int VERSION = 1;...
}

这样就通过ProvidesInterface注解将action和version暴露了出来，获取的方式很简单，调用ProvidesInterface的action方法获取的就是其action

public interface PluginManager {class Helper {public static <P> String getAction(Class<P> cls) {ProvidesInterface info = cls.getDeclaredAnnotation(ProvidesInterface.class);if (info == null) {throw new RuntimeException(cls + " doesn't provide an interface");}if (TextUtils.isEmpty(info.action())) {throw new RuntimeException(cls + " doesn't provide an action");}return info.action();}}

我们再回到Dependency.get(PluginManager.class).addPluginListener的方法，它的第二个参数是OverlayPlugin.class

OverlayPlugin


@ProvidesInterface(action = OverlayPlugin.ACTION, version = OverlayPlugin.VERSION)
public interface OverlayPlugin extends Plugin {String ACTION = "com.android.systemui.action.PLUGIN_OVERLAY";int VERSION = 3;.....}

根据我们上面的分析，就知道了在（2）号方法中获取的action就是OverlayPlugin中定义的ACTION = “com.android.systemui.action.PLUGIN_OVERLAY”，通过ProvidesInterface注解获取，好了接着（2）号方法调到了（4）号方法：

public <T extends Plugin> void addPluginListener(String action, PluginListener<T> listener,Class cls, boolean allowMultiple) {mPluginPrefs.addAction(action);PluginInstanceManager p = mFactory.createPluginInstanceManager(mContext, action, listener,allowMultiple, mLooper, cls, this);p.loadAll();mPluginMap.put(listener, p);startListening();}

首先将action添加到mPluginPrefs，mPluginPrefs是一个PluginPrefs，它的内部有一个ArraySet和一个SharedPreferences，它的存储机制就是将action先存储到ArraySet，再将此ArraySet存到SharedPreferences中，具体代码就不贴出了

接着mFactory.createPluginInstanceManager方法，mFactory是PluginInstanceManagerFactory类型，是PluginManagerImpl的静态内部类

@VisibleForTestingpublic static class PluginInstanceManagerFactory {public <T extends Plugin> PluginInstanceManager createPluginInstanceManager(Context context,String action, PluginListener<T> listener, boolean allowMultiple, Looper looper,Class<?> cls, PluginManagerImpl manager) {return new PluginInstanceManager(context, action, listener, allowMultiple, looper,new VersionInfo().addClass(cls), manager);}}

createPluginInstanceManager其实就是new了一个PluginInstanceManager对象，
接着调用了PluginInstanceManager的loadAll方法

PluginInstanceManager.loadAll()

public void loadAll() {if (DEBUG) Log.d(TAG, "startListening");mPluginHandler.sendEmptyMessage(PluginHandler.QUERY_ALL);}

通过handler处理消息，注意mPluginHandler这个handler，它发送的消息并不是到主线程的，因为它使用的不是主线程的Looper，这个looper其实是：
mProviders.put(BG_LOOPER, mBgLooper::get)，是一个后台Looper

PluginInstanceManager(Context context, PackageManager pm, String action,PluginListener<T> listener, boolean allowMultiple, Looper looper, VersionInfo version,PluginManagerImpl manager, boolean debuggable, String[] pluginWhitelist) {mMainHandler = new MainHandler(Looper.getMainLooper());mPluginHandler = new PluginHandler(looper);...}

QUERY_ALL

接着看mPluginHandler里的具体处理：

private class PluginHandler extends Handler {private final ArrayList<PluginInfo<T>> mPlugins = new ArrayList<>();public void handleMessage(Message msg) {switch (msg.what) {case QUERY_ALL:if (DEBUG) Log.d(TAG, "queryAll " + mAction);//如果mPlugins不为空，则遍历mPlugins，调用onPluginDisconnected//清理Pluginfor (int i = mPlugins.size() - 1; i >= 0; i--) {PluginInfo<T> plugin = mPlugins.get(i);mListener.onPluginDisconnected(plugin.mPlugin);if (!(plugin.mPlugin instanceof PluginFragment)) {plugin.mPlugin.onDestroy();}}//清空mPluginsmPlugins.clear();handleQueryPlugins(null);break;.....}
}

handleQueryPlugins

private void handleQueryPlugins(String pkgName) {Intent intent = new Intent(mAction);//pkgName == null，此处的intent只有action，没有pkgNameif (pkgName != null) {intent.setPackage(pkgName);}//給定intent，返回满足条件的ResolveInfo（本质是service）集合List<ResolveInfo> result = mPm.queryIntentServices(intent, 0);if (DEBUG) Log.d(TAG, "Found " + result.size() + " plugins");//mAllowMultiple == true，不会走进去if (result.size() > 1 && !mAllowMultiple) {Log.w(TAG, "Multiple plugins found for " + mAction);if (DEBUG) {for (ResolveInfo info : result) {ComponentName name = new ComponentName(info.serviceInfo.packageName,info.serviceInfo.name);Log.w(TAG, "  " + name);}}return;}//遍历ResolveInfofor (ResolveInfo info : result) {ComponentName name = new ComponentName(info.serviceInfo.packageName,info.serviceInfo.name);//根据info信息创建插件PluginInfo<T> t = handleLoadPlugin(name);if (t == null) continue;//如果成功创建了PluginInfo就添加到mPlugins保存mPlugins.add(t);//将创建好的PluginInfo发送到主线程处理mMainHandler.obtainMessage(mMainHandler.PLUGIN_CONNECTED, t).sendToTarget();}}

PLUGIN_CONNECTED

private class MainHandler extends Handler {public void handleMessage(Message msg) {switch (msg.what) {case PLUGIN_CONNECTED:if (DEBUG) Log.d(TAG, "onPluginConnected");PluginPrefs.setHasPlugins(mContext);//将handler发送过来的obj强转为PluginInfoPluginInfo<T> info = (PluginInfo<T>) msg.obj;mManager.handleWtfs();//如果是Fragment类型的Pluginif (!(msg.obj instanceof PluginFragment)) {//调用它的onCreate方法info.mPlugin.onCreate(mContext, info.mPluginContext);}//调用onPluginConnected方法mListener.onPluginConnected(info.mPlugin, info.mPluginContext);break;......}
}

我们可以看到mPluginHandler和mMainHandler的逻辑还是比较对称的：

mPluginHandler在后台线程处理消息，在收到QUERY_ALL消息后如果有Plugin则先判断是否是Fragment类型Plugin，如果是则调用onDestroy方法，还会调用Plugin添加的PluginListener的回调onPluginDisconnected
mMainHandler在主线程处理mPluginHandler发送来的Plugin，同样判断如果是Fragment类型Plugin则调用onCreate，还会调用Plugin添加的PluginListener的回调onPluginConnected

我们再会到addPluginListener，经过上面的分析，我们知道了PluginInstanceManager是一个专门用来管理Plugin的类，每个Plugin对应一个

public <T extends Plugin> void addPluginListener(String action, PluginListener<T> listener,Class cls, boolean allowMultiple) {mPluginPrefs.addAction(action);PluginInstanceManager p = mFactory.createPluginInstanceManager(mContext, action, listener,allowMultiple, mLooper, cls, this);p.loadAll();mPluginMap.put(listener, p);startListening();}

mPluginMap是一个ArrayMap，将同一个Plugin的listener和PluginInstanceManager一一对应的保存进去

private final ArrayMap<PluginListener<?>, PluginInstanceManager> mPluginMap= new ArrayMap<>();

startListening()

private void startListening() {//保证只启动一次if (mListening) return;mListening = true;IntentFilter filter = new IntentFilter(Intent.ACTION_PACKAGE_ADDED);filter.addAction(Intent.ACTION_PACKAGE_CHANGED);filter.addAction(Intent.ACTION_PACKAGE_REPLACED);filter.addAction(Intent.ACTION_PACKAGE_REMOVED);filter.addAction(PLUGIN_CHANGED);filter.addAction(DISABLE_PLUGIN);filter.addDataScheme("package");mContext.registerReceiver(this, filter);filter = new IntentFilter(Intent.ACTION_USER_UNLOCKED);mContext.registerReceiver(this, filter);}

这个方法就是注册了一些广播，PluginManagerImpl继承BroadcastReceiver，所有收到广播的处理都在它自己的onReceive方法中:

public void onReceive(Context context, Intent intent) {if(Intent.ACTION_USER_UNLOCKED.equals(intent.getAction())){......}else if(DISABLE_PLUGIN.equals(intent.getAction())){......}else {.....if (!Intent.ACTION_PACKAGE_REMOVED.equals(intent.getAction())) {for (PluginInstanceManager manager : mPluginMap.values()) {manager.onPackageChange(pkg);}} else {for (PluginInstanceManager manager : mPluginMap.values()) {manager.onPackageRemoved(pkg);}}}
}

我们可以看到，else分支中如果是ACTION_PACKAGE_REMOVED广播则调用
manager.onPackageRemoved，否则调用manager.onPackageChange，这两个方法在PluginInstanceManager类中，其实它们是一对相对应的方法，一个onPackageRemoved最终会调到PluginListener的onPluginDisconnected中，
onPackageChange最终会调到PluginListener的onPluginConnected中，我们看下具体代码：

PluginInstanceManager

onPackageChange中相当于先调了一次onPackageRemoved

public void onPackageRemoved(String pkg) {mPluginHandler.obtainMessage(PluginHandler.REMOVE_PKG, pkg).sendToTarget();}public void onPackageChange(String pkg) {mPluginHandler.obtainMessage(PluginHandler.REMOVE_PKG, pkg).sendToTarget();mPluginHandler.obtainMessage(PluginHandler.QUERY_PKG, pkg).sendToTarget();}

QUERY_PKG和REMOVE_PKG

private class PluginHandler extends Handler {public void handleMessage(Message msg) {switch (msg.what) {case REMOVE_PKG:mMainHandler.obtainMessage(MainHandler.PLUGIN_DISCONNECTED,plugin.mPlugin).sendToTarget();break;case QUERY_PKG:String p = (String) msg.obj;handleQueryPlugins(p);.....break;} }
}

REMOVE_PKG中向MainHandler主线程发送了PLUGIN_DISCONNECTED的msg，QUERY_PKG中调用了handleQueryPlugins方法，此方法前面已经分析过了，最终是向MainHandler主线程发送了PLUGIN_CONNECTED的msg

private class MainHandler extends Handler {switch (msg.what) {case PLUGIN_CONNECTED:......mListener.onPluginConnected(info.mPlugin, info.mPluginContext);break;case PLUGIN_DISCONNECTED:mListener.onPluginDisconnected((T) msg.obj);......break;}
}

我们看到startListening注册的广播里处理了PluginListener的回调

本篇以SystemUI启动过程中添加的OverlayPlugin为例分析了SystemUI的插件化机制Plugin

关于Plugin作一个总结：
Systemui插件化机制的添加步骤：

创建一个继承自Plugin或者FragmentBase的接口，定义ACTION和VERSION，使用ProvidesInterface注解将ACTION和VERSION暴露出去
创建PluginListener接口作为Plugin的回调
调用PluginManagerImpl的addPluginListener方法添加PluginListener和Plugin

SystemUI插件化的目的就是使开发者能够轻松随意替换SystemUI的一些组件，而不需要修改大量代码，在AOSP提供的官方doc中提到要使用插件化Plugin的条件有：

必须使用平台证书进行签名
必须在LOCAL_JAVA_LIBRARIES中包含SystemUIPluginLib（不能是LOCAL_STATIC_JAVA_LIBRARIES）
声明插件还需要在清单文件中注册类似如下代码：

       <service android:name=".SampleOverlayPlugin"android:label="@string/plugin_label"><intent-filter><action android:name="com.android.systemui.action.PLUGIN_OVERLAY" /></intent-filter></service>

需要添加相应权限：

<uses-permission android:name="com.android.systemui.permission.PLUGIN" />

然后实现你需要替换的SystemUI组件的提供的插件接口

@Requires(target = OverlayPlugin.class, version = OverlayPlugin.VERSION)
public class SampleOverlayPlugin implements OverlayPlugin {...
}