Android重学系列 ContentProvider 启动原理

前言

终于来到了四大组件的最后一个了,ContentProvider(之后简称CP)开发中用的不是很多,但这不代表这不重要。很多开源库不少巧妙的思路就是借用CP巧妙实现的,如头条的AutoSize是如何自动获取Context的,360的RePlugin是如何管理异步进程的Binder对象。还有比如说插件化管理多个LoadedApk对象,也是从CP的源码中汲取灵感。

当然我们常用的手段都是把CP作为开放给另一个进程或者服务的查询接口。先来看看怎么使用的。

正文

public class MyCP extends ContentProvider {
    @Override
    public boolean onCreate() {
        return false;
    }

    @Nullable
    @Override
    public Cursor query(@NonNull Uri uri, @Nullable String[] projection, @Nullable String selection, @Nullable String[] selectionArgs, @Nullable String sortOrder) {
        return null;
    }

    @Nullable
    @Override
    public String getType(@NonNull Uri uri) {
        return null;
    }

    @Nullable
    @Override
    public Uri insert(@NonNull Uri uri, @Nullable ContentValues values) {
        return null;
    }

    @Override
    public int delete(@NonNull Uri uri, @Nullable String selection, @Nullable String[] selectionArgs) {
        return 0;
    }

    @Override
    public int update(@NonNull Uri uri, @Nullable ContentValues values, @Nullable String selection, @Nullable String[] selectionArgs) {
        return 0;
    }
}

先继承ContentProvider,实现自己的增删查改四个接口。来处理自己可以允许外部操作的数据。一般为SQLite 数据库等敏感数据,从而做到隔离的目的。

接着在在AndroidManifest中声明:

        <provider
            android:name=".MyCP"
            android:authorities="com.example.data"
            />

这样就能让外部的应用,或者本进程应用进行访问通过android:authorities进行访问这个CP中对外开放的数据了。

注意CP支持跨进程,跨应用查询数据,这是怎么做到的呢?本文就来重点探索。

本进程启动时的CP启动

在我写的ActivityThread的初始化一文中,handleBindApplication方法中,有这么一段:

            if (!data.restrictedBackupMode) {
                if (!ArrayUtils.isEmpty(data.providers)) {
                    installContentProviders(app, data.providers);
                    mH.sendEmptyMessageDelayed(H.ENABLE_JIT, 10*1000);
                }
            }

当执行绑定Application的时候,会调用installContentProviders方法。获取AppBindData中所有的从PMS中解析出来来自apk包中所有的ProviderInfo信息,也就是AndroidManifest中所有注册在xml中ContentProvider。

installContentProviders


    private void installContentProviders(
            Context context, List<ProviderInfo> providers) {
        final ArrayList<ContentProviderHolder> results = new ArrayList<>();

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

        try {
            ActivityManager.getService().publishContentProviders(
                getApplicationThread(), results);
        } catch (RemoteException ex) {
            throw ex.rethrowFromSystemServer();
        }
    }
  • 1.遍历每一个ProviderInfo,并且调用installProvider生成对应ContentProvider
  • 2.跨进程调用AMS的publishContentProviders方法。

installProvider 生成ContentProvider

注意这个方法由于支持不同的应用CP的创建,这里的Context不一定是本进程,ContentProviderHolder包含的进程信息也不一定的本进程,因此会做重要的特殊处理:

    private ContentProviderHolder installProvider(Context context,
            ContentProviderHolder holder, ProviderInfo info,
            boolean noisy, boolean noReleaseNeeded, boolean stable) {
        ContentProvider localProvider = null;
        IContentProvider provider;
        if (holder == null || holder.provider == null) {

            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
                }
            }
            if (c == null) {

                return null;
            }

            if (info.splitName != null) {
                try {
                    c = c.createContextForSplit(info.splitName);
                } catch (NameNotFoundException e) {
                    throw new RuntimeException(e);
                }
            }

            try {
                final java.lang.ClassLoader cl = c.getClassLoader();
                LoadedApk packageInfo = peekPackageInfo(ai.packageName, true);
                if (packageInfo == null) {

                    packageInfo = getSystemContext().mPackageInfo;
                }
                localProvider = packageInfo.getAppFactory()
                        .instantiateProvider(cl, info.name);
                provider = localProvider.getIContentProvider();
                if (provider == null) {

                    return null;
                }

                localProvider.attachInfo(c, info);
            } catch (java.lang.Exception e) {
...
                return null;
            }
        } else {
            provider = holder.provider;

        }

        ContentProviderHolder retHolder;

        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 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 {
....
            }
        }
        return retHolder;
    }
  • 1.如果此时ContentProviderHolder为空,或者ContentProviderHolder中的CP为空,说明需要初始化。会根据ProviderInfo中保存的包名信息创造如下三种Context:

    • 1.1.如果包名和下传的Context 上下文的包名一致,CP则使用这个Context创建
    • 1.2.如果Context不一致,则判断执行的当前进程的包名和ProviderInfo的包名是否一致,一致则取mInitialApplication当前进程的Application的Context为CP的上下文
    • 1.3.剩下的情况就是,为CP对应的包名创建一个自己的上下文Context对象。
  • 2.从LoadedApk的缓存中获取是否有加载的其他apk的包名对应的LoadedApk对象。LoadedApk其实就是指Apk加载到内存后的对象,详细可以阅读ActivityThread的初始化。找不到则使用系统Context的包名的LoadedApk对象。使用LoadedApk的AppFactory反射实例化ContentProvider对象。

  • 3.获取ContentProvider中的IContentProvider对象,并调用ContentProvider的attachInfo方法。

  • 4.如果此时创建出来的CP不为空。

    • 4.1.通过当前CP的包名信息ComponentName从缓存mLocalProvidersByName获取ProviderClientRecord对象。
      • 4.1.1.如果能从缓存中获取,IContentProvider则获取ProviderClientRecord中的mProvider对象。
      • 4.1.2.如果无法从缓存中获取,则新创建ContentProviderHolder对象,并为该对象赋值CP的IContentProvider Binder对象。
      • 4.1.3.installProviderAuthoritiesLocked 使用 IContentProvider,CP创建ProviderClientRecord,最后把ProviderClientRecord缓存到mLocalProvidersByName中。

