App Startup 源碼分析

拋磚引玉

使用過 LeakCanary 的童鞋都知道，早在 LeakCanary 1.x 版本的時(shí)候，我們需要在 Application 中手動(dòng)調(diào)用 install 方法來完成 LeakCanary 的初始化過程。

而 LeakCanary 2.x 的版本實(shí)現(xiàn)了自動(dòng)初始化。通過查看 LeakCanary 2.x 的源碼，我們可以發(fā)現(xiàn)，它通過繼承 ContentProvider ，在 onCreate() 中來完成初始化過程。

internal sealed class AppWatcherInstaller : ContentProvider() {

  override fun onCreate(): Boolean {
    val application = context!!.applicationContext as Application

    val leakCanaryEnable = application
            .getSharedPreferences(KEY_LEAK_CANARY_ENABLE_FILE, Context.MODE_PRIVATE)
            .getBoolean(KEY_LEAK_CANARY_ENABLE, false)
    if (!leakCanaryEnable) {
      Log.d("LeakCanary", "Sorry ! you can't init LeakCanary")
      return true
    }
    InternalAppWatcher.install(application)
    return true
  }
  
}

為什么使用 ContentProvider 就能夠達(dá)到自動(dòng)初始化呢？

在應(yīng)用程序啟動(dòng)過程中，會(huì)調(diào)用到 ActivityThread.handleBindApplication()，我們可以看到如下關(guān)鍵代碼。

// 1. 這里會(huì)反射創(chuàng)建 Application, 并調(diào)用 Application.attach()
app = data.info.makeApplication(data.restrictedBackupMode, null);

if (!data.restrictedBackupMode) {
    if (!ArrayUtils.isEmpty(data.providers)) {
        // 2. 這里會(huì)裝載 ContentProvider
        installContentProviders(app, data.providers);
    }
}

try {
    // 3. 這里會(huì)調(diào)用Application 的 onCreate()
    mInstrumentation.callApplicationOnCreate(app);
} catch (Exception e) {
}

通過源碼，我們知道它的調(diào)用順序如下。

  1. 創(chuàng)建 Application，調(diào)用 Application.attach()；
  2. 裝載 ContentProvider；
  3. 調(diào)用 Application.onCreate();

所以在 ContentProvider.onCreate() 里面是可以拿到 application context ， 在這里進(jìn)行初始化是沒有問題的。

而 本文介紹的 Jetpack 的新成員 App Startup 就是通過 ContentProvider 來完成實(shí)現(xiàn)的。

App Startup 的使用

使用 App Startup 庫，我們需要在 build.gradle 中添加依賴。

implementation "androidx.startup:startup-runtime:1.0.0-alpha01"

實(shí)現(xiàn) Initializer 接口，為組件創(chuàng)建初始化程序。

舉個(gè)栗子，這里為 LibraryA 創(chuàng)建初始化程序，dependencies() 返回了一個(gè)集合，表明它依賴于其他庫的初始化。

class LibraryAInitializer : Initializer<LibraryA> {

    override fun create(context: Context): LibraryA {
        return LibraryA.getInstance(context)
    }

    override fun dependencies(): MutableList<Class<out Initializer<*>>> {
        return arrayListOf()
    }

}

在 manifest.xml 文件中配置 InitializationProvider， App Startup 使用指定的 ContentProvider 來檢索和初始化 Initializer。

<provider
    android:name="androidx.startup.InitializationProvider"
    android:authorities="${applicationId}.androidx-startup"
    android:exported="false"
    tools:node="merge">
</provider>

每個(gè) Initializer 使用 <meta-data /> 節(jié)點(diǎn)定義，其 value 必須為 androidx.startup（這里后面源碼會(huì)講到）。

<meta-data
    android:name="com.ppdai.code.jetpack.startup.initializer.LibraryAInitializer"
    android:value="androidx.startup" />

這樣，在 app 啟動(dòng)過程中就會(huì)自動(dòng)初始化 LibraryA 這個(gè)庫，是不是非常的簡單。

假設(shè) LibraryA 的初始化依賴于 LibraryB，我們只需要編寫 LibraryB 的 Initializer，然后修改 LibraryAInitializer，在其 dependencies() 方法中返回 LibraryB 的 Initializer 即可。

class LibraryAInitializer : Initializer<LibraryA> {

    override fun create(context: Context): LibraryA {
        return LibraryA.getInstance(context)
    }

    override fun dependencies(): MutableList<Class<out Initializer<*>>> {
        return arrayListOf(LibraryBInitializer::class.java)
    }

}

class LibraryBInitializer : Initializer<LibraryB> {

    override fun create(context: Context): LibraryB {
        return LibraryB.getInstance(context)
    }

    override fun dependencies(): MutableList<Class<out Initializer<*>>> {
        return arrayListOf()
    }

}

這樣在初始化 LibraryA 的時(shí)候會(huì)先初始化 LibraryB。

如果不希望在 app 啟動(dòng)的時(shí)候初始化，我們也可以通過 AppInitializer.initializeComponent() 在代碼中對(duì)指定的組件進(jìn)行初始化，如下所示。

AppInitializer.getInstance(this).initializeComponent(LibraryAInitializer::class.java)

源碼分析

InitializationProvider

InitializationProvider 在 Application.onCreate() 調(diào)用之前檢索和初始化 Initializer

