devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Android 源码分析 (十一) ContentProvider 启动_getcontentprovider

作者：我家自动化 | 2024-07-27 23:47:53

赞

踩

getcontentprovider

ContentProvider (内容提供者) 属于四大组件之一，可以说它是在四大组件中开发者使用率最少的一个，它的作用就是进程间进行数据交互，底层采用 Binder 机制进行进程间通信。

下面我们就以分析 ContentProvider 工作流程为主来进行全面分析。

源码分析

query 到 AMS 调用过程

下面先来看一个代码示例，代码如下:

  1.     fun getContactsLists(): MutableList<String> {
  2.         var contactsLists: MutableList<String> = mutableListOf<String>()
  3.         lateinit var cursor: Cursor
  4.         try {
  5.         //使用 getContentResolver() 查询联系人列表
  6.       	cursor = contentResolver.query(ContactsContract.CommonDataKinds.Phone.CONTENT_URI, null, null, null, null)
  7.         //对 cursor 进行遍历
  8.         if (cursor != null) {
  9.             while (cursor.moveToNext()) {
  10.      
  11.         //电话号码
  12.             val number = cursor.getString(cursor.getColumnIndex(ContactsContract.CommonDataKinds.Phone.NUMBER))
  13.             contactsLists.add("电话:$number")
  14.             }
  15.         }
  16. 	cursor.close()
  17.         } catch (error: Exception) {
  18.             logger.error("error:$error")
  19.         }
  20.         return contactsLists
  21.     }
  22.  
  23. 	//测试
  24.     val contactsLists = getContactsLists()
  25.     contactsLists.forEach { it -> println("通过ContentResolver获取联系人: $contactsLists") }
  26.

那么这一流程内部是怎么运行的，下面进入代码分析。老规矩，还是看一下该小节分析流程，这里以时序图为主

 通过上面代码示例想要 query 数据先要拿到 contentResolver 对象，通过父类 getContentResolver()方法获得，代码如下:

  1.     @Override
  2.     public ContentResolver getContentResolver() {
  3.         return mBase.getContentResolver();
  4.     }

这里的 mBase 是 Context 对象，它的实现类就是 ContextImpl 我们直接看它具体实现，代码如下:

  1. //ContextImpl.java
  2.     @Override
  3.     public ContentResolver getContentResolver() {
  4.         return mContentResolver;
  5.     }