来看看ContentProvider的attachInfo,以及installProviderAuthoritiesLocked。

有一个核心的方法,getIContentProvider方法获取IContentProvider Binder对象,先来看看这个方法做了什么?

位于ContentProvider中的Binder对象 Transport


    private Transport mTransport = new Transport();

    public IContentProvider getIContentProvider() {
        return mTransport;
    }

这个对象实际上就是Transport。

class Transport extends ContentProviderNative

他实际上就是一个派生于ContentProviderNative的Transport对象。所有跨进程通信都是通过这个内部类,通信外部的ContentProvider的。

ContentProvider attachInfo

    public void attachInfo(Context context, ProviderInfo info) {
        attachInfo(context, info, false);
    }

    private void attachInfo(Context context, ProviderInfo info, boolean testing) {
        mNoPerms = testing;

        /*
         * Only allow it to be set once, so after the content service gives
         * this to us clients can't change it.
         */
        if (mContext == null) {
            mContext = context;
            if (context != null) {
                mTransport.mAppOpsManager = (AppOpsManager) context.getSystemService(
                        Context.APP_OPS_SERVICE);
            }
            mMyUid = Process.myUid();
            if (info != null) {
                setReadPermission(info.readPermission);
                setWritePermission(info.writePermission);
                setPathPermissions(info.pathPermissions);
                mExported = info.exported;
                mSingleUser = (info.flags & ProviderInfo.FLAG_SINGLE_USER) != 0;
                setAuthorities(info.authority);
            }
            ContentProvider.this.onCreate();
        }
    }

能看到这里面做了两件很重要的事情:

  • 1.从PMS解析出来的ProviderInfo中获取装载CP的权限
  • 2.调用ContentProvider的onCreate方法。

ActivityThread installProviderAuthoritiesLocked

    private ProviderClientRecord installProviderAuthoritiesLocked(IContentProvider provider,
            ContentProvider localProvider, ContentProviderHolder holder) {
        final String auths[] = holder.info.authority.split(";");
        final int userId = UserHandle.getUserId(holder.info.applicationInfo.uid);

        if (provider != null) {
            // If this provider is hosted by the core OS and cannot be upgraded,
            // then I guess we're okay doing blocking calls to it.
            for (String auth : auths) {
                switch (auth) {
                    case ContactsContract.AUTHORITY:
                    case CallLog.AUTHORITY:
                    case CallLog.SHADOW_AUTHORITY:
                    case BlockedNumberContract.AUTHORITY:
                    case CalendarContract.AUTHORITY:
                    case Downloads.Impl.AUTHORITY:
                    case "telephony":
                        Binder.allowBlocking(provider.asBinder());
                }
            }
        }

        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;
    }
  • 1.如果当前的CP中的权限是:联系方式,下载,日历等,则说明这个CP是由系统托管且不能升级,则允许阻塞调用。
  • 2.创建一个ProviderClientRecord对象,获取当前CP中所有的权限和当前userID生成一个Key,保存到mProviderMap中。

这个缓存相当于可以通过CP的权限协议,快速找到ProviderClientRecord对象。

AMS publishContentProviders

