Android架构组件–App Startup

1.解决的问题

一般需要初始化的sdk都会对外提供一个初始化方法供外界调用，如：

public class App extends Application {      @Override     public void onCreate() {         super.onCreate();         Sdk1.init(this);     } } 

对调用者很不友好。另一种做法是使用ContentProvider初始化，如下：

public class Sdk1InitializeProvider extends ContentProvider {     @Override     public boolean onCreate() {         Sdk1.init(getContext());         return true;     }  ... } 

然后在AndroidManifest.xml文件中注册这个privoder，如下：

<manifest xmlns:android="https://schemas.android.com/apk/res/android"     package="cn.zhengzhengxiaogege.sdk1">     <application>         <provider             android:authorities="${applicationId}.init-provider"             android:name=".Sdk1InitializeProvider"             android:exported="false"/>     </application> </manifest> 

这样初始化的逻辑就由Sdk开发者在内部完成了。

但是，如果一个app依赖了很多需要初始化的sdk，如果都放在一个ContentProvider中会导致此ContentProvider代码数量增加。而且每增加一个需要初始化的sdk都要对该ContentProvider文件做改动，不方便合作开发。而如果每个sdk都采用同样的方式将会带来性能问题。App Startup library可以有效解决这个问题。

2.使用App StartUp

(1)添加依赖

在App模块的build.gradle文件中添加依赖：

dependencies {     implementation "androidx.startup:startup-runtime:1.0.0-alpha01" } 

(2)实现Initializer<T>接口

app通过Initializer<T>接口接入App Startup，需要实现两个方法

public interface Initializer<T> {    @NonNull   T create(@NonNull Context context);    @NonNull   List<Class<? extends Initializer<?>>> dependencies(); }  

例如有一个Sdk1如下：

public class Sdk1 {    private static final String TAG = "Sdk1";    private static Context sApplicationContext;    private static volatile Sdk1 sInstance;    public static void init(Context applicationContext){       sApplicationContext = applicationContext;       Log.e(TAG, "Sdk1 is initialized");   }    public static Sdk1 getInstance(){       if (sInstance == null) {           synchronized (Sdk1.class){               if (sInstance == null) {                   sInstance = new Sdk1();               }           }       }       return sInstance;   }    private Sdk1(){   }    public void printApplicationName(){       Log.e(TAG, sApplicationContext.getPackageName());   } } 

sdk1对外提供Sdk1类，包含初始化方法init(Context)，实例获取方法getInstance()和对外的服务方法printApplicationName()。为了使用App Startup，需要提供一个初始化器如下：

public class Sdk1Initializer implements Initializer<Sdk1> {     @NonNull     @Override     public Sdk1 create(@NonNull Context context) {         Sdk1.init(context);         return Sdk1.getInstance();     }      @NonNull     @Override     public List<Class<? extends Initializer<?>>> dependencies() {         return Collections.emptyList();     } } 

泛型T为待初始化的Sdk对外提供的对象类型；create(Context)方法是该Sdk初始化
逻辑写入的地方，其参数context为Application Context，同时需要返回一个Sdk对外提供的对象实例。

dependencies()方法则需要返回一个列表，这个列表需要给出一个该Sdk依赖的其它
Sdk的初始化器，也就是这个列表决定了哪些sdk会在这个sdk之前初始化，如果这个sdk是独立的没有依赖与其它的sdk，可以将该方法返回一个空列表(如Sdk1Initializer的实现)。

但是如果这个sdk依赖于其它的sdk，必须在其它sdk初始化之后才能初始化，则需要在dependencies()方法中指明。例如现在有一个sdk2也需要初始化，且它必须在sdk1初始化之后才能初始化，那么sdk2的初始化器的实现如下：

public class Sdk2Initializer implements Initializer<Sdk2> {     @NonNull     @Override     public Sdk2 create(@NonNull Context context) {         Sdk2.init(context);         return Sdk2.getInstance();     }      @NonNull     @Override     public List<Class<? extends Initializer<?>>> dependencies() {         List<Class<? extends Initializer<?>>> dependencies = new ArrayList<>();         dependencies.add(Sdk1Initializer.class);         return dependencies;     } } 

在dependencies()方法中指明了Skd2的依赖项，因此App Startup会在初始化sdk2之前先初始化sdk1。

(3)注册Provider和Initializer<?>

我们需要告诉App Startup我们实现了哪些Sdk初始化器(Sdk1Initializer、Sdk2Initializer)。同时App Startup并没有提供AndroidManifest.xml文件，因此App Startup用到的provider同样需要注册。在app的AndroidManifest.xml文件添加如下代码：

<provider             android:authorities="${applicationId}.androidx-startup"             android:name="androidx.startup.InitializationProvider"             android:exported="false"             tools:node="merge">             <meta-data                 android:name="cn.zhengzhengxiaogege.appstartupstudy.Sdk1Initializer"                 android:value="@string/androidx_startup"/>    <meta-data     android:name="cn.zhengzhengxiaogege.appstartupstudy.Sdk2Initializer"     android:value="@string/androidx_startup"/>         </provider> 

