App Startup是用来在应用进程启动的时候初始化其他组件的。
一般我们初始化的操作都放在Application的onCreate方法中或者ContentProvider的onCreate方法中,因为ContentProvider的onCreate方法会在进程创建的时候调用。
但是ContentProvider的创建成本比较高,并且它的onCreate方法会延长应用的启动时间,所以如果应用中或三方库中定义了多个ContentProvider,势必会对应用的性能产生影响。
App Startup 就是为了解决这个问题,它可以是应用的所有初始化操作(包括三方库和应用自定义内容)共用同一ContentProvider,并且可以控制初始化的顺序。
首先,需要在gradle中添加依赖
dependencies {
implementation "androidx.startup:startup-runtime:1.0.0"
}
其次,实现接口Initializer<T>,并提供它的两个方法的实现。
Initializer的源码如下:
/**
* {@link Initializer}s can be used to initialize libraries during app startup, without
* the need to use additional {@link android.content.ContentProvider}s.
*
* @param <T> The instance type being initialized
*/
public interface Initializer<T> {
/**
* Initializes and a component given the application {@link Context}
*
* @param context The application context.
*/
@NonNull
T create(@NonNull Context context);
/**
* @return A list of dependencies that this {@link Initializer} depends on. This is
* used to determine initialization order of {@link Initializer}s.
* <br/>
* For e.g. if a {@link Initializer} `B` defines another
* {@link Initializer} `A` as its dependency, then `A` gets initialized before `B`.
*/
@NonNull
List<Class<? extends Initializer<?>>> dependencies();
}
在create方法中需要初始化并返回组件的实例。
dependencies方法中指定了初始化当前组件需要依赖哪些其他的组件,这个方法决定了组件初始化的顺序。比如B组件依赖于A组件,那A在B之前初始化。
可以看一下WorkManagerInitializer的源码
/**
* Initializes {@link androidx.work.WorkManager} using {@code androidx.startup}.
*/
public final class WorkManagerInitializer implements Initializer<WorkManager> {
private static final String TAG = Logger.tagWithPrefix("WrkMgrInitializer");
@NonNull
@Override
public WorkManager create(@NonNull Context context) {
// Initialize WorkManager with the default configuration.
Logger.get().debug(TAG, "Initializing WorkManager with default configuration.");
WorkManager.initialize(context, new Configuration.Builder().build());
return WorkManager.getInstance(context);
}
@NonNull
@Override
public List<Class<? extends androidx.startup.Initializer<?>>> dependencies() {
return Collections.emptyList();
}
}
假设,我们的应用同样依赖一个叫做ExampleLogger的三方库,并且ExampleLogger依赖于WorkManager,那我们可以定义一个ExampleLoggerInitializer
// Initializes ExampleLogger.
class ExampleLoggerInitializer implements Initializer<ExampleLogger> {
@Override
public ExampleLogger create(Context context) {
// WorkManager.getInstance() is non-null only after
// WorkManager is initialized.
return ExampleLogger(WorkManager.getInstance(context));
}
@Override
public List<Class<Initializer<?>>> dependencies() {
// Defines a dependency on WorkManagerInitializer so it can be
// initialized after WorkManager is initialized.
return Arrays.asList(WorkManagerInitializer.class);
}
}
这样就能确保 WorkManager在 ExampleLogger之前初始化。
最后,需要在manifest中进行声明
App Startup中包含一个InitializationProvider,它是ContentProvider的子类,用来发现和调用我们定义的initializers。App Startup会首先检查manifest中定义的<meta-data>,然后初始化已经发现的initializers的依赖组件。
比如,我们上边定义的WorkManagerInitializer和ExampleLoggerInitializer,我们只需要在<meta-data>中定义ExampleLoggerInitializer,因为ExampleLoggerInitializer依赖于WorkManagerInitializer,所以App Startup可以找到WorkManagerInitializer并先进行初始化。
<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>
tools:node="merge"可以确保merge工具可以正确的处理冲突。
我们也可以手动的初始化组件。
首先,要先关闭自动初始化。
对单个组件,删除对应的<meta-data>即可。
<meta-data android:name="com.example.ExampleLoggerInitializer"
tools:node="remove" />
对全部的组件,可以删掉provider的声明。
<provider
android:name="androidx.startup.InitializationProvider"
android:authorities="${applicationId}.androidx-startup"
tools:node="remove" />
然后,在需要使用组件的地方手动调用初始化方法。
AppInitializer.getInstance(context)
.initializeComponent(ExampleLoggerInitializer.class);
从源码中分析原理
public class InitializationProvider extends ContentProvider {
@Override
public final boolean onCreate() {
Context context = getContext();
if (context != null) {
AppInitializer.getInstance(context).discoverAndInitialize();
} else {
throw new StartupException("Context cannot be null");
}
return true;
}
}
我们可以看到InitializationProvider继承了ContentProvider,并在其onCreate方法中调用了AppInitializer. discoverAndInitialize方法
@SuppressWarnings("unchecked")
void discoverAndInitialize() {
try {
Trace.beginSection(SECTION_NAME);
ComponentName provider = new ComponentName(mContext.getPackageName(),
InitializationProvider.class.getName());
ProviderInfo providerInfo = mContext.getPackageManager()
.getProviderInfo(provider, GET_META_DATA);
Bundle metadata = providerInfo.metaData;
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) {
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;
mDiscovered.add(component);
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();
}
}
@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();
}
}
}
代码比较简单明了,大家可以自行查看。
缺点
1、App Startup对于直接在Application.onCreate方法中进行初始化的方法优势不是很明显。
2、对于每一个需要初始化的组件都要定义一个Initializer,是不是太繁琐了?
网友评论