Android内容提供者（ContentProvider）浅析（一）

ContentProvider是Android系统四大基本组件中涉及到数据共享的重要角色。本文将对它的一些知识做一些简介来引导大家更好的了解这个组件。

下面将从三个方面分析：1、ContentProvider的加载；2、ContentProvider的调用；3、内容监听机制

1、来看看ContentProvider的加载过程，这个组件必须要在manifest文件中注册，这是有原因的，因为应用程序在安装过程中，这个组件的信息就应该被记录下来，以便在应用进程启动时就能直接根据组件信息来创建实例。

这个过程又跟系统的四大关键东西的功能，ActivityManagerService，PackageManagerService，ActivityThread和ApplicationThread。它们的关系相信大家都有一定的了解，这里就不阐述了。

下面从一个应用进程被创建说起。

在ActivityManagerService中，做一些诸如启动界面啊，广播啊，启动服务啊等等需要开始一个新的进程时就会执行到其中的startProcessLocked方法。有一行关键代码

</pre><pre name="code" class="html">Process.ProcessStartResult startResult = Process.start("android.app.ActivityThread",
app.processName, uid, uid, gids, debugFlags, mountExternal,
app.info.targetSdkVersion, null, null);

意思就是说启动一个新进程，并且这个进程的入口是ActivityThread，那么其实对于应用程序来说ActivityThread.main才是它的入口，而并不是我们常说的组件之类的。

继续看main方法：

public static void main(String[] args) {
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
AsyncTask.init();
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}

这里面建立了主线程的handler和looper当然还有消息队列了，建立起了消息循环机制，所有的主线程操作全部都是在这里进行的。继续看attach操作

private void attach(boolean system) {
if (!system) {
IActivityManager mgr = ActivityManagerNative.getDefault();
try {
mgr.attachApplication(mAppThread);
} catch (RemoteException ex) {
// Ignore
}
}
}

又到ActivityManagerService里面去了，接下来就是一系列的方法调用了，还是长话短说吧，几经波折之后到了ApplicationThread的以下方法中

public final void bindApplication(String processName,
ApplicationInfo appInfo, List<ProviderInfo> providers,
ComponentName instrumentationName, String profileFile,
ParcelFileDescriptor profileFd, boolean autoStopProfiler,
Bundle instrumentationArgs, IInstrumentationWatcher instrumentationWatcher,
int debugMode, boolean enableOpenGlTrace, boolean isRestrictedBackupMode,
boolean persistent, Configuration config, CompatibilityInfo compatInfo,
Map<String, IBinder> services, Bundle coreSettings) {
AppBindData data = new AppBindData();
data.processName = processName;
data.appInfo = appInfo;
data.providers = providers;
......
//将app的provider信息传到ActivityThread的H中处理
queueOrSendMessage(H.BIND_APPLICATION, data);
}
private class H extends Handler {
public void handleMessage(Message msg) {
switch (msg.what) {
case BIND_APPLICATION:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "bindApplication");
AppBindData data = (AppBindData)msg.obj;
handleBindApplication(data);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
}
}
private void handleBindApplication(AppBindData data) {
//前面一堆
// don't bring up providers in restricted mode; they may depend on the
// app's custom Application class
if (!data.restrictedBackupMode) {
List<ProviderInfo> providers = data.providers;
if (providers != null) {
installContentProviders(app, providers);
// For process that contains content providers, we want to
// ensure that the JIT is enabled "at some point".
mH.sendEmptyMessageDelayed(H.ENABLE_JIT, 10*1000);
}
}
//后面还有Application的OnCreate等操作。
}

关于ContentProvider的重点来了，installContentProviders(app, providers);顾名思义这个里面就把Provider安装到系统中了，这其中包括了创建和注册两步，创建是一个在本进程内创建provider实例并保存，注册其实就是将这个provider在activitymanagerservice保存的过程。来看看具体的代码实现

private void installContentProviders(
Context context, List<ProviderInfo> providers) {
final ArrayList<IActivityManager.ContentProviderHolder> results =
new ArrayList<IActivityManager.ContentProviderHolder>();
for (ProviderInfo cpi : providers) {
//创建provider实例
IActivityManager.ContentProviderHolder cph = installProvider(context, null, cpi,
false /*noisy*/, true /*noReleaseNeeded*/, true /*stable*/);
if (cph != null) {
cph.noReleaseNeeded = true;
results.add(cph);
}
}
try {
//将此记录保存到ActivityManagerService中
ActivityManagerNative.getDefault().publishContentProviders(
getApplicationThread(), results);
} catch (RemoteException ex) {
}
}
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();
//这里就new出了一个ContentProvider的实例
localProvider = (ContentProvider)cl.
loadClass(info.name).newInstance();
provider = localProvider.getIContentProvider();
if (provider == null) {
return null;
}                // XXX Need to create the correct context for this provider.
localProvider.attachInfo(c, info);
}
} else {
            provider = holder.provider;
            if (DEBUG_PROVIDER) Slog.v(TAG, "Installing external provider " + info.authority + ": "
                    + info.name);
          }

......
synchronized (mProviderMap) {
IBinder jBinder = provider.asBinder();
if (localProvider != null) {
ComponentName cname = new ComponentName(info.packageName, info.name);
ProviderClientRecord pr = mLocalProvidersByName.get(cname);
if (pr != null) {
provider = pr.mProvider;
} else {
holder = new IActivityManager.ContentProviderHolder(info);
holder.provider = provider;
holder.noReleaseNeeded = true;
pr = installProviderAuthoritiesLocked(provider, localProvider, holder);
//上面这个方法中将provider的信息保存在了mProviderMap中。
mLocalProviders.put(jBinder, pr);
mLocalProvidersByName.put(cname, pr);
}
retHolder = pr.mHolder;
}
}
}
}
private ProviderClientRecord installProviderAuthoritiesLocked(IContentProvider provider,
ContentProvider localProvider, IActivityManager.ContentProviderHolder holder) {
final String auths[] = PATTERN_SEMICOLON.split(holder.info.authority);
final int userId = UserHandle.getUserId(holder.info.applicationInfo.uid);
final ProviderClientRecord pcr = new ProviderClientRecord(
auths, provider, localProvider, holder);
for (String auth : auths) {
final ProviderKey key = new ProviderKey(auth, userId);
final ProviderClientRecord existing = mProviderMap.get(key);
if (existing != null) {
} else {
mProviderMap.put(key, pcr);
}
}
return pcr;
}

看到上面这里，可能大家都会有疑问，为什么这里有三个map来保存provider信息呢？这三个有什么区别什么时候使用这个目前还看不出来，后面的分析可能会看到一些端倪。我们下文将继续分析。