当App端生成并保存好缓存后,则调用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;
                }
                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--;
                        }
                    }
                    if (wasInLaunchingProviders) {
                        mHandler.removeMessages(CONTENT_PROVIDER_PUBLISH_TIMEOUT_MSG, r);
                    }
                    synchronized (dst) {
                        dst.provider = src.provider;
                        dst.proc = r;
                        dst.notifyAll();
                    }
                    updateOomAdjLocked(r, true);
                    maybeUpdateProviderUsageStatsLocked(r, src.info.packageName,
                            src.info.authority);
                }
            }

            Binder.restoreCallingIdentity(origId);
        }
    }
    1. mProviderMap 中做了两级缓存:
    • 1.1.以当前的实例化好的CP包名为key,把保存在ContentProviderHolder的ContentProviderRecord保存起来。
    • 1.2.以当前的实例化好的CP权限协议为key,把保存在ContentProviderHolder的ContentProviderRecord保存起来。
  • 2.如果mLaunchingProviders 不为空,且当前启动的CP是正在启动的mLaunchingProviders中一员,则移除CONTENT_PROVIDER_PUBLISH_TIMEOUT_MSG这个CP的ANR消息。这个时间是10秒。埋入的时机是进入attachApplicationLocked方法,也就是跨进程调用Activitythread的bindApplication之前:

          List<ProviderInfo> providers = normalMode ? generateApplicationProvidersLocked(app) : null;
    
          if (providers != null && checkAppInLaunchingProvidersLocked(app)) {
              Message msg = mHandler.obtainMessage(CONTENT_PROVIDER_PUBLISH_TIMEOUT_MSG);
              msg.obj = app;
              mHandler.sendMessageDelayed(msg, CONTENT_PROVIDER_PUBLISH_TIMEOUT);
          }
  • 3.更新App应用的adj优先级。

正是因为在App进程调用Application的onCreate之后会尝试启动本进程中的CP组件,所以想头条的AndroidAutoSize才能没有在Application中写注册代码就能获取到当前应用的上下文。

通过getContentResolver 创建CP

通过getContentResolver 获取CP对象是我们更加常用的方式。一般使用方法如下:

 Cursor cursor = null;
cursor = getContentResolver().query(ContactsContract.CommonDataKinds.Phone.CONTENT_URI,
                null, null, null, null);

通过getContentResolver获取到CP对象后,调用query查询本进程或者其他进程通过CP开放的数据(一般来说就是数据库的数据)。通过Cursor 游标遍历获取的数据集中的数据。

    public ContentResolver getContentResolver() {
        return mContentResolver;
    }

那么mContentResolver这个对象又是从哪里什么时候创建的呢?

    private ContextImpl(@Nullable ContextImpl container, @NonNull ActivityThread mainThread,
            @NonNull LoadedApk packageInfo, @Nullable String splitName,
            @Nullable IBinder activityToken, @Nullable UserHandle user, int flags,
            @Nullable ClassLoader classLoader) {
....
        mContentResolver = new ApplicationContentResolver(this, mainThread);
    }

实际上我们操作的就是ApplicationContentResolver对象,这个对象继承于ContentResolver。

private static final class ApplicationContentResolver extends ContentResolver 

我们先跟着ContentResolver的query,看看它做了什么事情