通常每一个初始化器对应一个<meta-data>标签，但是如果有些初始化器已经被一个已
经注册的初始化器依赖(比如Sdk1Initializer已经被Sdk2Initializer依赖)，那么
可以不用在AndroidManifest.xml文件中显式地指明，因为App Startup已经通过
注册的Sdk2Initializer找到它了。

这里的<meta-data>标签的value属性必须指定为字符串androidx_startup的值，
也就是("androidx.startup")，否则将不生效。

如果有一个sdk3内部通过App Startup帮助使用者处理了初始化，那么sdk3的AndroidManifest.xml文件中已经存在了InitializationProvider的provider标签，此时会与app模块中的冲突，因此在app模块的provider标签中指明tools:node="merge"，通过AndroidManifest.xml文件的合并机制。

3.App StartUp实现懒加载

为了减少app启动时间，对于一些非必须的初始化应该在app启动后、sdk使用前完成初始化，使用在provider中注册的方法不能达到这个目的。App StartUp提供了AppInitializer来解决这个问题。如下，在需要初始化的位置使用AppInitializer:

public class MainActivity extends AppCompatActivity {      private static final String TAG = "MainActivity";      @Override     protected void onCreate(Bundle savedInstanceState) {         super.onCreate(savedInstanceState);         setContentView(R.layout.activity_main);          Log.d(TAG, "MainActivity Created");          AppInitializer.getInstance(getApplicationContext())                 .initializeComponent(Sdk2Initializer.class);          Sdk1.getInstance().printApplicationName();     } } 

同时需要失能AndroidManifest.xml文件中的对应初始化器的<meta-data>，如下：

<provider             android:authorities="${applicationId}.androidx-startup"             android:name="androidx.startup.InitializationProvider"             android:exported="false"             tools:node="merge">             <meta-data                 android:name="cn.zhengzhengxiaogege.appstartupstudy.Sdk2Initializer"                 android:value="@string/androidx_startup"                 tools:node="remove"/>         </provider> 

通过tools:node="remove"来标记该初始化器。这样会在AndroidManifest.xml文件合并时将这个<meta-data>移除掉，否则该初始化器仍会在Application中被初始化并标记为已经初始化，后面的懒加载将不执行任何初始化操作，相当于使懒加载失效了。

4.剖析App StartUp

App StartUp的设计思路比较简单，就是将多个需要初始化的Sdk在一个provider中完成，从而减少多个provider带来的性能问题和繁杂的AndroidManifest.xml文件声明。目前App StartUp为1.0.0-alpha01版本，其代码结构非常简单。

只有五个类文件，除去StartupException和StartupLogger，其核心类只有三个。

Intializer.java的作用很简单，就是为lib的使用者提供了接入的方法，因此不再赘述。

InitializationProvider.java是App StartUp中使用的单一的provider，所有注册的初始化将在这个provider中完成。App StartUp只重写了OnCreate()方法：