这里的 getContentResolver 方法中返回了 ApplicationContentResolver 对象，它是 ContextImpl 的静态内部类，继承自 ContentResolver ,它在 ContextImpl 的构造方法中被创建，就会启动 ContentProvider,这里以上面我们示例 query 来进行分析，我们看它的具体实现，

  1. //ContentResolver.java
  2.     public final @Nullable Cursor query(final @RequiresPermission.Read @NonNull Uri uri,
  3.             @Nullable String[] projection, @Nullable Bundle queryArgs,
  4.             @Nullable CancellationSignal cancellationSignal) {
  5.         Preconditions.checkNotNull(uri, "uri");
  6.         1. 拿到 IContentProvider 对象,它是 ContentProvider 的本地代理
  7.         IContentProvider unstableProvider = acquireUnstableProvider(uri);
  8.         if (unstableProvider == null) {
  9.             return null;
  10.         }
  11.         IContentProvider stableProvider = null;
  12.         Cursor qCursor = null;
  13.         try {
  14.             
  15.             try {
  16.                2. 调用 IContentProvider 的 query 函数来进行 query
  17.                 qCursor = unstableProvider.query(mPackageName, uri, projection,
  18.                         queryArgs, remoteCancellationSignal);
  19.             } catch (DeadObjectException e) {
  20.                 
  21.  
  22.             //...
  23.             return wrapper;
  24.         } catch (RemoteException e) {
  25.             return null;
  26.         } finally {
  27.             ...
  28.         }
  29.     }

通过 acquireUnstableProvider 方法拿到 ContentProvider 的本地代理对象，我们先来看下注释 1 的  acquireUnstableProvider 方法怎么拿到 ContentProvider 本地代理对象，代码如下：

  1.    //ContentResolver.java 
  2.    public final IContentProvider acquireUnstableProvider(Uri uri) {
  3.         if (!SCHEME_CONTENT.equals(uri.getScheme())) {
  4.             return null;
  5.         }
  6.         String auth = uri.getAuthority();
  7.         if (auth != null) {
  8.           	//调用内部抽象方法
  9.             return acquireUnstableProvider(mContext, uri.getAuthority());
  10.         }
  11.         return null;
  12.     }
  13.  
  14.     /** @hide */
  15.     protected abstract IContentProvider acquireUnstableProvider(Context c, String name);
  1. //ContextImpl.java
  2.         @Override
  3.         protected IContentProvider acquireUnstableProvider(Context c, String auth) {
  4.             return mMainThread.acquireProvider(c,
  5.                     ContentProvider.getAuthorityWithoutUserId(auth),
  6.                     resolveUserIdFromAuthority(auth), false);
  7.         }

return 返回的对象，首先拿到 mMainThread 对象，然后调用它内部的 acquireProvider 方法

  1. //ActivityThread.java
  2.  
  3.     public final IContentProvider acquireProvider(
  4.             Context c, String auth, int userId, boolean stable) {
  5.         1. acquireExistingProvider 方法主要检查 ActivityThread 全局变量 mProviderMap 中是否有目标 ContentProvider 存在，有就返回，没有就通过注释 2 处获取，
  6.         final IContentProvider provider = acquireExistingProvider(c, auth, userId, stable);
  7.         if (provider != null) {
  8.             return provider;
  9.         }
  10.  
  11.  
  12.         ContentProviderHolder holder = null;
  13.         try {
  14.             2. 调用 IAcitivityManager 获取 ContentProviderHolder 对象
  15.             holder = ActivityManager.getService().getContentProvider(
  16.                     getApplicationThread(), auth, userId, stable);
  17.         } catch (RemoteException ex) {
  18.             throw ex.rethrowFromSystemServer();
  19.         }
  20.       
  21. 			...
  22.  
  23.         3. 用来安装 ContentProvider
  24.         holder = installProvider(c, holder, holder.info,
  25.                 true /*noisy*/, holder.noReleaseNeeded, stable);
  26.         return holder.provider;
  27.     }
  28.

总结

1 处的 acquireExistingProvider 方法内部会检查 ActivityThread 的全局变量 mProviderMap 中是否有 ContentProvider 存在

2 处 的 IActivityManager 的 getContentProvider 方法与 AMS 进行通信来获取

 3 是安装 ContentProvider,并将 ContentProvider 相关数据存储在 mProviderMap 中，起到缓存作用

我们现在来看下AMS 的 getContentProvider 方法具体实现，代码如下:

  1. //AMS.java
  2.     @Override
  3.     public final ContentProviderHolder getContentProvider(
  4.             IApplicationThread caller, String name, int userId, boolean stable) {
  5.         enforceNotIsolatedCaller("getContentProvider");
  6.        ...
  7.         //调动内部 getContentProviderImpl 方法
  8.         return getContentProviderImpl(caller, name, null, stable, userId);
  9.     }
  1. //AMS.java
  2.  
  3.  
  4.     private ContentProviderHolder getContentProviderImpl(IApplicationThread caller,
  5.             String name, IBinder token, boolean stable, int userId) {
  6.         ContentProviderRecord cpr;
  7.         ContentProviderConnection conn = null;
  8.         ProviderInfo cpi = null;
  9.  
  10.         ..1. 获取目标 ContentProvider  应用程序进程的信息，如果进程已经启动就调用注释 2 ，否则调用注释 3 
  11.                         ProcessRecord proc = getProcessRecordLocked(
  12.                                 cpi.processName, cpr.appInfo.uid, false);
  13.                         if (proc != null && proc.thread != null && !proc.killed) {
  14.                             if (DEBUG_PROVIDER) Slog.d(TAG_PROVIDER,
  15.                                     "Installing in existing process " + proc);
  16.                             if (!proc.pubProviders.containsKey(cpi.name)) {
  17.                                 checkTime(startTime, "getContentProviderImpl: scheduling install");
  18.                                 proc.pubProviders.put(cpi.name, cpr);
  19.                                 try {
  20.                                  2. 调用 IApplicationThreadscheduleInstallProvider 函数
  21.                                     proc.thread.scheduleInstallProvider(cpi);
  22.                                 } catch (RemoteException e) {
  23.                                 }
  24.                             }
  25.                         } else {
  26.                             checkTime(startTime, "getContentProviderImpl: before start process");
  27.                             3. 启动新进程
  28.                             proc = startProcessLocked(cpi.processName,
  29.                                     cpr.appInfo, false, 0, "content provider",
  30.                                     new ComponentName(cpi.applicationInfo.packageName,
  31.                                             cpi.name), false, false, false);
  32.                             checkTime(startTime, "getContentProviderImpl: after start process");
  33.                             if (proc == null) {
  34.                                 Slog.w(TAG, "Unable to launch app "
  35.                                         + cpi.applicationInfo.packageName + "/"
  36.                                         + cpi.applicationInfo.uid + " for provider "
  37.                                         + name + ": process is bad");
  38.                                 return null;
  39.                             }
  40.                         }
  41.                         cpr.launchingApp = proc;
  42.                         mLaunchingProviders.add(cpr);
  43.                     } finally {
  44.                         Binder.restoreCallingIdentity(origId);
  45.                     }
  46.                 }
  47.  
  48.               ....
  49.     }

