为了账号安全,请及时绑定邮箱和手机立即绑定

Android系统源码分析之-ContentProvider

2019.02.28 20:33 718浏览

距离上一次写博客已经半年多了,这半年发生了很多事情,也有了很多感触,最主要是改变了忙碌了工作,更加重视身体的健康,为此也把工作地点从深圳这个一线城市换到了珠海,工作相对没有那么累,身体感觉也好了很多。所以在工作完成之余,也有了更多的时间来自我学习和提高,后续会用更多时间来写更多实用的东西,帮助我们理解安卓系统的原理,帮助我们快速、稳定的开发。
这一篇我们接着之前的计划,完成四大组件的最后一个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

先看时序图:

webp

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


点击查看更多内容
0人点赞

若觉得本文不错,就分享一下吧!

评论

相关文章推荐

正在加载中
意见反馈 帮助中心 APP下载
官方微信

举报

0/150
提交
取消