概述

Dependency是用来封装SystemUI应用中的一些依赖对象。
启动过程：SystemUIApplication的startServicesIfNeeded方法通过反射创建了DependencyCreator的对象，然后调用它的apply方法创建了Dependency对象，最后调用Dependency的start方法完成启动。

DependencyCreator

    public static class DependencyCreator implements Injector {
        @Override
        public SystemUI apply(Context context) {
            Dependency dependency = new Dependency();//创建Dependency对象
            SystemUIFactory.getInstance().getRootComponent()//DaggerSystemUIFactory_SystemUIRootComponent
                    .createDependency()//DaggerSystemUIFactory_SystemUIRootComponent.DependencyInjectorImpl
                    .createSystemUI(dependency);//对dependency 进行初始化
            return dependency;
        }
    }

apply方法主要做的两件事：创建Dependency对象然后通过createSystemUI方法对Dependency对象的属性赋值。

Dependency对象的创建

Dependency关键属性如下：

    //定义一系列DependencyKey对象
    public static final DependencyKey<Looper> BG_LOOPER = new DependencyKey<>(BG_LOOPER_NAME);
    public static final DependencyKey<Handler> BG_HANDLER = new DependencyKey<>(BG_HANDLER_NAME);
    public static final DependencyKey<Handler> TIME_TICK_HANDLER = new DependencyKey<>(TIME_TICK_HANDLER_NAME);
    public static final DependencyKey<Handler> MAIN_HANDLER = new DependencyKey<>(MAIN_HANDLER_NAME);
    public static final DependencyKey<String> LEAK_REPORT_EMAIL = new DependencyKey<>(LEAK_REPORT_EMAIL_NAME);

    private static Dependency sDependency;//单例对象
    private final ArrayMap<Object, Object> mDependencies = new ArrayMap<>();//缓存创建的依赖对象
    private final ArrayMap<Object, LazyDependencyCreator> mProviders = new ArrayMap<>();//缓存所有相关的LazyDependencyCreator

    //以下为Lazy对象，在DependencyInjectorImpl的createSystemUI方法中被赋值
    @Inject Lazy<ActivityStarter> mActivityStarter;
    @Inject Lazy<ActivityStarterDelegate> mActivityStarterDelegate;
    @Inject Lazy<AsyncSensorManager> mAsyncSensorManager;
    @Inject Lazy<BluetoothController> mBluetoothController;
    @Inject Lazy<LocationController> mLocationController;
    //...定义各种Lazy对象

DependencyKey封装一个字符串，作为Key来使用，使用泛型来限制Value的类型，代码如下：

    public static final class DependencyKey<V> {
        private final String mDisplayName;

        public DependencyKey(String displayName) {
            mDisplayName = displayName;
        }

        @Override
        public String toString() {
            return mDisplayName;
        }
    }

Lazy提供一个get方法来获取对象。

public interface Lazy<T> {
    T get();
}

LazyDependencyCreator用来创建依赖对象。

    private interface LazyDependencyCreator<T> {
        T createDependency();//此方法返回一个依赖对象
    }

createSystemUI给属性赋值

apply方法中创建了DependencyInjector的实现对象DependencyInjectorImpl，并调用createSystemUI方法对Dependency进行了初始化，相关代码如下：

    @Subcomponent
    public interface DependencyInjector {
        void createSystemUI(Dependency dependency);//此方法的实现会对传入的dependency对象的一系列属性进行赋值。
    }

DependencyInjectorImpl的实现

       public void createSystemUI(Dependency dependency) {
            this.injectDependency(dependency);
        }

        private Dependency injectDependency(Dependency instance) {
            Dependency_MembersInjector.injectMActivityStarter(instance, DoubleCheck.lazy(DaggerSystemUIFactory_SystemUIRootComponent.this.activityStarterDelegateProvider));
            Dependency_MembersInjector.injectMActivityStarterDelegate(instance, DoubleCheck.lazy(DaggerSystemUIFactory_SystemUIRootComponent.this.activityStarterDelegateProvider));
            //...大量类似的inject方法
            return instance;
        }
    }