2 位置执行流程，首先调用 ActivityThread 的内部类 IApplication 的scheduleInstallProvider 函数，然后通过 H sendMessage 通知进行安装 ContentProvider

看3位置处我们直接看 ActivityThread main 函数，代码如下

  1. //AMS.java
  2.  
  3.  
  4.     final ProcessRecord startProcessLocked(String processName,
  5.             ApplicationInfo info, boolean knownToBeDead, int intentFlags,
  6.             String hostingType, ComponentName hostingName, boolean allowWhileBooting,
  7.             boolean isolated, boolean keepIfLarge) {
  8.         return startProcessLocked(processName, info, knownToBeDead, intentFlags, hostingType,
  9.                 hostingName, allowWhileBooting, isolated, 0 /* isolatedUid */, keepIfLarge,
  10.                 null /* ABI override */, null /* entryPoint */, null /* entryPointArgs */,
  11.                 null /* crashHandler */);
  12.     }

我们直接看 ActivityThread main 函数，代码如下

  1. //ActivityThread.java
  2.  
  3.  
  4.     //通过反射调用执行的
  5.     public static void main(String[] args) {
  6. 				....
  7.         //主线程消息循环
  8.         Looper.prepareMainLooper();
  9.         //创建 ActivityThread 对象
  10.         ActivityThread thread = new ActivityThread();
  11.         //Application,Activity 入口
  12.         thread.attach(false);
  13.  
  14.         if (sMainThreadHandler == null) {
  15.             sMainThreadHandler = thread.getHandler();
  16.         }
  17.  
  18.         if (false) {
  19.             Looper.myLooper().setMessageLogging(new
  20.                     LogPrinter(Log.DEBUG, "ActivityThread"));
  21.         }
  22.  
  23.         // End of event ActivityThreadMain.
  24.         Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  25.         Looper.loop();
  26.  
  27.         throw new RuntimeException("Main thread loop unexpectedly exited");
  28.     }

主要看 ActivityThread attach 函数具体实现，代码如下:

  1. //ActivityThread.java
  2.     private void attach(boolean system) {
  3.      ...
  4.      
  5.      final IActivityManager mgr = ActivityManager.getService();
  6.      try {
  7.           关联 Application
  8.           mgr.attachApplication(mAppThread);
  9.      } catch (RemoteException ex) {
  10.       throw ex.rethrowFromSystemServer();
  11.      }
  12.      ...
  13.       
  14.     }

从上得到 AMS 的代理类 IActivityManager ，在注释 调用 AMS 的 attachApplication 函数，并将 IApplicationThread 对象传入 AMS 保持应用进程和 AMS 跨进程通信，应用程序调用 AMS 的过程就分析完了，下面我们分析 AMS 到应用程序进程的 ContentProvider 安装过程

AMS 启动 ContentProvider 的过程

先看流程图

 

  1. //AMS.java
  2.  
  3. private final boolean attachApplicationLocked(IApplicationThread thread,
  4.             int pid) {
  5.   ...
  6.   
  7.    thread.bindApplication(processName, appInfo, providers,
  8.                         app.instr.mClass,
  9.                         profilerInfo, app.instr.mArguments,
  10.                         app.instr.mWatcher,
  11.                         app.instr.mUiAutomationConnection, testMode,
  12.                         mBinderTransactionTrackingEnabled, enableTrackAllocation,
  13.                         isRestrictedBackupMode || !normalMode, app.persistent,
  14.                         new Configuration(getGlobalConfiguration()), app.compat,
  15.                         getCommonServicesLocked(app.isolated),
  16.                         mCoreSettingsObserver.getCoreSettingsLocked(),
  17.                         buildSerial);
  18.     
  19.     
  20.   ...
  21. }