我們來看看 InitializationProvider 的具體實(shí)現(xiàn)，可以發(fā)現(xiàn)它只是在 onCreate() 方法中調(diào)用了 AppInitializer 的 discoverAndInitialize()。

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;
    }

    @Nullable
    @Override
    public Cursor query(
            @NonNull Uri uri,
            @Nullable String[] projection,
            @Nullable String selection,
            @Nullable String[] selectionArgs,
            @Nullable String sortOrder) {
        throw new IllegalStateException("Not allowed.");
    }

    @Nullable
    @Override
    public String getType(@NonNull Uri uri) {
        throw new IllegalStateException("Not allowed.");
    }

    @Nullable
    @Override
    public Uri insert(@NonNull Uri uri, @Nullable ContentValues values) {
        throw new IllegalStateException("Not allowed.");
    }

    @Override
    public int delete(
            @NonNull Uri uri,
            @Nullable String selection,
            @Nullable String[] selectionArgs) {
        throw new IllegalStateException("Not allowed.");
    }

    @Override
    public int update(
            @NonNull Uri uri,
            @Nullable ContentValues values,
            @Nullable String selection,
            @Nullable String[] selectionArgs) {
        throw new IllegalStateException("Not allowed.");
    }
}

AppInitializer

AppInitializer 是真正對(duì) Initializer 進(jìn)行初始化的地方。

AppInitializer 可以拆分為三個(gè)部分。

  1. AppInitializer 的創(chuàng)建；
  2. 如何初始化在 manifest.xml 中配置的 Initializer ；
  3. 如何在代碼中初始化指定 Initializer 。

創(chuàng)建

AppInitializer 使用單例模式。成員變量 mInitialized 用來存放已經(jīng)初始化的 Initializer，保證所有的 Intializer 只被初始化一次。

private static AppInitializer sInstance;

// 用來存放已初始化的 Initializer
@NonNull
final Map<Class<?>, Object> mInitialized;

@NonNull
final Context mContext;

AppInitializer(@NonNull Context context) {
    mContext = context.getApplicationContext();
    mInitialized = new HashMap<>();
}

@NonNull
@SuppressWarnings("UnusedReturnValue")
public static AppInitializer getInstance(@NonNull Context context) {
    synchronized (sLock) {
        if (sInstance == null) {
            sInstance = new AppInitializer(context);
        }
        return sInstance;
    }
}

初始化 manifest.xml 中配置的 Initializer

這個(gè)過程主要是通過 discoverAndInitialize 這個(gè)方法來完成的

void discoverAndInitialize() {
    try {
        Trace.beginSection(SECTION_NAME);
        // 1. 獲取InitializationProvider在manifest中配置的meta-data
        ComponentName provider = new ComponentName(mContext.getPackageName(),
                InitializationProvider.class.getName());
        ProviderInfo providerInfo = mContext.getPackageManager()
                .getProviderInfo(provider, GET_META_DATA);
        Bundle metadata = providerInfo.metaData;
        // androidx.startup
        String startup = mContext.getString(R.string.androidx_startup);
        if (metadata != null) {
            Set<Class<?>> initializing = new HashSet<>();
            Set<String> keys = metadata.keySet();
            // 2. 遍歷meta-data，找到所有value="androidx.startup"的元素，進(jìn)行初始化
            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;
                        if (StartupLogger.DEBUG) {
                            StartupLogger.i(String.format("Discovered %s", key));
                        }
                        // 3. 初始化指定的 Initializer
                        doInitialize(component, initializing);
                    }
                }
            }
        }
    } catch (PackageManager.NameNotFoundException | ClassNotFoundException exception) {
        throw new StartupException(exception);
    } finally {
        Trace.endSection();
    }
}

可以看出，通過解析 meta-data ，我們就能拿到配置的 Initializer，然后逐一調(diào)用 doInitialize() 進(jìn)行初始化。

再看看 doInitialize 做了什么事情。

<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;
            // 1. 保證 Initializer 只初始化一次
            if (!mInitialized.containsKey(component)) {
                initializing.add(component);
                try {
                    // 2. 通過反射創(chuàng)建 Initializer 
                    Object instance = component.getDeclaredConstructor().newInstance();
                    Initializer<?> initializer = (Initializer<?>) instance;
                    // 3. 獲取 Initializer 的依賴關(guān)系
                    List<Class<? extends Initializer<?>>> dependencies =
                            initializer.dependencies();

                    // 4. 遞歸初始化，先初始化 Initializer 依賴的且沒有被初始化過的 Initializer
                    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()));
                    }
                    // 5. 初始化自身
                    result = initializer.create(mContext);
                    if (StartupLogger.DEBUG) {
                        StartupLogger.i(String.format("Initialized %s", component.getName()));
                    }
                    initializing.remove(component);
                    // 6. 將 Initializer 放入已初始化 Map
                    mInitialized.put(component, result);
                } catch (Throwable throwable) {
                    throw new StartupException(throwable);
                }
            } else {
                result = mInitialized.get(component);
            }
            return (T) result;
        } finally {
            Trace.endSection();
        }
    }
}

在代碼中初始化指定的Initializer

我們可以通過 AppInitializer 的 initializeComponent() 在代碼中初始化指定的 Initializer。

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

可以看到，它實(shí)際上也是調(diào)用了 doInitialize() 方法。

Initializer

用來在 app startup 過程中初始化 libraries

public interface Initializer<T> {

    // application context
    @NonNull
    T create(@NonNull Context context);

    // 返回 Initializer 的依賴。比如初始化 A，A 依賴于B，那么在初始化 A 的時(shí)候會(huì)優(yōu)先查看 B 是否初始化了，如果沒有初始化 B，則會(huì)先初始化 B。
    @NonNull
    List<Class<? extends Initializer<?>>> dependencies();
}

參考

App Startup

Github/Jetpack-App Startup

最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請(qǐng)聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時(shí)請(qǐng)結(jié)合常識(shí)與多方信息審慎甄別。
平臺(tái)聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點(diǎn)，簡書系信息發(fā)布平臺(tái)，僅提供信息存儲(chǔ)服務(wù)。

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容