点赞关注，不再迷路，你的支持对我意义重大！

🔥 Hi，我是丑丑。本文 「Android 路线」| 导读 —— 从零到无穷大 已收录，这里有 Android 进阶成长路线笔记 & 博客，欢迎跟着彭丑丑一起成长。（联系方式在 GitHub）

---

前言

• ContentProvider 是 Android 四大组件之一，属于内容共享型组件；
• 在这上篇文章里，我已经讨论过 ContentProvider 的基本使用方法，在这篇文章里将讨论 ContentProvider 的原理 & 源码分析。如果能帮上忙，请务必点赞加关注，这真的对我非常重要。

• 《Android | ContentProvider 筑基篇》
• 《Android | ContentProvider 精通篇》

---

目录

---

前置知识

这篇文章的内容会涉及以下前置 / 相关知识，贴心的我都帮你准备好了，请享用~

• Binder 机制： 【点赞催更】

---

1. ContentResolver#query(...) 源码分析

在上篇文章介绍 ContentResolver 时提到，外界（包括当前进程的其他组件）也无法直接访问 ContentProvider 的，而是需要通过ContentResolver来间接访问，主要分为 3 个步骤：

• 1、根据 Uri 来获取对应 ContentProvider 的 Binder 接口实现对象 IContentProvider；
• 2、通过 IContentProvider 来访问 / 操作 ContentProvider 中的数据源（跨进程）；
• 3、返回 Cursor

ContentResolver.java

已简化
public final Cursor query(...) {
    1、获取 IContentProvider 对象
    IContentProvider stableProvider = acquireProvider(uri);

    2、调用 ContentProvider#query(...) 查询
    Cursor qCursor = stableProvider.query(mPackageName, uri, projection, queryArgs, remoteCancellationSignal);
    
    3、返回 Cursor
    return qCursor ;
}

不仅仅是 query(...) 方法，通过 ContentResolver 的四个方法（insert、delete、update、query）都会先获取 IContentProvider 对象（步骤 1）。如果 ContentProvider 所在进程还未启动，还会触发该进程启动，相应的也会伴随着 ContentProvider 的启动。这一点我在 第 2 节 ConentProvider 的启动过程 会详细介绍 。

现在，我们先分析 ContentResolver#query(...) 的源码：

1.1 获取 IContentProvider 对象

源码中 ContentResolver#acquireProvider() 是抽象方法，具体实现在子类 ApplicationContentResolver 中，源码位于 ContextImpl 内部：

ContextImpl.java

内部类 ApplicationContentResolver：

-> 1、获取 IContentProvider 对象
@Override
protected IContentProvider acquireProvider(Context context, String auth) {
    转发给 ActivityThread
    return mMainThread.acquireProvider(context, ContentProvider.getAuthorityWithoutUserId(auth),
        resolveUserIdFromAuthority(auth), true);
}

ActivityThread.java

public final IContentProvider acquireProvider (Context c, String auth, int userId, boolean stable) {

    1.1 在 ActivityThread 中查找目标 IContentProvider 对象
    final IContentProvider provider = acquireExistingProvider(c, auth, userId, stable);
    if (provider != null) {
        return provider;
    }

    1.2 进程间调用 AMS 启动目标 ContentProvider（实际上是启动对应的进程）
    ContentProviderHolder holder = null;
    synchronized (getGetProviderLock(auth, userId)) {
        holder = ActivityManager.getService().getContentProvider(
            getApplicationThread(), auth, userId, stable);
        }

    1.3 记录 IContentProvider 对象，并修改引用计数
    holder = installProvider(c, holder, holder.info,
        true /*noisy*/, holder.noReleaseNeeded, stable);
    return holder.provider;
}

ActivityThread.java

-> 1.1 在 ActivityThread 中查找目标 IContentProvider 对象（已简化）
public final IContentProvider acquireExistingProvider(Context c, String auth, int userId, boolean stable) {
    synchronized (mProviderMap) {

        1.1.1 查找目标 IContentProvider 对象
        final ProviderKey key = new ProviderKey(auth, userId);
        final ProviderClientRecord pr = mProviderMap.get(key);
        if (pr == null) {
            return null;
        }

        1.1.2 增加引用计数
        IContentProvider provider = pr.mProvider;
        IBinder jBinder = provider.asBinder();
        ProviderRefCount prc = mProviderRefCountMap.get(jBinder);
        incProviderRefLocked(prc, stable);
        return provider;
    }
}