在 attachApplicationLocked 函数中调用了 thread.bindApplication 方法，thread 是 IApplicationThread ，这里和 IActivityManager 一样采用了 aidl 进行进程间传输数据，我们回到 ActivityThread 内部类 ApplicationThread 的 bindApplication 方法

  1. //ActivityThread.java
  2.  
  3.         public final void bindApplication(String processName, ApplicationInfo appInfo,
  4.                 List<ProviderInfo> providers, ComponentName instrumentationName,
  5.                 ProfilerInfo profilerInfo, Bundle instrumentationArgs,
  6.                 IInstrumentationWatcher instrumentationWatcher,
  7.                 IUiAutomationConnection instrumentationUiConnection, int debugMode,
  8.                 boolean enableBinderTracking, boolean trackAllocation,
  9.                 boolean isRestrictedBackupMode, boolean persistent, Configuration config,
  10.                 CompatibilityInfo compatInfo, Map services, Bundle coreSettings,
  11.                 String buildSerial) {
  12.  
  13.             if (services != null) {
  14.                 // Setup the service cache in the ServiceManager
  15.                 ServiceManager.initServiceCache(services);
  16.             }
  17.  
  18.             setCoreSettings(coreSettings);
  19.  
  20.             AppBindData data = new AppBindData();
  21.             data.processName = processName;
  22.             data.appInfo = appInfo;
  23.             data.providers = providers;
  24.             data.instrumentationName = instrumentationName;
  25.             data.instrumentationArgs = instrumentationArgs;
  26.             data.instrumentationWatcher = instrumentationWatcher;
  27.             data.instrumentationUiAutomationConnection = instrumentationUiConnection;
  28.             data.debugMode = debugMode;
  29.             data.enableBinderTracking = enableBinderTracking;
  30.             data.trackAllocation = trackAllocation;
  31.             data.restrictedBackupMode = isRestrictedBackupMode;
  32.             data.persistent = persistent;
  33.             data.config = config;
  34.             data.compatInfo = compatInfo;
  35.             data.initProfilerInfo = profilerInfo;
  36.             data.buildSerial = buildSerial;
  37.           	//发送消息给 H 类
  38.             sendMessage(H.BIND_APPLICATION, data);
  39.         }

ActivityThread 内部类 H 收到消息，开始处理 BIND_APPLICSTION消息，代码如下:

  1. //ActivityThread.java
  2. ...
  3.   public void handleMessage(Message msg) {
  4.   ...
  5.    case BIND_APPLICATION:
  6.     AppBindData data = (AppBindData)msg.obj;
  7.     handleBindApplication(data);
  8.                     
  9.     break;    
  10.   ...
  11. }
  12. ...
  1. //ActivityThread.java
  2. ...
  3.   public void handleMessage(Message msg) {
  4.   ...
  5.    case BIND_APPLICATION:
  6.     AppBindData data = (AppBindData)msg.obj;
  7.     handleBindApplication(data);
  8.                     
  9.     break;    
  10.   ...
  11. }
  12. ...
  1. //ActivityThread.java
  2.  
  3. private void handleBindApplication(AppBindData data) {
  4.   ...
  5.     
  6.         1. 创建 ContentImpl
  7.         final ContextImpl appContext = ContextImpl.createAppContext(this, data.info);
  8.   
  9.   ...
  10.     
  11.             2 通过反射创建 Instrumentation 
  12.                 final ClassLoader cl = instrContext.getClassLoader();
  13.                 mInstrumentation = (Instrumentation)
  14.                     cl.loadClass(data.instrumentationName.getClassName()).newInstance();
  15.             } catch (Exception e) {
  16.                ...
  17.             }
  18.  
  19.             final ComponentName component = new ComponentName(ii.packageName, ii.name);
  20.             3 处初始化 Instrumentaion
  21.             mInstrumentation.init(this, instrContext, appContext, component,
  22.                     data.instrumentationWatcher, data.instrumentationUiAutomationConnection);
  23.  
  24. ....
  25.   
  26.    try {
  27.  
  28.             创建 Application
  29.             Application app = data.info.makeApplication(data.restrictedBackupMode, null);
  30.             mInitialApplication = app;
  31.  
  32.  
  33.             if (!data.restrictedBackupMode) {
  34.                 if (!ArrayUtils.isEmpty(data.providers)) {
  35.                     5 ContentProvider 启动的
  36.                     installContentProviders(app, data.providers);
  37.                     mH.sendEmptyMessageDelayed(H.ENABLE_JIT, 10*1000);
  38.                 }
  39.             }
  40.  
  41.  
  42.             try {
  43.                 mInstrumentation.onCreate(data.instrumentationArgs);
  44.             }
  45.             catch (Exception e) {
  46.           ...
  47.             }
  48.  
  49.             try {
  50.                 6  调用 Application onCreate 生命周期方法
  51.                 mInstrumentation.callApplicationOnCreate(app);
  52.             } catch (Exception e) {
  53.                ...
  54.             }
  55. }

