距离上一次写博客已经半年多了，这半年发生了很多事情，也有了很多感触，最主要是改变了忙碌了工作，更加重视身体的健康，为此也把工作地点从深圳这个一线城市换到了珠海，工作相对没有那么累，身体感觉也好了很多。所以在工作完成之余，也有了更多的时间来自我学习和提高，后续会用更多时间来写更多实用的东西，帮助我们理解安卓系统的原理，帮助我们快速、稳定的开发。
这一篇我们接着之前的计划，完成四大组件的最后一个ContentProvider的分析。ContentProvider是一个抽象类，用来提供访问数据的统一格式的接口。ContentProvider的作用是多应用间共享数据，如果用户需要直接使用则可以直接在里面使用数据库来保存数据，也可以通用ContentResolver使用URI来存储数据，使用URI用户不需要知道内部怎么存储只需要知道如何使用该存储方式。
ContentProvider
ContentProvider的描述及使用：
在之前我们分析过ContentProvider的启动比Application的启动早，所以使用时需要知道这种情况。在使用ContentResolver时是通过URI来访问的，URI的结构：content://cn.codemx.myprovider/item/123，我们划分一下：
[ 1 ][ 2 ][ 3 ][ 4 ] [content://][cn.codemx.myprovider.settings][/item][/123]
第一个组件：是一个协议名称，它的值固定为：“content://”，是Content Provider组件的专用访问协议
第二个组件：是一个Content Provider组件的android:authority属性值。这个组件类似于URL中的域名，因此我们要保证它是全局唯一的，一般使用它所描述的ContentProvider组件的包名来命名。
第三个组件：是一个资源相对路径，用来描述要访问的资源类型。如果一个ContentProvider只有一种资源，那么忽略这个组件，否则通过它来指定要访问的资源的类型。
第四个组件：是一个资源ID，用来描述具体的资源。
举个例子：
<provider android:name="com.android.launcher3.LauncherProvider" android:authorities="cn.codemx.myprovider.settings" android:exported="true" android:readPermission="cn.codemx.myprovider.permission.READ_SETTINGS" android:writePermission="cn.codemx.myprovider.permission.WRITE_SETTINGS"/>
我有个LauncherProvider继承ContentProvider，在AndroidManifest.xml中要像上面一样声明，其中authorities是位置认证，在使用时是这样使用的：
public static final String TABLE_NAME = "favorites";/**
* The content:// style URL for this table
*/public static final Uri CONTENT_URI = Uri.parse("content://" +
ProviderConfig.AUTHORITY + "/" + TABLE_NAME);其中ProviderConfig.AUTHORITY为：
public class ProviderConfig { public static final String AUTHORITY = "cn.codemx.myprovider.settings".intern();
}这个就是上面AndroidManifest.xml中声明的那个authorities属性值。上面获取了Uri就可以通过Uri来获取或者保存数据了。
ContentProvider启动过程：
Activity通过MyContentProvider.CONTENT_URI来访问MyContentProvider组件，以便可以获得它的内容
Activity组件所运行在的应用程序进程发现它里面不存在一个用来访问MyContentProvider组件的代理对象，于是通过MyContentProvider.CONTENT_URI来请求AMS返回一个用来访问MyContentProvider组件的代理对象
AMS发现MyContentProvider还没有起来，于是先创建一个新的应用进程，然后在这个新创建的应用进程中启动MyContentProvider组件
MyContentProvider组件启动之后，就会将自己发布到AMS中，以便AMS可以将它的一个代理对象返回Activity组件。
ContentProvider方法：
onCreate() // 执行初始化工作；insert(Uri, ContentValues) // 插入新数据；delete(Uri, String, String[]) // 删除已有数据；update(Uri, ContentValues, String, String[]) // 更新数据；query(Uri, String[], String, String[], String) // 查询数据；getType(Uri) // 获取数据MIME类型。
ContentProvider不像Activity一样有生命周期，只有一个onCreate方法用来创建。然后就是提供了增、删、改、查用来操作数据的接口，通过Uri来管理数据。
ContentResolver的获取:
上面我们提到ContentProvider主要是提供接口，并没有具体实现，如果需要具体实现，一种是通过操作数据库，一种是通过URI操作ContentResolver，数据库的这里不再介绍，只介绍一下ContentResolver。
通常我们获取ContentResolver的代码如下：
ContentResolver cr = context.getContentResolver(); //获取ContentResolver
前面Android系统源码分析--Context章节我们分析过Context的子类及继承关系，知道，Context的所有实现都是在ContextImp中，所以context.getContentResolver()方法的实现也是一样。
ContextImpl.getContentResolver():
@Override
public ContentResolver getContentResolver() { return mContentResolver;
}mContentResolver是定义在ContextImpl中类型为ApplicationContentResolver的变量：
private final ApplicationContentResolver mContentResolver;
这里我们可以知道我们获取到的ContentResolver实际上是ApplicationContentResolver，所以具体操作应该都是在ApplicationContentResolver中实现的。我们先看看这个mContentResolver是在哪里初始化的。
private ContextImpl(ContextImpl container, ActivityThread mainThread,
LoadedApk packageInfo, IBinder activityToken, UserHandle user, int flags,
Display display, Configuration overrideConfiguration, int createDisplayWithId) {
...
mContentResolver = new ApplicationContentResolver(this, mainThread, user);
}上面代码可以知道这个是在ContextImpl构造函数中初始化的。而ContentResolver中的所有操作都在ApplicationContentResolver实现。
ContentResolver.query
先看时序图：
ContentProvider启动时序图
1.ContentResolver.query
public final @Nullable Cursor query(final @RequiresPermission.Read @NonNull Uri uri,
@Nullable String[] projection, @Nullable String selection,
@Nullable String[] selectionArgs, @Nullable String sortOrder,
@Nullable CancellationSignal cancellationSignal) {
Preconditions.checkNotNull(uri, "uri"); // 返回的是ContentProvider的中的mTransport（Transport）
IContentProvider unstableProvider = acquireUnstableProvider(uri); if (unstableProvider == null) { return null;
}
IContentProvider stableProvider = null;
Cursor qCursor = null; try {
... try {
qCursor = unstableProvider.query(mPackageName, uri, projection,
selection, selectionArgs, sortOrder, remoteCancellationSignal);
} catch (DeadObjectException e) { // The remote process has died... but we only hold an unstable
// reference though, so we might recover!!! Let's try!!!!
// This is exciting!!1!!1!!!!1
unstableProviderDied(unstableProvider); // 返回的是ContentProvider的中的mTransport（Transport）
stableProvider = acquireProvider(uri); if (stableProvider == null) { return null;
}
qCursor = stableProvider.query(mPackageName, uri, projection,
selection, selectionArgs, sortOrder, remoteCancellationSignal);
} if (qCursor == null) { return null;
}
... // Wrap the cursor object into CursorWrapperInner object.
final IContentProvider provider = (stableProvider != null) ? stableProvider
: acquireProvider(uri); final CursorWrapperInner wrapper = new CursorWrapperInner(qCursor, provider);
stableProvider = null;
qCursor = null; return wrapper;
} catch (RemoteException e) {
... return null;
} finally { // 释放资源
...
}
}首先是判断Uri是否是空，如果空抛出异常，如果不是获取unstableProvider，从名字看是不稳定的Provider，往下看还有个stableProvider（稳定的Provider），其实从代码看没有区别，只是第一次获取是不稳定的，出现异常就再次获取就是稳定的。所以我们只看一个即可。从注释可以知道unstableProvider其实是ContentProvider中的Transport对象mTransport，这个我们先提出来，后面通过代码看是不是对的。
2.ContentResolver.acquireUnstableProvider
public final IContentProvider acquireUnstableProvider(Uri uri) { // uri以"content"开头
if (!SCHEME_CONTENT.equals(uri.getScheme())) { return null;
} // 获取Manifest文件中的authorities属性（例如：cn.codemx.myprovider.settings）
String auth = uri.getAuthority(); if (auth != null) { // 具体实现ApplicationContentResolver中
return acquireUnstableProvider(mContext, uri.getAuthority());
} return null;
}这里主要是验证协议名是不是content，然后验证属性是不是存在，如果存在则开始获取实现IContentProvider接口的对象。
3.ApplicationContentResolver.acquireUnstableProvider
protected IContentProvider acquireUnstableProvider(Context c, String auth) { return mMainThread.acquireProvider(c,
ContentProvider.getAuthorityWithoutUserId(auth),
resolveUserIdFromAuthority(auth), false);
}这里调用的是ActivityThread.acquireProvider方法。
4.ActivityThread.acquireProvider
public final IContentProvider acquireProvider(
Context c, String auth, int userId, boolean stable) { // 返回的是ContentProvider的中的mTransport（Transport）
final IContentProvider provider = acquireExistingProvider(c, auth, userId, stable); if (provider != null) {// 如果不为空，说明访问过，如果是第一次访问，为空
return provider;
}
...
IActivityManager.ContentProviderHolder holder = null; try { // 核心部分
holder = ActivityManagerNative.getDefault().getContentProvider(
getApplicationThread(), auth, userId, stable);
} catch (RemoteException ex) { throw ex.rethrowFromSystemServer();
} if (holder == null) {
Slog.e(TAG, "Failed to find provider info for " + auth); return null;
} // Install provider will increment the reference count for us, and break
// any ties in the race.
holder = installProvider(c, holder, holder.info, true /*noisy*/, holder.noReleaseNeeded, stable); return holder.provider;
}先根据auth获取是否存在实现IContentProvider的类，如果存在直接返回，不存在则获取IActivityManager.ContentProviderHolder对象，然后获取实现IContentProvider接口的类。我们先看acquireExistingProvider方法。
5.ActivityThread.acquireExistingProvider
public final IContentProvider acquireExistingProvider(
Context c, String auth, int userId, boolean stable) { synchronized (mProviderMap) { final ProviderKey key = new ProviderKey(auth, userId); // mProviderMap保存当前应用程序进程访问过的ContentProvider组件代理对象
final ProviderClientRecord pr = mProviderMap.get(key); if (pr == null) {// 如果不存在说明还没有访问过
return null;
} // 返回的是ContentProvider的中的mTransport（Transport）
IContentProvider provider = pr.mProvider;
IBinder jBinder = provider.asBinder(); // 检查线程是否还存在
if (!jBinder.isBinderAlive()) {
... return null;
} // Only increment the ref count if we have one. If we don't then the
// provider is not reference counted and never needs to be released.
ProviderRefCount prc = mProviderRefCountMap.get(jBinder); if (prc != null) { // 增加引用计数
incProviderRefLocked(prc, stable);
} return provider;
}
}首先是去缓存中获取，是否存在封装了ContentProvider对象的ProviderClientRecord对象，如果不存在则说明第一次启动，还没添加到缓存中，如果存在，那么说明已经启动过，则会有需要的实现IContentProvider接口的对象。再看第4步中如果返回对象不为空则直接返回，如果是空则要先获取IActivityManager.ContentProviderHolder。
6.ActivityManagerProxy.getContentProvider
public ContentProviderHolder getContentProvider(IApplicationThread caller,
String name, int userId, boolean stable) throws RemoteException {
... // 通过Binder代理对象mRemote发送一个类型为GET_CONTENT_PROVIDER_TRANSACTION的进程间通信消息
mRemote.transact(GET_CONTENT_PROVIDER_TRANSACTION, data, reply, 0);
... return cph;
}这里我们在前面几章涉及到了很多次，就不再说了，主要是从这里调用AMS(ActivityManagerService)中的对应方法getContentProvider
7.AMS.getContentProvider
public final ContentProviderHolder getContentProvider(
IApplicationThread caller, String name, int userId, boolean stable) {
... return getContentProviderImpl(caller, name, null, stable, userId);
}这里比较简单，调用AMS.getContentProviderImpl方法。
8.AMS.getContentProviderImpl
private ContentProviderHolder getContentProviderImpl(IApplicationThread caller,
String name, IBinder token, boolean stable, int userId) {
ContentProviderRecord cpr;
ContentProviderConnection conn = null;
ProviderInfo cpi = null; synchronized (this) { // 描述进程信息的对象
ProcessRecord r = null; if (caller != null) {// 如果调用者的线程存在，根据caller获取对应的进程
r = getRecordForAppLocked(caller); // 如果找不到caller对应的进程抛出异常
...
}
... // 根据名称和userId获取ContentProviderRecord对象，用来检测是不是ContentProvider已经发布了
cpr = mProviderMap.getProviderByName(name, userId); // If that didn't work, check if it exists for user 0 and then
// verify that it's a singleton provider before using it.
if (cpr == null && userId != UserHandle.USER_SYSTEM) {// 如果不存在并且不是系统的userId
// 检测mProviderMap中是否存在系统的ContentProviderRecord对象，如果已经启动则存在
cpr = mProviderMap.getProviderByName(name, UserHandle.USER_SYSTEM); if (cpr != null) {
cpi = cpr.info; if (isSingleton(cpi.processName, cpi.applicationInfo,
cpi.name, cpi.flags)
&& isValidSingletonCall(r.uid, cpi.applicationInfo.uid)) {
...
} else {
cpr = null;
cpi = null;
}
}
} // 检查ContentProvider是否正在运行（第一次还没有运行）
boolean providerRunning = cpr != null && cpr.proc != null && !cpr.proc.killed; if (providerRunning) {// ContentProvider已经运行
... if (r != null && cpr.canRunHere(r)) {// 进程存在
ContentProviderHolder holder = cpr.newHolder(null);
holder.provider = null; return holder;
}
... // provider实例已经存在，因此我们直接返回
conn = incProviderCountLocked(r, cpr, token, stable); // 如何stable和unstable的总引用计数为1，那么更新LruProcess列表
if (conn != null && (conn.stableCount + conn.unstableCount) == 1) { if (cpr.proc != null && r.setAdj <= ProcessList.PERCEPTIBLE_APP_ADJ) {
...
updateLruProcessLocked(cpr.proc, false, null);
}
} final int verifiedAdj = cpr.proc.verifiedAdj; // 更新provider进程的adj
boolean success = updateOomAdjLocked(cpr.proc);
... if (!success) {// 如果更新不成功，那么减少引用计数并杀死provider进程
...
ppDiedLocked(cpr.proc);// 杀死进程
... // 已经杀死了，所以要恢复初始状态
providerRunning = false;
conn = null;
} else {// 更新成功了
cpr.proc.verifiedAdj = cpr.proc.setAdj;
}
...
} if (!providerRunning) {// 还没有运行，第一次启动
try { // 根据ContentProvider的AUTHORITY来获取对应的配置信息（ProviderInfo）
cpi = AppGlobals.getPackageManager().
resolveContentProvider(name,
STOCK_PM_FLAGS | PackageManager.GET_URI_PERMISSION_PATTERNS, userId);
} catch (RemoteException ex) {
} // 没有找到对应的ProviderInfo，因此返回空
if (cpi == null) { return null;
} // Provider是否为单例
boolean singleton = isSingleton(cpi.processName, cpi.applicationInfo,
cpi.name, cpi.flags)
&& isValidSingletonCall(r.uid, cpi.applicationInfo.uid);
... // 通过ComponentName获取providerMap中的cpr
ComponentName comp = new ComponentName(cpi.packageName, cpi.name); // 先去缓存中找
cpr = mProviderMap.getProviderByClass(comp, userId); // 是否是第一次启动
final boolean firstClass = cpr == null; if (firstClass) {// 第一次启动
final long ident = Binder.clearCallingIdentity(); try { // 获取应用信息
ApplicationInfo ai =
AppGlobals.getPackageManager().
getApplicationInfo(
cpi.applicationInfo.packageName,
STOCK_PM_FLAGS, userId);
... // 创建一个cpr(ContentProviderRecord)
cpr = new ContentProviderRecord(this, cpi, ai, comp, singleton);
} catch (RemoteException ex) {
...
} finally {
...
}
}
... if (r != null && cpr.canRunHere(r)) {// 进程存在且正在运行
return cpr.newHolder(null);
}
... final int N = mLaunchingProviders.size(); int i; for (i = 0; i < N; i++) { if (mLaunchingProviders.get(i) == cpr) { break;
}
} // ContentProvider还没有被启动
if (i >= N) { final long origId = Binder.clearCallingIdentity(); try {
... // 获取运行ContentProvider的进程
ProcessRecord proc = getProcessRecordLocked(
cpi.processName, cpr.appInfo.uid, false); // 如果进程已经存在并且没有被杀死
if (proc != null && proc.thread != null && !proc.killed) { if (!proc.pubProviders.containsKey(cpi.name)) { // 将描述ContentProvider的对象（ContentProviderRecord）以包名为键放到进程进行缓存
proc.pubProviders.put(cpi.name, cpr); try { // 安装ContentProvider
proc.thread.scheduleInstallProvider(cpi);
} catch (RemoteException e) {
}
}
} else {// 进程不存在
// 启动进程
proc = startProcessLocked(cpi.processName,
cpr.appInfo, false, 0, "content provider", new ComponentName(cpi.applicationInfo.packageName,
cpi.name), false, false, false); if (proc == null) {// 进程启动失败
return null;
}
}
cpr.launchingApp = proc;
mLaunchingProviders.add(cpr);
} finally {
...
}
} if (firstClass) {// 第一次启动要保存ContentProvider
mProviderMap.putProviderByClass(comp, cpr);
} // 保存
mProviderMap.putProviderByName(name, cpr);
conn = incProviderCountLocked(r, cpr, token, stable); if (conn != null) {
conn.waiting = true;
}
}
}
... return cpr != null ? cpr.newHolder(conn) : null;
}这里代码比较多，但是思路比较清晰，首先是找对应的进程是否存在，因为我们正在启动ContentProvider，所以正常进程时存在的，然后根据进程找描述ContentProvider的描述对象ContentProviderRecord，如果第一次启动，这个描述对象是不存在的，如果不是第一次那么则存在该对象，其中providerRunning参数用来判断ContentProvider是否已经运行的，如果运行了直接返回，如果没有运行则创建ContentProvider的描述对象ContentProviderRecord，然后判断进程是否存在，存在则调用ApplicationThread.scheduleInstallProvider方法安装ContentProvider，不存在则直接启动进程。安装完成后缓存这些创建的ContentProvider相关的对象，方便下次使用直接从缓存获取。
9.ApplicationThread.scheduleInstallProvider
public void scheduleInstallProvider(ProviderInfo provider) {
sendMessage(H.INSTALL_PROVIDER, provider);
}这里是发送消息到ApplicationThread中的H（继承Handler）中，然后调用ActivityThread.handleInstallProvider
10.ActivityThread.handleInstallProvider
public void handleInstallProvider(ProviderInfo info) { final StrictMode.ThreadPolicy oldPolicy = StrictMode.allowThreadDiskWrites(); try {
installContentProviders(mInitialApplication, Lists.newArrayList(info));
} finally {
StrictMode.setThreadPolicy(oldPolicy);
}
}调用installContentProviders方法。
11.ActivityThread.installContentProviders
private void installContentProviders(
Context context, List<ProviderInfo> providers) { final ArrayList<IActivityManager.ContentProviderHolder> results = new ArrayList<IActivityManager.ContentProviderHolder>(); for (ProviderInfo cpi : providers) {
... // 加载ContentProvider，然后调用ContentProvider的onCreate方法
IActivityManager.ContentProviderHolder cph = installProvider(context, null, cpi, false /*noisy*/, true /*noReleaseNeeded*/, true /*stable*/); if (cph != null) {
cph.noReleaseNeeded = true;
results.add(cph);
}
} try {
ActivityManagerNative.getDefault().publishContentProviders(
getApplicationThread(), results);
} catch (RemoteException ex) { throw ex.rethrowFromSystemServer();
}
}这里有两步，第一步：安装ContentProvider，然后调用ContentProvider.onCreate方法，第二步：调用AMP.publishContentProviders发布ContentProvider。我们先看第一步。
12.ActivityThread.installProvider
private IActivityManager.ContentProviderHolder installProvider(Context context,
IActivityManager.ContentProviderHolder holder, ProviderInfo info, boolean noisy, boolean noReleaseNeeded, boolean stable) {
ContentProvider localProvider = null;
IContentProvider provider; if (holder == null || holder.provider == null) {
... try { final java.lang.ClassLoader cl = c.getClassLoader(); // 根据名字通过类加载方式加载ContentProvider
localProvider = (ContentProvider) cl.
loadClass(info.name).newInstance(); // 获取provider，也就是ContentProvider中的mTransport（Transport），这个provider赋值给了retHolder，所以前面在获取的时候就是这个provider（Transport）
provider = localProvider.getIContentProvider();
... // 添加ProviderInfo，然后调用ContentProvider的onCreate方法
localProvider.attachInfo(c, info);
} catch (java.lang.Exception e) {
... return null;
}
} else {// localProvider == null
provider = holder.provider;
...
}
IActivityManager.ContentProviderHolder retHolder; // 创建IActivityManager.ContentProviderHolder并且缓存ContentProvider相关信息
... return retHolder;
}这里通过反射获取ContentProvider，然后调用ContentProvider的onCreate方法。创建完成后会缓存到IActivityManager.ContentProviderHolder中，并且返回IActivityManager.ContentProviderHolder对象。在11步中我们提到两步，一个就是安装，一个是发布，下面我看发布的代码。
13.AMP.publishContentProviders
public void publishContentProviders(IApplicationThread caller,
List<ContentProviderHolder> providers) throws RemoteException {
...
mRemote.transact(PUBLISH_CONTENT_PROVIDERS_TRANSACTION, data, reply, 0);
...
}通过这里调用AMS.publishContentProviders方法。
14.AMS.publishContentProviders
public final void publishContentProviders(IApplicationThread caller,
List<ContentProviderHolder> providers) { if (providers == null) { return;
} synchronized (this) { // 获取进程描述对象
final ProcessRecord r = getRecordForAppLocked(caller);
... final long origId = Binder.clearCallingIdentity(); final int N = providers.size(); for (int i = 0; i < N; i++) {
ContentProviderHolder src = providers.get(i); if (src == null || src.info == null || src.provider == null) { continue;
} // 获取每个ContentProvider的描述对象ContentProviderRecord放到mProviderMap中
ContentProviderRecord dst = r.pubProviders.get(src.info.name); if (dst != null) {
ComponentName comp = new ComponentName(dst.info.packageName, dst.info.name);
mProviderMap.putProviderByClass(comp, dst);
String names[] = dst.info.authority.split(";"); for (int j = 0; j < names.length; j++) { // 缓存
mProviderMap.putProviderByName(names[j], dst);
}
int launchingCount = mLaunchingProviders.size();
... synchronized (dst) {
dst.provider = src.provider;
dst.proc = r; // 通知AMS provider已经"发布"成功
dst.notifyAll();
}
...
}
}
...
}
}这里主要是从ContentProvider列表中获取对应的描述对象进行缓存，然后通知AMS中的ContentProvider发布完成。
15.ActivityThread.installProvider
这个方法我们上面12中分析了。只是一个是第一次启动，一个已经存在缓存了。
16.Transport.query
结合第1步和第12步我们知道IContentProvider unstableProvider返回的是ContentProvider中的mTransport，因此这里调用的是Transport.query方法
public Cursor query(String callingPkg, Uri uri, String[] projection,
String selection, String[] selectionArgs, String sortOrder,
ICancellationSignal cancellationSignal) {
... if (enforceReadPermission(callingPkg, uri, null) != AppOpsManager.MODE_ALLOWED) {
... // 回调目标ContentProvider所定义的query方法
Cursor cursor = ContentProvider.this.query(uri, projection, selection,
selectionArgs, sortOrder, CancellationSignal.fromTransport(
cancellationSignal)); if (cursor == null) { return null;
} // Return an empty cursor for all columns.
return new MatrixCursor(cursor.getColumnNames(), 0);
} final String original = setCallingPackage(callingPkg); try { return ContentProvider.this.query(
uri, projection, selection, selectionArgs, sortOrder,
CancellationSignal.fromTransport(cancellationSignal));
} finally {
...
}
}最终调用了ContentProvider.this.query方法。到此我们对于ContentProvider.this.query方法分析完成了。其实还有其他方法（insert,delete,update）逻辑也是差不多的，分析完一个其他也就很好分析。
到此Android系统四大组件都分析完了，可能感觉还是不够详细，其实还是要自己多看，多看几遍源码就熟悉了。后面开始分析View的绘制流程，因为这个相对来说非常复杂，如果一篇写完会写很长，看的话也很累，所以后面改用分章节去写，没章尽量分离开，尽量简短清晰，一看就能明白。
作者：翰墨飘香
链接：https://www.jianshu.com/p/dfd079ac62ac
共同学习，写下你的评论
评论加载中...
作者其他优质文章