由以上源码可知，获取 IContentProvider 对象的过程主要分为以下步骤：

• 1.1 首先会在mProviderMap中查找目标 IContentProvider 对象，存在则直接返回，同时还修改引用计数 + 1。mProviderMap 和 mProviderRefCountMap 的数据结构如下：

final ArrayMap<ProviderKey, ProviderClientRecord> mProviderMap = new ArrayMap<ProviderKey, ProviderClientRecord>();
final ArrayMap<IBinder, ProviderRefCount> mProviderRefCountMap = new ArrayMap<IBinder, ProviderRefCount>();
final ArrayMap<IBinder, ProviderClientRecord> mLocalProviders = new ArrayMap<IBinder, ProviderClientRecord>();

• 1.2 否则，通过进程间调用 AMS 启动目标 ContentProvider（实际上是启动对应的进程）；

• 1.3 接着调用 installProvider() 方法记录 IContentProvider 对象，并修改引用计数。

3.2 调用 IContentProvider#query(...) 查询

todo

---

2. ContentProvider 的启动过程

众所周知，ActivityThread#main() 是应用进程的入口方法，在 main 方法中会启动主线程的消息循环，然后在 ActivityThread#attach() 中会远程调用 AMS#attachApplication()，以将 ApplicationThread 对象提供给 AMS。

ApplicationThread 是 IApplicationThread 接口的 Binder 对象，主要用于 ActivityThread 和 AMS 之间的进程间通讯。在 AMS#attachApplication() 中会跨进程调用 ApplicationThread#bindApplication()，其中通过 ActivityThread 中的 Handler mH 分发到 handlerBindApplication()。

整个过程的关键节点浓缩为下图：

ActivityThread.java

private void handleBindApplication(AppBindData data) {
    // ...
    1、实例化 Application 对象
    Application app;
    app = data.info.makeApplication(data.restrictedBackupMode, null);
    mInitialApplication = app;

    2、初始化所有 ContentProvider
    installContentProviders(app, data.providers);

    3、调用 Application#onCreate()
    mInstrumentation.callApplicationOnCreate(app);
    ...
}

-> 1、实例化 Application 对象
public Application makeApplication(boolean forceDefaultAppClass,
            Instrumentation instrumentation) {
    ...
    1.1 Context 基础对象
    ContextImpl appContext = ContextImpl.createAppContext(mActivityThread, this);

    1.2 实例化，内部会调用 Context#attachBaseContext(...)
    app = mActivityThread.mInstrumentation.newApplication(cl, appClass, appContext);

    1.3 Context 基础对象持有代理类
    appContext.setOuterContext(app);
    ...
}

-> 2、初始化所有 ContentProvider
private void installContentProviders(Context context, List<ProviderInfo> providers) {
    final ArrayList<ContentProviderHolder> results = new ArrayList<>();

    for (ProviderInfo cpi : providers) {
        依次初始化 ContentProvider
        ContentProviderHolder cph = installProvider(context, null, cpi,
                false /*noisy*/, true /*noReleaseNeeded*/, true /*stable*/);
        if (cph != null) {
            cph.noReleaseNeeded = true;
            results.add(cph);
        }
    }
    // ...
}

关键结论：

• 1、当 ContentProvider 所在进程启动时，ContentProvider 也会启动并自动发布到 AMS 中。 启动 ContentPrivider 的方法就是上面源码中的 installContentProviders()；

• 2、installContentProviders() 会初始化属于当前进程的 ContentProvider；

• 3、ContentProvider#onCreate() 是早于 Application#onCreate() 执行的，这在四大组件里是比较少见的情况。

Context#attachBaseContext() -> ContentProvider#onCreate() -> Application#onCreate()

---

创作不易，你的「三连」是丑丑最大的动力，我们下次见！