在看Jetpack的官网时，发现在Jetpack中新加了一个App Startup组件，查了一下是最近和Hilt、Paging 3一起更新的。
为什么需要App Startup呢？
在我们实际的开发工作中，一些第三方库需要在App启动的时候初始化并不少见，比如WorkManager和LifeCycle在App启动时通过ContentProvider进行初始化。通过ContentProvider，一旦App冷启动后，在调用Application.onCreate( )之前，ContentProvider就可以自动执行初始化。
App Startup是什么？
Google定义：App Startup这个库在App启动的时候提供了一个直接、高效的方式来初始化组件。所有的library开发者和app开发者能够使用App Startup这个组件来简化启动顺序并且显示地设置初始化顺序。通过App Startup这个组件，您无需为需要初始化的每个组件定义单独的content providers，而是允许通过共享一个content provider来定义组件初始化器，从而提高应用的启动速度.
由上可知，App Startup提供了一个ContentProvider来完成项目需要的一些组件的初始化，避免每个第三方的库(比如友盟统计、埋点等)单独通过ContentProvider 进行初始化。我们可以通过通过App Startup这个组件将所有第三方需要在Application中初始化的一些库都通过ContentProvider来初始化，有点将第三方库初始化这个过程进行了封装的意味。
如何使用App Startup？
我们可以通过定义组件初始化器完成组件的初始化，那么如何定义组件初始化器呢？Android为我们提供了Initializer接口，通过实现接口并实现接口中的两个方法就可以实现组件初始化器的定义了。
我们来看下面这两个方法：
create() : 包含了初始化组件，并且返回T的实例的所有必要操作；
dependencies() : 此方法返回一个初始化程序依赖的其他Initializer对象的列表。可以使用此方法来控制应用程序启动时初始化的顺序。
在没有使用App Startup的时候，如何保证content providers的初始化顺序呢？其实很简单，在配置清单中将先启动的content provider的标签放在前面即可。
下面看下如何进行初始化。
通过App Startup来运行依赖项的初始化有两种方式：
自动初始化(automatic initialization)
手动初始化(manually initialization)
无论是自动初始化还是手动初始化都需要在app或者library中的build.gradle文件中添加如下依赖：
dependencies {
implementation " androidx. startup:star tup- runtime:1.0.0-alpha01"
}
实现自动初始化
假设APP依赖了WorkManager，并且需要在程序一开始启动时就初始化WorkManager，定义一个WorkManagerInitializer类并且实现Initializer接口：
// Initializes WorkManager.
class WorkManagerInitializer : Initializer<WorkManager> {
override fun create(context: Context): WorkManager {
val configuration = Configuration.Builder().build()
WorkManager.nitialize(context, configuration)
return WorkManager.getInstance(context)
}
override fun dependencies(): List<Class<out Initializer<*>>> {
//No dependencies on other l ibraries.
return emptyList()
}
}
如图中所示，dependencies()方法返回了一个空列表，意思是我WorkManager实例化谁也不需要依赖，我自己个就能行。
假设我们的应用依赖了另一个叫做ExampleLogger的库，这个库依赖于WorkManager。这也就意味着，初始化这个库必须先确保WorkManager的实例已经被初始化了才可以。那么如何做呢？我们看下面代码：
// Initializes ExampleLogger ,
class ExampleLoggerInitializer : Initializer<ExampleLogger> {
override fun create(context: Context): ExampleLogger {
// WorkManager.getInstance() is non-null only after
// WorkManager is initialized .
return ExampleLogger(WorkManager.getInstance(context))
}
override fun dependencies(): List<Class<out Initializer<*>>> {
// Defines a dependency on Wor kManagerInitializer so it can be
// initialized after WorkManager is initialized.
return listOf(WorkManagerInitializer::class.java)
}
}
代码中定义了一个ExampleLoggerInitializer类并且实现了Initializer接口。这个时候我们看到dependencies()方法返回的就不是空列表了，而是包含了WorkManagerInitializer的一个列表，这样ExampleLogger要想初始化，必须先初始化WorkManager。
提示：如果App中之前使用content providers来初始化应用程序中的组件，请确保使用App Startup时删除这些content providers
App Startup包含了一个名为InitializationProvider的特殊的content provider，它用来找到并且调用你的组件初始化器。那么这个过程是什么样的呢？
首先，通过检查InitializationProvider清单标签下的标签，找到组件初始化器；
App Startup调用它找到的所有组件初始化器的dependencies()方法。
这就意味着如果想要让App Startup找到组件初始化器，必须满足下面的一个条件：
组件初始化器在InitializationProvider清单标签下配置了相应的标签；
组件初始化器在一个已被找到的组件初始化器的dependencies()方法中被列出；
从上面写过的WorkManagerInitializer和ExampleLoggerInitializer这两个例子中来说，为了确保初始化器能被实现，需要在清单文件中配置如下代码：
<provider
android:name="androidx.startup.InitializationProvider"
android:authorities="${applicationId}.androidx-startup"
android:exported="false"
tools:node="merge">
<!-- This entry makes ExampleLoggerInitializer discoverable. -->
<meta-data
android:name="com.example.ExampleLoggerInitializer"
android:value="androidx.startup" />
</provider>
我们只配置了ExampleLoggerInitializer的标签，因为它是依赖于WorkManager的，并且满足了第二条：dependencies()方法中列出了它依赖于WorkManager，如果ExampleLoggerInitializer能被找到，那么WorkManagerInitializer一定也能被找到。
tools:node="merge"属性是为了确保清单合并工具可能造成的冲突问题
App Startup库包含了一系列的lint规则，通过这些规则，你能够检查是否正确定义了组件初始化器。你可以在终端通过./gradlew :app:lintDebug命令执行lint检查。
实现手动初始化
通常来说，当你使用App Startup时，InitializationProvider对象就会使用AppInitializer在App启动时来自动寻找并且运行初始化器。然而，你也可以直接调用。AppInitializer来手动初始化不需要在启动时就调用的组件初始化器。这个操作被称作懒初始化，它能够减少程序启动的时间。要想实现手动初始化，必须先禁止掉你想要手动初始化的组件的自动初始化功能。
为了禁止掉单个组件的自动初始化功能，可以在清单文件中移除那个组件的标签，举例来说，我们想禁止ExampleLogger的自动初始化：
<provider
android:name="androidx.startup.InitializationProvider"
android:authorities="${applicationId}.androidx-startup"
android:exported="false"
tools:node="merge">
<!-- This entry makes ExampleLoggerInitializer discoverable. -->
<meta-data
android:name="com.example.ExampleLoggerInitializer"
tools:node="remove" />
</provider>
使用tools:node="remove"而不是直接移除这个标签是为了确保清单合并工具能够移除所有合并文件的这个标签。
提示: 禁用组件的自动初始化也会禁用该组件的依赖项的自动初始化，比如我禁用了ExampleLogger，而ExampleLogger依赖了WorkManager，那么WorkManager也不会自动初始化了。
我们现在知道如何禁止单个组件的自动初始化，那么如何禁止全部组件的自动初始化，转而手动初始化呢？
<provider
android:name="androidx.startup.InitializationProvider "
android:authorities="${applicationId}.androidx-startup"
tools:node="remove" />
禁用自动初始化后，你可以使用AppInitializer手动初始化组件和它的依赖。
AppInitializer.getInstance(context)
.initializeComponent(ExampleLoggerInitializer::class.java)
通过上述代码，App Startup也对WorkManager进行了初始化，因为ExampleLogger依赖了WorkManager。
源码分析
App Startup包中代码并不多，只有五个类
其中最核心的类就是InitializationProvider，它是继承了ContentProvider，这样我们就懂了，在onCreate()方法中，可以看到它其实是调用了AppInitializer这个类中的discoverAndInitialize()方法，我们简单看下这个代码：
@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) {
// Use the simpleName here because section names would get too big otherwise.
Trace.beginSection(component.getSimpleName());
}
if (initializing.contains(component)) {
String message = String.format(
"Cannot initialize %s. Cycle detected.", component.getName()
);
throw new IllegalStateException(message);
}
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()));
}
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();
}
}
}
代码很简单，就是解析出来metadata中的数据，然后遍历metadata拿到配置的初始化器，然后调用每个初始化器的初始化方法，也就是doInitialize()方法。接下来再看下这个方法：
@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) {
// Use the simpleName here because section names would get too big otherwise.
Trace.beginSection(component.getSimpleName());
}
if (initializing.contains(component)) {
String message = String.format(
"Cannot initialize %s. Cycle detected.", component.getName()
);
throw new IllegalStateException(message);
}
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()));
}
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();
}
}
}
可以看到在执行初始化的时候，先判断了是否有依赖项，有的话先执行依赖项的初始化。
掘金链接 Android Jetpack组件之App Startup