注释 5 看 ContentProvider 是如何启动的，代码如下：

  1. //ActivityThread.java
  2.  
  3.     private void installContentProviders(
  4.             Context context, List<ProviderInfo> providers) {
  5.         final ArrayList<ContentProviderHolder> results = new ArrayList<>();
  6.  
  7.       1 遍历当前应用程序进程的 ProviderInfo 列表，得到每个 ContentProvicer 的存储信息
  8.         for (ProviderInfo cpi : providers) {
  9.             if (DEBUG_PROVIDER) {
  10.                 StringBuilder buf = new StringBuilder(128);
  11.                 buf.append("Pub ");
  12.                 buf.append(cpi.authority);
  13.                 buf.append(": ");
  14.                 buf.append(cpi.name);
  15.                 Log.i(TAG, buf.toString());
  16.             }
  17.             2 调用 installProvider 方法来启动这些 ContentProvider
  18.             ContentProviderHolder cph = installProvider(context, null, cpi,
  19.                     false /*noisy*/, true /*noReleaseNeeded*/, true /*stable*/);
  20.             if (cph != null) {
  21.                 cph.noReleaseNeeded = true;
  22.                 results.add(cph);
  23.             }
  24.         }
  25.  
  26.         try {
  27.             3 处是将启动了的 ContentProvider 存入 AMS 的 mProviderMap 中 就是用来缓存启动过的 ContentProvidec
  28.             ActivityManager.getService().publishContentProviders(
  29.                 getApplicationThread(), results);
  30.         } catch (RemoteException ex) {
  31.             throw ex.rethrowFromSystemServer();
  32.         }
  33.     }

现在来看调用 installProvider 方法来启动这些 ContentProvider

  1. //ActivityThread.java
  2.  
  3.  private ContentProviderHolder installProvider(Context context,
  4.             ContentProviderHolder holder, ProviderInfo info,
  5.             boolean noisy, boolean noReleaseNeeded, boolean stable) {
  6.    
  7.    
  8.    ....
  9.        try {
  10.                 final java.lang.ClassLoader cl = c.getClassLoader();
  11.                 1 通过反射实例化 ContentProvider 对象
  12.                 localProvider = (ContentProvider)cl.
  13.                     loadClass(info.name).newInstance();
  14.                 provider = localProvider.getIContentProvider();
  15.          
  16.                 ...
  17.                
  18.                 2处调用它的 attachInfo 方法
  19.                 localProvider.attachInfo(c, info);
  20.             } catch (java.lang.Exception e) {
  21.                 if (!mInstrumentation.onException(null, e)) {
  22.                     throw new RuntimeException(
  23.                             "Unable to get provider " + info.name
  24.                             + ": " + e.toString(), e);
  25.                 }
  26.                 return null;
  27.             }
  28.    
  29.    ....
  30.      
  31.  }

在注释 2 处调用它的 attachInfo 方法，代码如下

  1. //ContentProvider.java
  2.     public void attachInfo(Context context, ProviderInfo info) {
  3.         attachInfo(context, info, false);
  4.     }
  5.  
  6.     private void attachInfo(Context context, ProviderInfo info, boolean testing) {
  7.         mNoPerms = testing;
  8.  
  9.  
  10.         if (mContext == null) {
  11.             mContext = context;
  12.             if (context != null) {
  13.                 mTransport.mAppOpsManager = (AppOpsManager) context.getSystemService(
  14.                         Context.APP_OPS_SERVICE);
  15.             }
  16.             mMyUid = Process.myUid();
  17.             if (info != null) {
  18.                 setReadPermission(info.readPermission);
  19.                 setWritePermission(info.writePermission);
  20.                 setPathPermissions(info.pathPermissions);
  21.                 mExported = info.exported;
  22.                 mSingleUser = (info.flags & ProviderInfo.FLAG_SINGLE_USER) != 0;
  23.                 setAuthorities(info.authority);
  24.             }
  25.             /**
  26.              * 安装成功，调用生命周期函数 onCreate
  27.              */
  28.             ContentProvider.this.onCreate();
  29.         }
  30.     }
  31.  
  32.     public abstract boolean onCreate();

可以看到最后在 ContentProvider 的 attachInfo 函数中进行调用了抽象方法 onCreate, 那么它的子类就会进行实现 onCreate 达到启动成功的通知。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/892109
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号