DoubleCheck.lazy返回Lazy对象，下面是DoubleCheck.lazy方法的实现

    public static <P extends Provider<T>, T> Lazy<T> lazy(P provider) {
        if (provider instanceof Lazy) {
            Lazy<T> lazy = (Lazy)provider;
            return lazy;
        } else {//如果不是Lazy对象，创建DoubleCheck对象返回
            return new DoubleCheck((Provider)Preconditions.checkNotNull(provider));
        }
    }

DoubleCheck实现了Lazy，用于懒创建，get方法第一次调用时获取provider的get返回值，缓存返回值，之后的调用直接使用缓存。

    //DoubleCheck.java
    public T get() {//这个方法实现了双重校验锁，保证对象只会被实例化一次
        Object result = this.instance;
        if (result == UNINITIALIZED) {
            synchronized(this) {
                result = this.instance;
                if (result == UNINITIALIZED) {
                    result = this.provider.get();
                    this.instance = reentrantCheck(this.instance, result);
                    this.provider = null;
                }
            }
        }
        return result;
    }

inject系列的方法主要是给Dependency的属性赋值

    //Dependency_MembersInjector.java
    public static void injectMActivityStarter(Dependency instance, Lazy<ActivityStarter> mActivityStarter) {
        instance.mActivityStarter = mActivityStarter;//给Dependency的属性赋值
    }

     //...

start初始化

 @Override
    public void start() {
        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);
        //...缓存各种LazyDependencyCreator
        sDependency = this;
    }

在start方法中将所有的LazyDependencyCreator对象存放在mProviders中，最后给sDependency 赋值，这样，Dependency启动完成。

Dependency关键方法

    @Deprecated
    public static <T> T get(Class<T> cls) {
        return sDependency.getDependency(cls);//静态方法获取依赖对象
    }

    @Deprecated
    public static <T> T get(DependencyKey<T> cls) {
        return sDependency.getDependency(cls);//静态方法获取依赖对象
    }

    protected final <T> T getDependency(Class<T> cls) {
        return getDependencyInner(cls);//获取依赖对象
    }

    protected final <T> T getDependency(DependencyKey<T> key) {
        return getDependencyInner(key);//获取依赖对象
    }

    private synchronized <T> T getDependencyInner(Object key) {
        @SuppressWarnings("unchecked")
        T obj = (T) mDependencies.get(key);//缓存中获取
        if (obj == null) {//没有通过createDependency方法创建
            obj = createDependency(key);
            mDependencies.put(key, obj);//添加到缓存中
        }
        return obj;
    }

    @VisibleForTesting
    protected <T> T createDependency(Object cls) {
        Preconditions.checkArgument(cls instanceof DependencyKey<?> || cls instanceof Class<?>);

        @SuppressWarnings("unchecked")
        LazyDependencyCreator<T> provider = mProviders.get(cls);//取出LazyDependencyCreator
        if (provider == null) {
            throw new IllegalArgumentException("Unsupported dependency " + cls
                    + ". " + mProviders.size() + " providers known.");
        }
        return provider.createDependency();//创建对象
    }

    private <T> void destroyDependency(Class<T> cls, Consumer<T> destroy) {
        T dep = (T) mDependencies.remove(cls);//从缓存中移除
        if (dep != null && destroy != null) {
            destroy.accept(dep);
        }
    }

当外界请求获取依赖时，从mDependencies缓存中获取，缓存中没有时从mProviders中获取对应的LazyDependencyCreator来获取，并放入mDependencies缓存。

总结

Dependency用来向SystemUI提供一些特定的全局对象，内部维护这些对象的创建者和这些对象的缓存，当需要的对象时，如果缓存没有，由创建者创建对象并存入缓存。
可以通过Class或DependencyKey来获取对象。

Android10 SystemUI之Dependency