ContentResolver query

    public final @Nullable Cursor query(@RequiresPermission.Read @NonNull Uri uri,
            @Nullable String[] projection, @Nullable String selection,
            @Nullable String[] selectionArgs, @Nullable String sortOrder) {
        return query(uri, projection, selection, selectionArgs, sortOrder, null);
    }

    public final @Nullable Cursor query(@RequiresPermission.Read @NonNull Uri uri,
            @Nullable String[] projection, @Nullable String selection,
            @Nullable String[] selectionArgs, @Nullable String sortOrder,
            @Nullable CancellationSignal cancellationSignal) {
        Bundle queryArgs = createSqlQueryBundle(selection, selectionArgs, sortOrder);
        return query(uri, projection, queryArgs, cancellationSignal);
    }

    public final @Nullable Cursor query(final @RequiresPermission.Read @NonNull Uri uri,
            @Nullable String[] projection, @Nullable Bundle queryArgs,
            @Nullable CancellationSignal cancellationSignal) {
        Preconditions.checkNotNull(uri, "uri");
        IContentProvider unstableProvider = acquireUnstableProvider(uri);
        if (unstableProvider == null) {
            return null;
        }
        IContentProvider stableProvider = null;
        Cursor qCursor = null;
        try {
            long startTime = SystemClock.uptimeMillis();

....
            try {
                qCursor = unstableProvider.query(mPackageName, uri, projection,
                        queryArgs, remoteCancellationSignal);
            } catch (DeadObjectException e) {

                unstableProviderDied(unstableProvider);
                stableProvider = acquireProvider(uri);
                if (stableProvider == null) {
                    return null;
                }
                qCursor = stableProvider.query(
                        mPackageName, uri, projection, queryArgs, remoteCancellationSignal);
            }
            if (qCursor == null) {
                return null;
            }


            qCursor.getCount();
            long durationMillis = SystemClock.uptimeMillis() - startTime;
      ...
            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 {
            if (qCursor != null) {
                qCursor.close();
            }
            if (cancellationSignal != null) {
                cancellationSignal.setRemote(null);
            }
            if (unstableProvider != null) {
                releaseUnstableProvider(unstableProvider);
            }
            if (stableProvider != null) {
                releaseProvider(stableProvider);
            }
        }
    }
  • 1.acquireUnstableProvider 先获取一个先从ActivityThread中获取一个IContentProvider Binder对象

  • 2.调用IContentProvider的query方法。

  • 3.如果query方法爆出了Binder死亡异常的错误,先调用unstableProviderDied销毁原来的对象,再一次调用acquireProvider方法获取IContentProvider对象,再进行一次query的方法,查询数据结果。

  • 4.stableProvider为空,也就说没有经过弥补查询的过程,则调用acquireProvider获取IContentProvider对象,并把获取到的数据浮标Cursor和IContentProvider封装成CursorWrapperInner返回。

  • 5.如果stableProvider不为空,说明出现过异常,弥补了异常,直接使用stableProvider封装成CursorWrapperInner返回。

核心的方法有三个:

  • 1.acquireUnstableProvider 获取IContentProvider
  • 2.acquireProvider 获取IContentProvider
  • 3.IContentProvider的query方法。

acquireProvider和acquireUnstableProvider

在ContentResolver中:

    public final IContentProvider acquireUnstableProvider(Uri uri) {
        if (!SCHEME_CONTENT.equals(uri.getScheme())) {
            return null;
        }
        String auth = uri.getAuthority();
        if (auth != null) {
            return acquireUnstableProvider(mContext, uri.getAuthority());
        }
        return null;
    }

    public final IContentProvider acquireProvider(Uri uri) {
        if (!SCHEME_CONTENT.equals(uri.getScheme())) {
            return null;
        }
        final String auth = uri.getAuthority();
        if (auth != null) {
            return acquireProvider(mContext, auth);
        }
        return null;
    }

核心的实现还是它的派生类ApplicationContentResolver

        @Override
        protected IContentProvider acquireUnstableProvider(Context c, String auth) {
            return mMainThread.acquireProvider(c,
                    ContentProvider.getAuthorityWithoutUserId(auth),
                    resolveUserIdFromAuthority(auth), false);
        }


        @Override
        protected IContentProvider acquireProvider(Context context, String auth) {
            return mMainThread.acquireProvider(context,
                    ContentProvider.getAuthorityWithoutUserId(auth),
                    resolveUserIdFromAuthority(auth), true);
        }

能看到这两个方法最后都是调用了ActivityThread的acquireProvider方法。

ActivityThread acquireProvider
    public final IContentProvider acquireProvider(
            Context c, String auth, int userId, boolean stable) {
        final IContentProvider provider = acquireExistingProvider(c, auth, userId, stable);
        if (provider != null) {
            return provider;
        }


        ContentProviderHolder holder = null;
        try {
            synchronized (getGetProviderLock(auth, userId)) {
                holder = ActivityManager.getService().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;
        }

        holder = installProvider(c, holder, holder.info,
                true /*noisy*/, holder.noReleaseNeeded, stable);
        return holder.provider;
    }

    private Object getGetProviderLock(String auth, int userId) {
        final ProviderKey key = new ProviderKey(auth, userId);
        synchronized (mGetProviderLocks) {
            Object lock = mGetProviderLocks.get(key);
            if (lock == null) {
                lock = key;
                mGetProviderLocks.put(key, lock);
            }
            return lock;
        }
    }
  • 1.首先通过acquireExistingProvider 使用CP的uri权限获取已经保存在mProviderMap缓存好的IContentProvider对象,增加引用计数。如果找到了IContentProvider对象,则直接返回。

      public final IContentProvider acquireExistingProvider(
              Context c, String auth, int userId, boolean stable) {
          synchronized (mProviderMap) {
              final ProviderKey key = new ProviderKey(auth, userId);
              final ProviderClientRecord pr = mProviderMap.get(key);
              if (pr == null) {
                  return null;
              }
    
              IContentProvider provider = pr.mProvider;
              IBinder jBinder = provider.asBinder();
              if (!jBinder.isBinderAlive()) {
    
                  handleUnstableProviderDiedLocked(jBinder, true);
                  return null;
              }
    
              ProviderRefCount prc = mProviderRefCountMap.get(jBinder);
              if (prc != null) {
                  incProviderRefLocked(prc, stable);
              }
              return provider;
          }
      }
  • 2.如果当前进程不存在一个IContentProvider对象,说明当前CP对象是其他进程提供的,或者是当前的进程还有启动这个CP对象。那么通过auth从mGetProviderLocks获取一个互斥锁,通过AMS跨进程获取ContentProviderHolder对象,接着通过installProvider把这个CP对象装载在本进程中。

AMS getContentProvider

    public final ContentProviderHolder getContentProvider(
            IApplicationThread caller, String name, int userId, boolean stable) {
        enforceNotIsolatedCaller("getContentProvider");
...
        return getContentProviderImpl(caller, name, null, stable, userId);
    }

从AMS获取一个ContentProviderHolder对象核心还是getContentProviderImpl

getContentProviderImpl

下面这个方法很长,我们分为几个阶段来聊聊。

    private ContentProviderHolder getContentProviderImpl(IApplicationThread caller,
            String name, IBinder token, boolean stable, int userId) {
        ContentProviderRecord cpr;
        ContentProviderConnection conn = null;
        ProviderInfo cpi = null;

        synchronized(this) {
            long startTime = SystemClock.uptimeMillis();

            ProcessRecord r = null;
            if (caller != null) {
                r = getRecordForAppLocked(caller);
...
            }

            boolean checkCrossUser = true;



            cpr = mProviderMap.getProviderByName(name, userId);

...
            boolean providerRunning = cpr != null && cpr.proc != null && !cpr.proc.killed;
            if (providerRunning) {
                cpi = cpr.info;
                String msg;

...

                if (r != null && cpr.canRunHere(r)) {

                    holder.provider = null;
                    return holder;
                }

                try {
                    if (AppGlobals.getPackageManager()
                            .resolveContentProvider(name, 0 /*flags*/, userId) == null) {
                        return null;
                    }
                } catch (RemoteException e) {
                }

                final long origId = Binder.clearCallingIdentity();

                conn = incProviderCountLocked(r, cpr, token, stable);
                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;
                boolean success = updateOomAdjLocked(cpr.proc, true);

                if (success && verifiedAdj != cpr.proc.setAdj && !isProcessAliveLocked(cpr.proc)) {
                    success = false;
                }
                maybeUpdateProviderUsageStatsLocked(r, cpr.info.packageName, name);
 ...
                Binder.restoreCallingIdentity(origId);
            }

...
    }
    1. 首先先从mProviderMap,通过权限名和userId查找AMS中已经启动的ContentProviderRecord对象。注意在ProviderMap有4层缓存:

      private final HashMap<String, ContentProviderRecord> mSingletonByName
             = new HashMap<String, ContentProviderRecord>();
      private final HashMap<ComponentName, ContentProviderRecord> mSingletonByClass
             = new HashMap<ComponentName, ContentProviderRecord>();
      
      private final SparseArray<HashMap<String, ContentProviderRecord>> mProvidersByNamePerUser
             = new SparseArray<HashMap<String, ContentProviderRecord>>();
      private final SparseArray<HashMap<ComponentName, ContentProviderRecord>> mProvidersByClassPerUser
             = new SparseArray<HashMap<ComponentName, ContentProviderRecord>>();

      能通过Class的包名查找ContentProviderRecord,能直接通过name也就是CP的权限名查找ContentProviderRecord。

如果在这两个缓存中找不到,说明ContentProviderRecord对象会根据userID作为key 保存在SparseArray集合中。可以通过userId在对应的应用查找启动过的CP对象

注意此时调用query的时候传入的是一个uri格式,会获取uri的authority部分作为线索在AMS中查找缓存。同样的userId也是从authority中获取。也就是说如果想要对着某一个userID的缓存下查询CP对象,权限就要符合下面的格式:

userId@authority

会截取@之前的数字作为userId。

接下来就会根据ProviderMap的结果,得到此时需要当前需要访问的CP是否还存活?

CP 对象存活
            if (providerRunning) {
                cpi = cpr.info;
                String msg;

...

                if (r != null && cpr.canRunHere(r)) {

                    ContentProviderHolder holder = cpr.newHolder(null);

                    holder.provider = null;
                    return holder;
                }

                try {
                    if (AppGlobals.getPackageManager()
                            .resolveContentProvider(name, 0 /*flags*/, userId) == null) {
                        return null;
                    }
                } catch (RemoteException e) {
                }

                final long origId = Binder.clearCallingIdentity();


                conn = incProviderCountLocked(r, cpr, token, stable);
                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;
                boolean success = updateOomAdjLocked(cpr.proc, true);

....
            }
  • 1.则调用ContentProviderRecord.canRunHere,校验CP对象是否能在调用方的进程运行

  • 2.如果可以则ContentProviderRecord.newHolder 生成一个ContentProviderHolder,设置其中的provider为空返回。

  • 3.增加引用计数,更新进程的adj优先级

ContentProviderRecord canRunHere
    public boolean canRunHere(ProcessRecord app) {
        return (info.multiprocess || info.processName.equals(app.processName))
                && uid == app.info.uid;
    }

是否允许运行在当前进程,满足两个条件其一即可:

  • 1.android:multiprocess="true"在AndroidManifest中打开这个设置,允许CP在另外一个进程运行
  • 2.uid一致且进程名一致

如果是允许多进程执行,那就不关心这个CP运行在哪一个进程了,直接返回ContentProviderHolder。注意如果android:multiprocess没有打开,就如同系统查询手机联系人一样:

        <provider android:name="CallLogProvider"
            android:authorities="call_log"
            android:syncable="false" android:multiprocess="false"
            android:exported="true"
            android:readPermission="android.permission.READ_CALL_LOG"
            android:writePermission="android.permission.WRITE_CALL_LOG">
        </provider>

它不允许多进程运行,必须是当前进程执行。那么会直接到了方法最底部直接调用ContentProviderRecord.newHolder返回,不同的是传入了ContentProviderConnection

ContentProviderRecord newHolder
    public ContentProviderHolder newHolder(ContentProviderConnection conn) {
        ContentProviderHolder holder = new ContentProviderHolder(info);
        holder.provider = provider;
        holder.noReleaseNeeded = noReleaseNeeded;
        holder.connection = conn;
        return holder;
    }

返回了IContentProvider对象以及传入一个ContentProviderConnection对象,此时是空,我们暂时不去考虑。

CP对象还没有启动

如果通过权限没办法找到对应的ContentProviderRecord对象,说明很可能没有启动.

            if (!providerRunning) {
                try {

                    cpi = AppGlobals.getPackageManager().
                        resolveContentProvider(name,
                            STOCK_PM_FLAGS | PackageManager.GET_URI_PERMISSION_PATTERNS, userId);

                } catch (RemoteException ex) {
                }
                if (cpi == null) {
                    return null;
                }

                boolean singleton = isSingleton(cpi.processName, cpi.applicationInfo,
                        cpi.name, cpi.flags)
                        && isValidSingletonCall(r.uid, cpi.applicationInfo.uid);
                if (singleton) {
                    userId = UserHandle.USER_SYSTEM;
                }
                cpi.applicationInfo = getAppInfoForUser(cpi.applicationInfo, userId);


                String msg;

                if ((msg = checkContentProviderPermissionLocked(cpi, r, userId, !singleton))
                        != null) {
                    throw new SecurityException(msg);
                }


                if (!mProcessesReady
                        && !cpi.processName.equals("system")) {

                    throw new IllegalArgumentException(
                            "Attempt to launch content provider before system ready");
                }

...

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

                        if (ai == null) {
                            return null;
                        }
                        ai = getAppInfoForUser(ai, userId);
                        cpr = new ContentProviderRecord(this, cpi, ai, comp, singleton);
                    } catch (RemoteException ex) {
                        // pm is in same process, this will never happen.
                    } finally {
                        Binder.restoreCallingIdentity(ident);
                    }
                }

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


                if (i >= N) {
                    final long origId = Binder.clearCallingIdentity();

                    try {
...
                        ProcessRecord proc = getProcessRecordLocked(
                                cpi.processName, cpr.appInfo.uid, false);
                        if (proc != null && proc.thread != null && !proc.killed) {

                            if (!proc.pubProviders.containsKey(cpi.name)) {

                                proc.pubProviders.put(cpi.name, cpr);
                                try {
                                    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 {
                        Binder.restoreCallingIdentity(origId);
                    }
                }

                if (firstClass) {
                    mProviderMap.putProviderByClass(comp, cpr);
                }

                mProviderMap.putProviderByName(name, cpr);
                conn = incProviderCountLocked(r, cpr, token, stable);
                if (conn != null) {
                    conn.waiting = true;
                }
            }

            grantEphemeralAccessLocked(userId, null /*intent*/,
                    cpi.applicationInfo.uid, UserHandle.getAppId(Binder.getCallingUid()));
        }
  • 1.首先resolveContentProvider从PMS中获取AndroidManifest中解析出对应的ProviderInfo对象。

  • 2.通过ProviderInfo,获取其中的包名和类名,判断是否希望启动系统唯一的CP独享,但是发现运行的程序不是系统且没有运行则会报错。

  • 3.根据ProviderInfo中保存的包名和类名从ProviderMap中查找是否有启动过的ContentProviderRecord对象。

  • 4.通过AMS获取ProviderInfo的应用信息,根据应用信息和ProviderInfo生成ContentProviderRecord对象。接着校验ContentProviderRecord是否可以在调用进程运行,如果可以则返回ContentProviderHolder,在App进程生成CP对象。

  • 5.接下来就是如果不可以在调用进程运行,说明此时这个不是该应用的CP注册没有打开多进程的标志。

    • 5.1.那么遍历mLaunchingProviders中是否存在现在需要启动的ContentProviderRecord对象。
      • 5.1.1.如果有,说明正在启动的CP对应的进程正在启动或者进程还在存活正在装载CP对象,此时则直接返回ContentProviderHolder。
  • 6.如果没有在mLaunchingProviders找到CP对应的进程正在启动,进一步的判断这个进程是否还存活:

    • 6.1.如果当前的进程还存活,进程对象ProcessRecord的pubProviders保存当前的ProviderInfo的包名,并且调用scheduleInstallProvider方法。
    • 6.2.如果当前进程已经死亡了,那么就会调用startProcessLocked,先启动进程,接着mLaunchingProviders保存当前的ContentProviderRecord,mProviderMap根据权限保存当前的ContentProviderRecord对象,接着执行下面这段代码:

        synchronized (cpr) {
            while (cpr.provider == null) {
                if (cpr.launchingApp == null) {

                    return null;
                }
                try {

                    if (conn != null) {
                        conn.waiting = true;
                    }
                    cpr.wait();
                } catch (InterruptedException ex) {
                } finally {
                    if (conn != null) {
                        conn.waiting = false;
                    }
                }
            }
        }
        return cpr != null ? cpr.newHolder(conn) : null;

这一段代码很简单,如果是因为启动CP对象,而需要启动的进程,就会把ContentProviderRecord作为Montor监控器,阻塞这个线程,等待CP所属的进程启动完成。

对于CP还没有运行起来,这里就分为两个大逻辑:

  • 1.CP所属进程还存活,就会调用scheduleInstallProvider安装CP对象
  • 2.CP的进程不存活,则会阻塞当前的进程,知道进程启动成功后唤醒,才会继续返回方法。

返回之后调用installProvider方法

ActivityThread scheduleInstallProvider

这个方法最后调用handleInstallProvider方法

    public void handleInstallProvider(ProviderInfo info) {
        final StrictMode.ThreadPolicy oldPolicy = StrictMode.allowThreadDiskWrites();
        try {
            installContentProviders(mInitialApplication, Arrays.asList(info));
        } finally {
            StrictMode.setThreadPolicy(oldPolicy);
        }
    }
CP所属的App进程启动后唤醒,AMS的阻塞

这一段其实就是当App进程启动后,调用installProvider装载好CP之后,调用publishContentProviders方法,跨进程调用AMS的publishContentProviders:

    public final void publishContentProviders(IApplicationThread caller,
            List<ContentProviderHolder> providers) {
        if (providers == null) {
            return;
        }

        enforceNotIsolatedCaller("publishContentProviders");
        synchronized (this) {
...
            final long origId = Binder.clearCallingIdentity();

            final int N = providers.size();
            for (int i = 0; i < N; i++) {
...
                if (dst != null) {
...
                    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--;
                        }
                    }
                    if (wasInLaunchingProviders) {
                        mHandler.removeMessages(CONTENT_PROVIDER_PUBLISH_TIMEOUT_MSG, r);
                    }
                    synchronized (dst) {
                        dst.provider = src.provider;
                        dst.proc = r;
                        dst.notifyAll();
                    }
....
                }
            }

            Binder.restoreCallingIdentity(origId);
        }
    }

就是在这里,当CP所属进程绑定好Application之后,publishContentProviders查询之前在getContentProviderImpl添加到mLaunchingProviders集合中的ContentProviderRecord对象。调用ContentProviderRecord的notifyAll,唤醒还在等待的调用端。

  • 2.接着通过Context中的ClassLoader,反射生成CP对象。注意这里反射的时候是使用系统Context的AppFactory,也就是说无法使用自定义的AppFactory做特殊处理。
  • 3.最后保存到本地缓存mLocalProviders中,并生成新的ContentProviderHolder返回给AMS中进行缓存。

这个过程是不是很熟悉,其实就是插件化的核心原理,关于插件化的原理可以阅读我写的横向浅析Small,RePlugin两个插件化框架实际上就是从这里获取到灵感的。

CP 调用query查询数据

我们继续getContentResolve().query方法的流程,当准备好之后CP对象后,就调用ContentProvider中的Transport对象的query方法进行查询:

        public Cursor query(String callingPkg, Uri uri, @Nullable String[] projection,
                @Nullable Bundle queryArgs, @Nullable ICancellationSignal cancellationSignal) {
            validateIncomingUri(uri);
            uri = maybeGetUriWithoutUserId(uri);
            if (enforceReadPermission(callingPkg, uri, null) != AppOpsManager.MODE_ALLOWED) {

                if (projection != null) {
                    return new MatrixCursor(projection, 0);
                }

                Cursor cursor = ContentProvider.this.query(
                        uri, projection, queryArgs,
                        CancellationSignal.fromTransport(cancellationSignal));
                if (cursor == null) {
                    return null;
                }

                return new MatrixCursor(cursor.getColumnNames(), 0);
            }
            final String original = setCallingPackage(callingPkg);
            try {
                return ContentProvider.this.query(
                        uri, projection, queryArgs,
                        CancellationSignal.fromTransport(cancellationSignal));
            } finally {
                setCallingPackage(original);
            }
        }

在查询的时候会校验,当前CP是否设置了android:readPermission读取权限,如果设置了需要进行校验才能进行查询。同理增删改三个操作则是需要设置android:writePermission写入权限是否设置并允许。

如果此时不允许,且搜索的行列不为空,返回一个空数据的MatrixCursor。如果调用了query之后查询到的浮标是空则返回空。否则返回带了所有列名的空数据浮标

如果允许则调用ContentProvider的query方法,直接返回。在这里直接返回了Cursor 包含数据窗口的浮标。如果是SQLCursor的实现,那么就是来自sqlite数据库的数据。

当时进行SQLCursor查询的时候,会把索引填充好在整个CursorWindow中,等待浮标的移动进行查询。

总结与思考

CP的启动可以分为如下三种情况:

CP 异进程的启动与安装小结

本应用的CP在本应用中是如何安装,这个很简单。就是在Application 绑定之后,调用installProvider实例化每一个来自本应用中所有在AndroidManifest的privder标签。如下图:
本应用的ContentProvider在本应用启动.png

真正可能让人弄迷糊的问题就是,客户端应用需要访问一个不属于客户端应用的CP对象。

可以分为两个情况,一个是添加了android:multiprocess="true"的CP,一个是没有。

  • 对于没有打开多进程标签,也会生成一个ContentProviderHolder对象,保存到mLauncherProviders集合中,并阻塞获取ContentProviderHolder对象的流程。
    • 然后等到启动CP所属真正的进程,实例化好ContentProvider后。再实例化一个ContentProviderHolder对象,不过这个时候ContentProviderHolder就有了Transport 这个Binder对象。
    • 通过AMS的publishContentProviders保存当前CP对应的CP名和ContentProviderHolder对象在ProviderMap中,让之后其他应用可以通过这个Binder通信到CP所属的进程进行数据上的交互。

如图:
其他应用的CP在不允许多进程启动模式.png

  • 对于打开了多进程标签,会返回一个ContentProviderHolder对象,而这个对象中IContentProvider Binder对象,也就是Transport对象。接下来则比较复杂:

    • 1.在installProvider方法中,先通过createPackageContext,创建出包名对应的Context上下文出来:

      public Context createPackageContextAsUser(String packageName, int flags, UserHandle user)
              throws NameNotFoundException {
          if (packageName.equals("system") || packageName.equals("android")) {
              // The system resources are loaded in every application, so we can safely copy
              // the context without reloading Resources.
              return new ContextImpl(this, mMainThread, mPackageInfo, null, mActivityToken, user,
                      flags, null);
          }
      
          LoadedApk pi = mMainThread.getPackageInfo(packageName, mResources.getCompatibilityInfo(),
                  flags | CONTEXT_REGISTER_PACKAGE, user.getIdentifier());
          if (pi != null) {
              ContextImpl c = new ContextImpl(this, mMainThread, pi, null, mActivityToken, user,
                      flags, null);
      
              final int displayId = mDisplay != null
                      ? mDisplay.getDisplayId() : Display.DEFAULT_DISPLAY;
      
              c.setResources(createResources(mActivityToken, pi, null, displayId, null,
                      getDisplayAdjustments(displayId).getCompatibilityInfo()));
              if (c.mResources != null) {
                  return c;
              }
          }
      
          throw new PackageManager.NameNotFoundException(
                  "Application package " + packageName + " not found");
      }

      能看到这个过程很熟悉,就是通过getPackageInfo从PMS中获取包名对应的LoadedApk对象,这个对象就是apk在内存中的表示,接着装载资源到Context中,并返回Context。

如图:
非本应用的CP打开多进程模式.png

关于资源是如何加载的可以阅读我写的资源管理系统系列,关于Context和Application是如何绑定可以阅读我写的ActivityThread的初始化

思考

基于CP这种初始化的特殊性,开发者们也在此基础上做了各种奇思妙想。比如说,我不想过多的涉足应用的Application中,可以把初始化放到CP中进行,最经典就是AndroidAutoSize的初始化。当然,我自己在编写自定义腾讯Matrix插件时候也用到这种思路。

RePlugin在管理每一个插件的Binder接口时候,也是包装成一个Cursor返回。

那么为什么Cursor没有实现Binder对象,也能进行数据共享呢?因为在客户端也提供了一个CP对象,把另一个进程的代码和ClassLoader也加载到本进程中。

为什么要这么做?因为CP本身经常和SQLite一起出现,由于Cursor中包含了数据库的浮标。每一次进行数据查询都会填充浮标中的浮标窗口,它的数据量很可能超过了Binder的传输限制,因此Google官方才会这么做。

其实这个CP加载把别的应用apk加载到另一个应用的过程,就是我们常说的插件化。插件化最初的灵感就是来源于此,关于插件化的具体原理,可以阅读横向浅析Small,RePlugin两个插件化框架

后话

关于ContentProvider的启动就到这里了,但是我并没有深入聊CP中链接到数据库的原理,如何查询,数据如何填充CursorWindow的。关于这部分的知识等,后面有机会我们来解析Android的sqlite是如何实现的吧。

还有一句话,如果从重学系列一直跟着阅读到现在的朋友,现在应该可以把我两年前写的插件化原理绝大部分的内容都看懂了。接下来再让我写完最后一个PMS的模块,就可以把写了2年的Android重学系列给完结了。


 上一篇
Android重学系列 PackageManagerService的启动与安装(上) Android重学系列 PackageManagerService的启动与安装(上)
前言PackageManagerService 是Android系统中对所有apk包的管理服务中心,之后我将成其为PMS。PMS除了管理所有已经安装好的apk包的数据,还包含了安装apk的服务,让我们一探究竟。 正文PMS的启动PMS的启动
2020-08-22
下一篇 
Android重学系列 Service 启动和绑定原理 Android重学系列 Service 启动和绑定原理
前言我们已经了解了BroadcastReceiver的原理,我们再来看看四大组件之一的Service是怎么启动的,以及怎么运行的原理。 正文启动Service的入口就是startService和bindService方法。我们先来看看sta
  目录