public final class InitializationProvider extends ContentProvider {     @Override     public boolean onCreate() {         Context context = getContext();         if (context != null) {             AppInitializer.getInstance(context).discoverAndInitialize();         } else {             throw new StartupException("Context cannot be null");         }         return true;     }  ... 

可以看到，在OnCreate()方法中执行了扫描和初始化注册的组件。其实现方法在
AppInitializer.java中。AppInitializer内部是一个单例实现，它的getInstance(Context)方法传入的是Application级别的Context，并将其传递给注册的各Intializer，首先看discoverAndInitialize()方法：

@SuppressWarnings("unchecked") void discoverAndInitialize() {  try {   Trace.beginSection(SECTION_NAME);      // 扫描并获取Manifest文件中的 `InitializationProvider`这个组件中注册的<meta-data>   // 信息   ComponentName provider = new ComponentName(mContext.getPackageName(),     InitializationProvider.class.getName());   ProviderInfo providerInfo = mContext.getPackageManager()     .getProviderInfo(provider, GET_META_DATA);   Bundle metadata = providerInfo.metaData;      // 然后遍历<meta-data>标签，获取到每个标签的 `Initializer`并对其初始化   String startup = mContext.getString(R.string.androidx_startup);   if (metadata != null) {    Set<Class<?>> initializing = new HashSet<>();    Set<String> keys = metadata.keySet();    for (String key : keys) {          // 注意这里会用<meta-data>标签的value属性的值和`@string/androidx_startup`     // 对比，只有是这个值的<meta-data>标签才会被初始化。     String value = metadata.getString(key, null);     if (startup.equals(value)) {      Class<?> clazz = Class.forName(key);      if (Initializer.class.isAssignableFrom(clazz)) {       Class<? extends Initializer<?>> component =         (Class<? extends Initializer<?>>) clazz;       if (StartupLogger.DEBUG) {        StartupLogger.i(String.format("Discovered %s", key));       }       doInitialize(component, initializing);      }     }    }   }  } catch (PackageManager.NameNotFoundException | ClassNotFoundException exception) {   throw new StartupException(exception);  } finally {   Trace.endSection();  } } 

discoverAndInitialize()方法首先扫描清单文件获取到需要初始化的初始化器Initializer，然后执行初始化操作，即调用doInitialize(Class<? extends Initializer<?>>, Set<Class<?>>)方法，如下：

@NonNull @SuppressWarnings({"unchecked", "TypeParameterUnusedInFormals"}) <T> T doInitialize(   @NonNull Class<? extends Initializer<?>> component,   @NonNull Set<Class<?>> initializing) {  synchronized (sLock) {   boolean isTracingEnabled = Trace.isEnabled();   try {    if (isTracingEnabled) {     Trace.beginSection(component.getSimpleName());    }        // `initializing`存储着正在初始化的初始化器。    // 这个判断是要解决循环依赖的问题，比如 `Sdk1Initializer`依赖了它本身，或者是    // `Sdk1Initializer` 依赖了 `Sdk2Initializer`，同时 `Sdk2Initializer` 又    // 依赖了 `Sdk1Initializer`，这是存在逻辑错误的，因此需要排除。    if (initializing.contains(component)) {     String message = String.format(       "Cannot initialize %s. Cycle detected.", component.getName()     );     throw new IllegalStateException(message);    }        // `mInitialized` 是一个 `Map<Class<?>, Object>`，它缓存了已经执行过初始化的    // `Initializer`的 `Class` 对象和初始化的结果，通过这种方法来避免重复初始化。    Object result;    if (!mInitialized.containsKey(component)) {          // 这是这个初始化器还没被初始化的情况。     initializing.add(component);     try {            // 首先构造一个该初始化器的实例      Object instance = component.getDeclaredConstructor().newInstance();      Initializer<?> initializer = (Initializer<?>) instance;            // 读取它的依赖关系，如果有依赖的初始化器，要先对他们做初始化。      List<Class<? extends Initializer<?>>> dependencies =        initializer.dependencies();      if (!dependencies.isEmpty()) {       for (Class<? extends Initializer<?>> clazz : dependencies) {        if (!mInitialized.containsKey(clazz)) {         doInitialize(clazz, initializing);        }       }      }            if (StartupLogger.DEBUG) {       StartupLogger.i(String.format("Initializing %s", component.getName()));      }            // 调用初始化器的 `create(Context)`方法，执行具体的初始化逻辑。      result = initializer.create(mContext);            if (StartupLogger.DEBUG) {       StartupLogger.i(String.format("Initialized %s", component.getName()));      }            // 最后把这个初始化器标为已初始化并缓存结果。      initializing.remove(component);      mInitialized.put(component, result);     } catch (Throwable throwable) {      throw new StartupException(throwable);     }    } else {     // 已经初始化过了，就直接从缓存中取走结果即可。     result = mInitialized.get(component);    }    return (T) result;   } finally {    Trace.endSection();   }  } } 

doInitialize(Class<? extends Initializer<?>>, Set<Class<?>>)方法首先会实例化一个初始化器，然后通过dependencies()方法找到它依赖的初始化器做递归初始化，这个过程中如果遇到诸如依赖自身、循环依赖等逻辑错误问题将抛出异常。处理完依赖后调用它的create(Context)方法执行具体的初始化逻辑。最后初始化完成，将状态和结果缓存，防止多次初始化。

用来做懒加载的initializeComponent(Class<? extends Initializer<T>>)的方法就比较简单了，它直接调用doInitialize(Class<? extends Initializer<?>>, Set<Class<?>>)方法对指定的初始化器做初始化，如下：

@NonNull @SuppressWarnings("unused") public <T> T initializeComponent(@NonNull Class<? extends Initializer<T>> component) {  return doInitialize(component, new HashSet<Class<?>>()); } 

5.App StartUp利弊

优点：

• 解决了多个sdk初始化导致Application文件和Mainfest文件需要频繁改动的问题，同时也减少了Application文件和Mainfest文件的代码量，更方便维护了
• 方便了sdk开发者在内部处理sdk的初始化问题，并且可以和调用者共享一个ContentProvider，减少性能损耗。
• 提供了所有sdk使用同一个ContentProvider做初始化的能力，并精简了sdk的使用流程。
• 符合面向对象中类的单一职责原则
• 有效解耦，方便协同开发

缺点：

• 会通过反射实例化Initializer<>的实现类，在低版本系统中会有一定的性能损耗。
• 必须给Initializer<>的实现类提供一个无参构造器，当然也不能算是缺点，如果缺少的话新版的android studio会通过lint检查给出提醒。

• 导致类文件增多，特别是有大量需要初始化的sdk存在时。
• 版本较低，还没有发行正式版。