一、自己的理解
对于content provide的启动我是这样认为的，要用ContentResolver去获得一个contentProvider，在这的获得的过程中，
1、如果本应用之前有contentProvider的引用，则直接返回。
2、如果没用，则向AMS（ActivityManagerService）去申请，然后AMS返回一个ContentProvideHolder对象，这时又分两种情况：
2.1如果此contentprovider需要在本应用进程中创建，则返回一个Holder对象，然后在本进程中创建一个contentprovider，并保存一系列引用。
2.2 如果此contentprovider在其他进程中，这时又要分情况：
2.2.1如果此contentprovider已经存在，并且可以在运行在本应用进程中，则直接返回；如果不可以，则需要设置一个ContentProviderConnection对象 conn，然后将contentProvider添加到conn中，即为contentProvider添加了一个异地引用。
2.2.2如果此contentProvider不存在，则需要去创建一个，如果这个contentProvider所在的进程已经被创建，则直接在此进程中加载，如果没有被创建，则先启动这个应用进程，然后加载。在这个加载过程中会有一个while循环，直到contentprovider被加载完毕。
最后，会返回一个带有contentProvider的Holder对象。
ps:其实返回的ContentProvider对象并不真正是一个ContentProvider对象，因为这是两个进程之间的通信，他们不能直接获得彼此进程中的一些引用，而客户进程得到的ContentProvider对象引用，本质上是一个Binder对象。因为Android中只有BInder才能在两个进程之间通信。在这里，客户端得到的其实是Transport对象，通过它来操作服务端的ContentProvider
二、源码浅析
在分析源码前，先说明几个变量：
1、AMS的mProviderMap，它保存了整个系统中所有的ContentProviderRecord对象，而这个记录里面包含了contentProvider，mProviderMap有两种获得ContentProviderRecord的方法，一是通过类名获得，另一个是通过contentProvider的授权URI获得。
2、ProcessRecord的pubProviders和conProviders，他们是被存放在每个应用各自的进程中，以键值对的方式记录着ContentProviderRecord，pubProviders保存着进程中所有创建的ContentProvider，conProviders保存着进程中所有使用的ContentProvider。
3、ContentProviderHolder中保存了ContentProvider的相关信息，它含有ProviderInfo（包含了contentProvider的授权URI，读写权限等信息），ContentProvider的引用，IBInder(这其实是一个服务端的ContentProviderConnection对象，其继承了BInder，用来作为客户端与服务端的链接)
下面我们来看一下源码中使怎么写的：
1、ContentResolver的query
在query()中，会首先获得contentProvider对象，然后用此对象去进行查询。要获得contentProvider对象会调用acquireUnstableProvider(uri)或acquireProvider(uri)。其实这两个方法的最终调用都是一样的，现在，我们选择acquireUnstableProvider(uri)来分析。
2、ContentResolver的acquireUnstableProvider()
要分析此方法，首先要知道resolver对象是如何获得的。resolver对象是通过context对象的getContentResolver()获得的。其实是ContextImpl实现了Context，然后由ContextWrapper对其进行了修饰，即有ContextImpl对象的一个引用——mBase，然后Service，Activity又继承了ContextWrapper ，由此就可以使用上下文的资源。在ContextImpl中，有一个ApplicationContentResolver类继承了ContentResolver，并在ContextImplement初始化时，对其进行实例化，保存为mContentResolver引用。在getContentResolver()中会使用mBase的getContentResolver()，得到的就是这个mContentResolver，然后会在它的acquireUnstableProvider()去调用mMainThread(ActivityThread)的acquireProvider().
3、ActivityThread的acquireProvider()方法
public final IContentProvider acquireProvider( Context c, String auth, int userId, boolean stable) { //查看是否有已经存在的ContentProvider，若存在，则将其返回 final IContentProvider provider = acquireExistingProvider(c, auth, userId, stable); if (provider != null) { return provider; }
// There is a possible race here. Another thread may try to acquire // the same provider at the same time. When this happens, we want to ensure // that the first one wins. // Note that we cannot hold the lock while acquiring and installing the // provider since it might take a long time to run and it could also potentially // be re-entrant in the case where the provider is in the same process. IActivityManager.ContentProviderHolder holder = null; try { //向AMS请求一个含有ContentProvider的Holder 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. //如注释所说，对ContentProvider添加引用 holder = installProvider(c, holder, holder.info, true /*noisy*/, holder.noReleaseNeeded, stable); return holder.provider; }
关于此方法的作用，已在注释中写明，从这个方法中我们的值ContentProvider主要是从两个方面去获取的，一，从本地存在的COntentProvider集合中获取，即第4步；二，向AMS索取，即5,6,7步
4、ActivityThread的acquireExistingProvider()
public final IContentProvider acquireExistingProvider( Context c, String auth, int userId, boolean stable) { synchronized (mProviderMap) { final ProviderKey key = new ProviderKey(auth, userId); //查看本应用中是否存有要求的ContentProvider，没有则返回null final ProviderClientRecord pr = mProviderMap.get(key); if (pr == null) { return null; } //查看provider是否可用，不可用返回null IContentProvider provider = pr.mProvider; IBinder jBinder = provider.asBinder(); if (!jBinder.isBinderAlive()) { // The hosting process of the provider has died; we can't // use this one. Log.i(TAG, "Acquiring provider " + auth + " for user " + userId + ": existing object's process dead"); handleUnstableProviderDiedLocked(jBinder, true); return null; } //至此，说明provider是可用的，然后对contentProvider的引用数量进行改变 // 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; } }
关于incProviderRefLocked()，当请求一个新的ContentProvider时会调用此方法，它会将ContentProvider的引用计数加1，即将ContentProviderConnection对象进行更新，告诉它有某个应用需要使用新的ContentProvider，令其更新他的计数器。
5、AMS的getContentProvider()
调用此方法说明，在本应用没有已经存在的ContentProvider，需要向AMS申请一个。在此方法中会进行参数检查，最终去调用getContentProviderImpl()
5.1、AMS的getContentProviderImpl()
这个方法较长我们将它分为几个部分：
5.1.1若ContentProvider已经存在，则返回引用
5.1.2若其不存在，但是提供它的进程存在，则令此进程加载ContentProvider，然后返回新加载的对象
5.1.3若其不存，且提供它的进程也不存在，则开启此进程，并加载ContentProvider ，而后返回新加载的对象
好的下面来分析5.1.1：
先声明一些变量来保存数据
ContentProviderRecord cpr; ContentProviderConnection conn = null; ProviderInfo cpi = null;
接下来是一个同步代码块，再此代码块中获得ContentProvider，并防止多个进程进行争抢，导致出错
ProcessRecord r = null; if (caller != null) { r = getRecordForAppLocked(caller); if (r == null) { throw new SecurityException( "Unable to find app for caller " + caller + " (pid=" + Binder.getCallingPid() + ") when getting content provider " + name); } }
获得客户端的进程，用来判断获得ContentProvider后，能否直接在客户端进程运行。
// First check if this content provider has been published... 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) { 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)) { userId = UserHandle.USER_SYSTEM; checkCrossUser = false; } else { cpr = null; cpi = null; } } }
在此代码块中，首先查看，授权URI对应的进程中是否有ContentProvider，若没有，则去系统进程中查找，找到则证明此ContentProvider是单实例的，即系统中只有一个。
boolean providerRunning = cpr != null && cpr.proc != null && !cpr.proc.killed;
这一句是判断是否有存在且存活的ContentProvider，若有则为true,否则为false
if (providerRunning) { cpi = cpr.info; ...... //查看是否可以在请求contentProvider的进程中运行，如果可以或者此contentProvider就是请求，提供的 //则直接返回 if (r != null && cpr.canRunHere(r)) { ContentProviderHolder holder = cpr.newHolder(null); holder.provider = null; return holder; } ...... // In this case the provider instance already exists, so we can // return it right away. //为contentProvider增加引用数 conn = incProviderCountLocked(r, cpr, token, stable); if (conn != null && (conn.stableCount+conn.unstableCount) == 1) { if (cpr.proc != null && r.setAdj <= ProcessList.PERCEPTIBLE_APP_ADJ) { // 更新提供contentProvider进程的位置 ...... updateLruProcessLocked(cpr.proc, false, null); } } //下面检查提供contentprovider的进程是否存活，若已死亡，等待新的进程启动 //它是通过oom_adj的值来检查的 final int verifiedAdj = cpr.proc.verifiedAdj; boolean success = updateOomAdjLocked(cpr.proc); if (success && verifiedAdj != cpr.proc.setAdj && !isProcessAliveLocked(cpr.proc)) { success = false; } ...... if (!success) { // 进程已为空，等待新进程的启动 appDiedLocked(cpr.proc); ...... providerRunning = false; conn = null; } else { cpr.proc.verifiedAdj = cpr.proc.setAdj; } Binder.restoreCallingIdentity(origId); }
上面的代码是当有contentProvider时，该如何做。应在注释中写明
这两个方法的作用详见：
下面我们来分析contentProvider不存在的情况，这里我们把5.1.2和5.1.3合并到一起分析
if (!providerRunning) {
try{
//在此获得provider的信息
cpi = AppGlobals.getPackageManager(). resolveContentProvider(name, STOCK_PM_FLAGS | PackageManager.GET_URI_PERMISSION_PATTERNS, userId); checkTime(startTime, "getContentProviderImpl: after resolveContentProvider"); } catch (RemoteException ex) { } if (cpi == null) { return null; } // 参数检查
......
ComponentName comp = new ComponentName(cpi.packageName, cpi.name); ......
//以类名的来获得provider cpr = mProviderMap.getProviderByClass(comp, userId); ......final boolean firstClass = cpr == null; if (firstClass) { ......try { checkTime(startTime, "getContentProviderImpl: before getApplicationInfo"); ApplicationInfo ai = AppGlobals.getPackageManager(). getApplicationInfo( cpi.applicationInfo.packageName, STOCK_PM_FLAGS, userId); ...... ai = getAppInfoForUser(ai, userId);
//因为我们需要provider，但是provider记录不存在，所以在此创建一个ContentProviderRecord来保存要获得provider cpr = new ContentProviderRecord(this, cpi, ai, comp, singleton); } catch (RemoteException ex) { // pm is in same process, this will never happen. } finally { Binder.restoreCallingIdentity(ident); } } ......
//到这里我们已经获得了contentProviderRecord对象cpr，不管它含不含有provider
if (r != null && cpr.canRunHere(r)) {
//条件成立，表示provider可以在请求者进程运行，或在请求者进程创建，则可以直接返回一个Holder return cpr.newHolder(null); } if (DEBUG_PROVIDER) Slog.w(TAG_PROVIDER, "LAUNCHING REMOTE PROVIDER (myuid " + (r != null ? r.uid : null) + " pruid " + cpr.appInfo.uid + "): " + cpr.info.name + " callers=" + Debug.getCallers(6)); //查看是否有正在启动的provider，若有等待启动完成 final int N = mLaunchingProviders.size(); int i; for (i = 0; i < N; i++) { if (mLaunchingProviders.get(i) == cpr) { break; } } // 没有正在启动的provider，去启动它 if (i >= N) { final long origId = Binder.clearCallingIdentity(); try { // 加载provider所在的包 try { ...... AppGlobals.getPackageManager().setPackageStoppedState( cpr.appInfo.packageName, false, userId); checkTime(startTime, "getContentProviderImpl: after set stopped state"); } catch (RemoteException e) { } catch (IllegalArgumentException e) { Slog.w(TAG, "Failed trying to unstop package " + cpr.appInfo.packageName + ": " + e); } // 获得provider所在的进程，因为我们要在此进程中启动provider ProcessRecord proc = getProcessRecordLocked( cpi.processName, cpr.appInfo.uid, false); if (proc != null && proc.thread != null && !proc.killed) {
//条件成立，表示进程已经启动 if (DEBUG_PROVIDER) Slog.d(TAG_PROVIDER, "Installing in existing process " + proc); if (!proc.pubProviders.containsKey(cpi.name)) { checkTime(startTime, "getContentProviderImpl: scheduling install"); proc.pubProviders.put(cpi.name, cpr); try {
//在此进程启动provider proc.thread.scheduleInstallProvider(cpi); } catch (RemoteException e) { } } } else { //条件不成立，则需要先启动一个进程，然后等待此进程加载provider proc = startProcessLocked(cpi.processName, cpr.appInfo, false, 0, "content provider", new ComponentName(cpi.applicationInfo.packageName, cpi.name), false, false, false); ...... } cpr.launchingApp = proc; mLaunchingProviders.add(cpr); } finally { Binder.restoreCallingIdentity(origId); } } //此处保存这个新provider的一些引用信息 if (firstClass) { mProviderMap.putProviderByClass(comp, cpr); } mProviderMap.putProviderByName(name, cpr); conn = incProviderCountLocked(r, cpr, token, stable); if (conn != null) { conn.waiting = true; } }
完成上面的代码，表示provider已经存在，或正在启动，下面的代码用来检查
synchronized (cpr) { while (cpr.provider == null) { ......try { ...... cpr.wait(); } catch (InterruptedException ex) { } finally { if (conn != null) { conn.waiting = false; } } } } return cpr != null ? cpr.newHolder(conn) : null;
新的provider成功获得后，把它放在一个Holder中返回
下面我们来说一下，上面的两个进程中启动provider的方法startProcessLocked()和scheduleInstallProvider(),他们最终都会调用installProvider()。现在，我们以scheduleInstallProvider（）来分析。首先，会调用ApplicationThread的scheduleInstallProvider(),而在这个方法中会给消息队列发送一个消息，然后，会转到ActivityThread中的Handler对象中去处理。继而调用handleInstallProvider().
ActivityThread的handleInstallProvider():
public void handleInstallProvider(ProviderInfo info) { final StrictMode.ThreadPolicy oldPolicy = StrictMode.allowThreadDiskWrites(); try { installContentProviders(mInitialApplication, Lists.newArrayList(info)); } finally { StrictMode.setThreadPolicy(oldPolicy); } }
此方法会转而去调用installContentProviders（）
ActivityThread的installContentProviders（）
private void installContentProviders( Context context, List<ProviderInfo> providers) { final ArrayList<IActivityManager.ContentProviderHolder> results = new ArrayList<IActivityManager.ContentProviderHolder>(); for (ProviderInfo cpi : providers) { if (DEBUG_PROVIDER) { StringBuilder buf = new StringBuilder(128); buf.append("Pub "); buf.append(cpi.authority); buf.append(": "); buf.append(cpi.name); Log.i(TAG, buf.toString()); } 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(); } }
在这个方法中，首先会获得要加载的每一个provider的信息，因为我们这里只传入了一个，所以providers的长度为1.然后调用installProvider()去启动provider，启动完成之后会去告诉AMS，此provider已经启动完毕，让AMS去更新一些信息。installProvider()这个方法我们在前面请求者请求provider时见过，所以在这我们结合着两种不同的场景来分这方法的实现
ActivityThread的installProviders()
private IActivityManager.ContentProviderHolder installProvider(Context context, I
ActivityManager.ContentProviderHolder holder, ProviderInfo inf
boolean noisy, boolean noReleaseNeeded, boolean stable) {
ContentProvider localProvider = null;
IContentProvider provider;
if (holder == null || holder.provider == null) { ......
//在此首先要获得与要加载provider相关的Context，因为provider是null，所以我们在后面要去实例化一个provider，这是当前情况下的处理做法
Context c = null; ApplicationInfo ai = info.applicationInfo; if (context.getPackageName().equals(ai.packageName)) { c = context; } else if (mInitialApplication != null && mInitialApplication.getPackageName().equals(ai.packageName)) { c = mInitialApplication; } else { try { c = context.createPackageContext(ai.packageName, Context.CONTEXT_INCLUDE_CODE); } catch (PackageManager.NameNotFoundException e) { // Ignore } } ......try { final java.lang.ClassLoader cl = c.getClassLoader(); localProvider = (ContentProvider)cl. loadClass(info.name).newInstance();
//实例化一个provider，并获得可以在进程间通信的Transport对象 provider = localProvider.getIContentProvider(); ......
// 为新创建的provider配置一些信息，如读写权限之类的 localProvider.attachInfo(c, info); } catch (java.lang.Exception e) { ...... } } else {
//这是在请求者请求时的处理，传进来的是一个在其他进程已经启动好了的provider provider = holder.provider; ...... } IActivityManager.ContentProviderHolder retHolder; synchronized (mProviderMap) { ...... IBinder jBinder = provider.asBinder(); if (localProvider != null) {
//条件成立，表示此provider是新建的，需要保存一些引用 ComponentName cname = new ComponentName(info.packageName, info.name); ProviderClientRecord pr = mLocalProvidersByName.get(cname); if (pr != null) { //为null表示，在多个进程同时请求时，竞争失败，已经有其他进程先获得了provider，在此不需要在此保存 provider = pr.mProvider; } else {
//需要将provider保存在holder中 holder = new IActivityManager.ContentProviderHolder(info); holder.provider = provider; holder.noReleaseNeeded = true; pr = installProviderAuthoritiesLocked(provider, localProvider, holder); mLocalProviders.put(jBinder, pr); mLocalProvidersByName.put(cname, pr); } retHolder = pr.mHolder; } else {
//表示此provider是用其他进程传入的，要在此保存provider的引用数量，当Pro不为null时，是第一次传入，可以根据要求判断是否进行更新
//pro为null，则需要创建一个provider远程引用数，并进行保存
ProviderRefCount prc = mProviderRefCountMap.get(jBinder); if (prc != null) { ...... if (!noReleaseNeeded) { incProviderRefLocked(prc, stable); try { ActivityManagerNative.getDefault().removeContentProvider( holder.connection, stable); } catch (RemoteException e) { //do nothing content provider object is dead any way } } } else { ProviderClientRecord client = installProviderAuthoritiesLocked( provider, localProvider, holder); if (noReleaseNeeded) { prc = new ProviderRefCount(holder, client, 1000, 1000); } else { prc = stable ? new ProviderRefCount(holder, client, 1, 0) : new ProviderRefCount(holder, client, 0, 1); } mProviderRefCountMap.put(jBinder, prc); } retHolder = prc.holder; } } return retHolder; }
然后，我们可以通知AMS去发布provider了
AMS的publishContentProviders()
public final void publishContentProviders(IApplicationThread caller, List<ContentProviderHolder> providers) { .....synchronized (this) { final ProcessRecord r = getRecordForAppLocked(caller); ......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; }
//dst为之前在getContentProviderImpl中创建的provider记录 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(); int j; boolean wasInLaunchingProviders = false; for (j = 0; j < launchingCount; j++) { if (mLaunchingProviders.get(j) == dst) { mLaunchingProviders.remove(j); wasInLaunchingProviders = true; j--; launchingCount--; } } //在此表示，请求的provider已经被启动，并向record中添加provider，然后打断前面的while循环。synchronized (dst) { dst.provider = src.provider; dst.proc = r; dst.notifyAll(); } updateOomAdjLocked(r); maybeUpdateProviderUsageStatsLocked(r, src.info.packageName, src.info.authority); } } Binder.restoreCallingIdentity(origId); } }
传入的providers 是已经加载好的provider，会与加载的provider进行比较，若相同则说明已经启动，并将其从待启动队列中移除。并向provider记录中添加provider，这样前面的while循环就可以被打断，从而AMS就可以将provider返回，给请求者。
至此contentProvider的启动就已经分析结束。