深入理解ContentProvider共享数据更新通知机制

快来打我* 2022-01-25 15:16 225阅读 0赞

前面一篇文章 深入理解Android四大组件之一ContentProvider 讲了ContentProvider的简单使用和它的启动过程.  
这里接着讲解一下关于ContentProvider共享数据更新通知机制.  
数据更新通知是很有必要的,比如我们在第二个应用程序中添加了一个联系人(接着上一篇文章例子),返回到显示主界面时,我们不会去更新列表数据,所以就没有刚刚添加的联系人信息,这样数据不同步,影响客户体验.不单单是第二个程序不会察觉到数据库里数据已经更新了,其他的客户端程序,这些程序都是共享第一个应用程序的数据的,也不会察觉到.因此,在第一个应用程序里面,我们需要做一件事,就是当本地数据库的数据更新时,就通知其他对该数据库数据感兴趣的客户端程序,好让它们及时更新数据.

Android应用程序组件ContentProvider中的数据更新通知机制和Android系统中的广播（Broadcast）通知机制的实现思路是相似的。在Android的广播机制中，首先是接收者对自己感兴趣的广播进行注册，接着当发送者发出这些广播时，接收者就会得到通知了。然而，ContentProvider中的数据监控机制与Android系统中的广播机制又有三个主要的区别，一是前者是通过URI来把通知的发送者和接收者关联在一起的，而后者是通过Intent来关联的，二是前者的通知注册中心是由ContentService服务来扮演的，而后者是由ActivityManagerService服务来扮演的，三是前者负责接收数据更新通知的类必须要继承ContentObserver类，而后者要继承BroadcastReceiver类。之所以会有这些区别，是由于ContentProivder组件的数据共享功能本身就是建立在URI的基础之上的，因此专门针对URI来设计另外一套通知机制会更实用和方便，而Android系统的广播机制是一种更加通用的事件通知机制，它的适用范围会更广泛一些。

这里我们把ContentProvider的数据更新机制划分为三个单元进行分析，第一个单元是ContentService的启动过程，第二个单元是监控数据变化的ContentObserver的注册过程，第二个单元是数据更新通知的发送过程。

1,ContentService在系统启动的时候就启动起来了，以便后面启动起来的应用程序可以使用它.关于ContentService的启动过程这里没分析了.

2.ContentObserver的注册过程分析

resolver.registerContentObserver(Uri.parse("content://com.cj.mycontentprovider/contact"),  
true,new MyContentObserver(new Handler()));

在第二个应用程序中 通过调用ContentResolver对象的registerContentObserver()方法 来注册一个自定义的ContentObserver(MyContentObserver)来监控MyContentProvider这个Content Provider中的数据变化.

private class MyContentObserver extends ContentObserver\{  
  
/\*\*  
\* Creates a content observer.  
\*  
\* @param handler The handler to run \{@link \#onChange\} on, or null if none.  
\*/  
public MyContentObserver(Handler handler) \{  
super(handler);  
\}  
  
@Override  
public void onChange(boolean selfChange) \{  
myAdapter.notifyDataSetChanged();  
  
\}  
\}

从ContentObserver继承下来的子类必须要实现onChange函数。当这个ContentObserver子类负责监控的数据发生变化时，ContentService就会调用它的onChange函数来处理，参数selfChange表示这个变化是否是由自己引起的。在这个应用程序中，MyContentObserver继承了ContentObserver类，它负责监控的URI是"content://com.cj.mycontentprovider/contact".当以这个URI为前缀的URI对应的数据发生改变时，ContentService都会调用这个MyContentObserver类的onChange函数来处理。在MyContentObserver类的onChange函数中，执行的操作就是重新获取MyContentProvider中的数据来更新界面上的联系人信息列表。

在MyContentObserver类的构造函数中，有一个参数handler，它的类型为Handler，它是从MainActivity类的onCreate函数中创建并传过来的。这个handler是用来分发和处理消息用的。由于MainActivity类的onCreate函数是在应用程序的主线程中被调用的，因此，这个handler参数就是和应用程序主线程的消息循环关联在一起的。在后面我们分析数据更新通知的发送过程时，便会看到这个handler参数是如何使用的了。

下面我们就开始分析注册MyContentObserver来监控MyContentProvider中的数据变化的过程.

第一步.ContentResolver.registerContentObserver()

在frameworks/base/core/java/android/content/ContentResolver.java文件中：

public final void registerContentObserver(Uri uri, boolean notifyForDescendents,  
ContentObserver observer)  
\{  
registerContentObserver(uri, notifyForDescendents, observer, UserHandle.myUserId());  
\}  
  
/\*\* @hide - designated user version \*/  
public final void registerContentObserver(Uri uri, boolean notifyForDescendents,  
ContentObserver observer, int userHandle)  
\{  
try \{  
getContentService().registerContentObserver(uri, notifyForDescendents,  
observer.getContentObserver(), userHandle);  
\} catch (RemoteException e) \{  
\}  
\}

当参数notifyForDescendents为true时，表示要监控所有以uri为前缀的URI对应的数据变化。上面函数做了三件事情，一是调用getContentService函数来获得前面已经启动起来了的ContentService服务，二是调用从参数传进来的ContentObserver对象observer的getContentObserver函数来获得一个Binder对象，三是通过调用这个ContentService远程接口的registerContentObserver函数来把这个Binder对象注册到ContentService中去。

第二步. ContentResolver.getContentService()

在frameworks/base/core/java/android/content/ContentResolver.java文件中：

public static IContentService getContentService() \{  
if (sContentService != null) \{  
return sContentService;  
\}  
IBinder b = ServiceManager.getService(CONTENT\_SERVICE\_NAME);  
...  
sContentService = IContentService.Stub.asInterface(b);  
..  
return sContentService;  
\}

在ContentResolver类中，有一个静态成员变量sContentService，开始时它的值为null。当ContentResolver类的getContentService函数第一次被调用时，它便会通过ServiceManager类的getService函数来获得前面已经启动起来了的ContentService服务的远程接口，然后把它保存在sContentService变量中。这样，当下次ContentResolver类的getContentService函数再次被调用时，就可以直接把这个ContentService远程接口返回给调用者了。

第三步. ContentResolver.getContentObserver()

在frameworks/base/core/java/android/database/ContentObserver.java文件中：

public abstract class ContentObserver \{  
private final Object mLock = new Object();  
private Transport mTransport; // guarded by mLock  
Handler mHandler;  
/\*\*  
\* Creates a content observer.  
\*  
\* @param handler The handler to run \{@link \#onChange\} on, or null if none.  
\*/  
public ContentObserver(Handler handler) \{  
mHandler = handler;  
\}  
/\*\*  
\* Gets access to the binder transport object. Not for public consumption.  
\*  
\* \{@hide\}  
\*/  
public IContentObserver getContentObserver() \{  
synchronized (mLock) \{  
if (mTransport == null) \{  
mTransport = new Transport(this);  
\}  
return mTransport;  
\}  
\}  
/\*\*

ContentObserver类的getContentObserver函数返回的是一个成员变量mTransport，它的类型为ContentObserver的内部类Transport。ContentObserver类的成员变量mTransport是一个Binder对象，它是要传递给ContentService服务的，以便当ContentObserver所监控的数据发生变化时，ContentService服务可以通过这个Binder对象通知相应的ContentObserver它监控的数据发生变化了。

第四步. ContentService.registerContentObserver()

在frameworks/base/core/java/android/content/ContentService.java文件中：

public void registerContentObserver(Uri uri, boolean notifyForDescendants,  
IContentObserver observer, int userHandle) \{  
.....  
synchronized (mRootNode) \{  
mRootNode.addObserverLocked(uri, observer, notifyForDescendants, mRootNode,  
Binder.getCallingUid(), Binder.getCallingPid(), userHandle);  
...  
\}  
\}

它调用了ContentService类的成员变量mRootNode的addObserverLocked函数来注册这个ContentObserver对象observer。成员变量mRootNode的类型为ContentService在内部定义的一个类ObserverNode。

第五步. ObserverNode.addObserverLocked()

在frameworks/base/core/java/android/content/ContentService.java文件中：

public void addObserverLocked(Uri uri, IContentObserver observer,  
boolean notifyForDescendants, Object observersLock,  
int uid, int pid, int userHandle) \{  
addObserverLocked(uri, 0, observer, notifyForDescendants, observersLock,  
uid, pid, userHandle);  
\}  
  
private void addObserverLocked(Uri uri, int index, IContentObserver observer,  
boolean notifyForDescendants, Object observersLock,  
int uid, int pid, int userHandle) \{  
// If this is the leaf node add the observer  
if (index == countUriSegments(uri)) \{//这里的index 上一步传进来的是0  
mObservers.add(new ObserverEntry(observer, notifyForDescendants, observersLock,  
uid, pid, userHandle));  
return;  
\}  
  
// Look to see if the proper child already exists  
String segment = getUriSegment(uri, index);  
  
int N = mChildren.size();  
for (int i = 0; i < N; i++) \{  
ObserverNode node = mChildren.get(i);  
if (node.mName.equals(segment)) \{  
node.addObserverLocked(uri, index + 1, observer, notifyForDescendants,  
observersLock, uid, pid, userHandle);  
return;  
\}  
\}  
  
// No child found, create one  
ObserverNode node = new ObserverNode(segment);  
mChildren.add(node);  
node.addObserverLocked(uri, index + 1, observer, notifyForDescendants,  
observersLock, uid, pid, userHandle);  
\}

从这里我们就可以看出，注册到ContentService中的ContentObserver按照树形来组织，树的节点类型为ObserverNode，而树的根节点就为ContentService类的成员变量mRootNode。  
private final ObserverNode mRootNode = new ObserverNode("");  
每一个ObserverNode节点都对应一个名字，它是从URI中解析出来的。

在我们这个情景中，传进来的uri为"content://com.cj.mycontentprovider/contact"，从第五步第一个用mRootNode的addObserverLocked()函数来往树上增加一个ObserverNode节点时，传进来的参数index的值为0，而调用countUriSegments("content://com.cj.mycontentprovider/contact")函数的返回值为2，不等于index的值.这里看一下countUriSegments()函数:

private int countUriSegments(Uri uri) \{  
if (uri == null) \{  
return 0;  
\}  
return uri.getPathSegments().size() + 1;  
\}

\--getPathSegments得到uri的path部分，并拆分，去掉"/"，取到第一个元素(从第0个开始)。这里只有contact一个元素 .

因此就会往下执行，而通过调用getUriSegment("content://com.cj.mycontentprovider/contact", 0)函数得到的返回值为"com.cj.mycontentprovider"。

private String getUriSegment(Uri uri, int index) \{  
if (uri != null) \{  
if (index == 0) \{  
return uri.getAuthority();  
\} else \{  
return uri.getPathSegments().get(index - 1);  
\}  
\} else \{  
return null;  
\}  
\}

假设这里是第一次调用树的根节点mRootNode来增加"content://com.cj.mycontentprovider/contact"这个URI，那么在接下来的for循环中，就不会在mRootNode的孩子节点列表mChildren中找到与名称"com.cj.mycontentprovider"对应的ObserverNode，于是就会以"com.cj.mycontentprovider"为名称来创建一个新的ObserverNode，并增加到mRootNode的孩子节点列表mChildren中去，并以这个新的ObserverNode来开始新一轮的addObserverLocked()函数调用。

第二次进入到addObserverLocked()函数时，countUriSegments("content://com.cj.mycontentprovider/contact")的值仍为2(参考前面函数)，而index的值为1，因此就会往下执行，这时候通过调用getUriSegment("content://shy.luo.providers.articles/item", 1)函数得到的返回值为"contact"。这里不存在名称为"contact"的孩子节点，于是又会以"contact"为名称来创建一个新的ObserverNode，并以这个新的ObserverNode来开始新一轮的addObserverLocked函数调用。

第三次进入到addObserverLocked()函数时，countUriSegments("content://com.cj.mycontentprovider/contact")的值仍为2，而index的值也为2，因此就会新建一个ObserverEntry对象，并保存在这个以"contact"为名称的ObserverNode的ContentObserver列表mObervers中。

最终我们得到的树形结构如下所示：

mRootNode("")

\-- ObserverNode("com.cj.mycontentprovider")

\--ObserverNode("contact") , which has a ContentObserver in mObservers  
这样，ContentObserver的注册过程就完成了。

2. 数据更新通知的发送过程  
在第二个应用程序中，在添加联系人的界面田添加一个联系人时：

ContentValues contentValues = new ContentValues();  
contentValues.put("name",name);  
contentValues.put("number",num);  
getContentResolver().insert(Uri.parse("content://com.cj.mycontentprovider/contact"),contentValues);

便会进入到第一个应用程序的MyContentProvider类的insert函数中：

public Uri insert(Uri uri, ContentValues values) \{  
Uri u = null;  
if(uriMatcher.match(uri) == CONTACT)\{  
SQLiteDatabase database = dbHelp.getWritableDatabase();  
  
long d = database.insert("contact", "\_id", values);  
u = ContentUris.withAppendedId(uri,d);  
contentResolver.notifyChange(u,null);  
\}  
return u;  
  
\}

从上面传来的参数uri的值为"content://com.cj.mycontentprovider/contact"。假设当这个函数把数据成功增加到SQLite数据库之后，返回来的id值为d，于是通过调用ContentUris.withAppendedId(uri,d);得到的newUri的值就为"content://com.cj.mycontentprovider/contact/d"。这时候就会调用下面语句来通知那些注册了监控"content://com.cj.mycontentprovider/contact/d"这个URI的ContentObserver，它监控的数据发生变化了：  
contentResolver.notifyChange(u,null);  
下面就根据源码来分析这个数据变化通知的发送过程：  
第一步:ContentResolver.notifyChange()  
在frameworks/base/core/java/android/content/ContentResolver.java文件中：

public void notifyChange(Uri uri, ContentObserver observer) \{  
notifyChange(uri, observer, true /\* sync to network \*/);  
\}  
public void notifyChange(Uri uri, ContentObserver observer, boolean syncToNetwork) \{  
notifyChange(uri, observer, syncToNetwork, UserHandle.getCallingUserId());  
\}  
  
/\*\*  
\* Notify registered observers within the designated user(s) that a row was updated.  
\*  
\* @hide  
\*/  
public void notifyChange(Uri uri, ContentObserver observer, boolean syncToNetwork,  
int userHandle) \{  
try \{  
getContentService().notifyChange(  
uri, observer == null ? null : observer.getContentObserver(),  
observer != null && observer.deliverSelfNotifications(), syncToNetwork,  
userHandle);  
\} catch (RemoteException e) \{  
\}  
\}

这里调用了ContentService的远接程口来调用它的notifyChange()函数来发送数据更新通知。

第二步: ContentService.notifyChange()

在frameworks/base/core/java/android/content/ContentService.java文件中

public void notifyChange(Uri uri, IContentObserver observer,  
boolean observerWantsSelfNotifications, boolean syncToNetwork,  
int userHandle) \{  
...  
// This makes it so that future permission checks will be in the context of this  
// process rather than the caller's process. We will restore this before returning.  
  
try \{  
ArrayList<ObserverCall> calls = new ArrayList<ObserverCall>();  
synchronized (mRootNode) \{  
mRootNode.collectObserversLocked(uri, 0, observer, observerWantsSelfNotifications,  
userHandle, calls);  
\}  
final int numCalls = calls.size();  
for (int i=0; i<numCalls; i++) \{  
ObserverCall oc = calls.get(i);  
try \{  
oc.mObserver.onChange(oc.mSelfChange, uri);  
..  
\} catch (RemoteException ex) \{  
..  
\}  
\}  
if (syncToNetwork) \{  
SyncManager syncManager = getSyncManager();  
if (syncManager != null) \{  
syncManager.scheduleLocalSync(null /\* all accounts \*/, callingUserHandle,  
uri.getAuthority());  
\}  
\}  
\} finally \{  
restoreCallingIdentity(identityToken);  
\}  
\}

这个函数主要做了两件事情，第一件事情是调用ContentService的成员变量mRootNode的collectObserverLocked()函数来收集那些注册了监控"content://com.cj.mycontentprovider/contact/d"这个URI的ContentObserver，第二件事情是分别调用了这些ContentObserver的onChange()函数来通知它们监控的数据发生变化了。

第三步: ObserverNode.collectObserversLocked()

在frameworks/base/core/java/android/content/ContentService.java文件中：

public void collectObserversLocked(Uri uri, int index, IContentObserver observer,  
boolean observerWantsSelfNotifications, int targetUserHandle,  
ArrayList<ObserverCall> calls) \{  
String segment = null;  
int segmentCount = countUriSegments(uri);  
if (index >= segmentCount) \{  
// This is the leaf node, notify all observers  
collectMyObserversLocked(true, observer, observerWantsSelfNotifications,  
targetUserHandle, calls);  
\} else if (index < segmentCount)\{  
segment = getUriSegment(uri, index);  
// Notify any observers at this level who are interested in descendants  
collectMyObserversLocked(false, observer, observerWantsSelfNotifications,  
targetUserHandle, calls);  
\}  
  
int N = mChildren.size();  
for (int i = 0; i < N; i++) \{  
ObserverNode node = mChildren.get(i);  
if (segment == null || node.mName.equals(segment)) \{  
// We found the child,  
node.collectObserversLocked(uri, index + 1,  
observer, observerWantsSelfNotifications, targetUserHandle, calls);  
if (segment != null) \{  
break;  
\}  
\}  
\}  
\}

private void collectMyObserversLocked(boolean leaf, IContentObserver observer,  
boolean observerWantsSelfNotifications, int targetUserHandle,  
ArrayList<ObserverCall> calls) \{  
int N = mObservers.size();  
IBinder observerBinder = observer == null ? null : observer.asBinder();  
for (int i = 0; i < N; i++) \{  
ObserverEntry entry = mObservers.get(i);  
  
// Don't notify the observer if it sent the notification and isn't interested  
// in self notifications  
boolean selfChange = (entry.observer.asBinder() == observerBinder);  
if (selfChange && !observerWantsSelfNotifications) \{  
continue;  
\}  
  
// Does this observer match the target user?  
if (targetUserHandle == UserHandle.USER\_ALL  
|| entry.userHandle == UserHandle.USER\_ALL  
|| targetUserHandle == entry.userHandle) \{  
// Make sure the observer is interested in the notification  
if (leaf || (!leaf && entry.notifyForDescendants)) \{  
calls.add(new ObserverCall(this, entry.observer, selfChange));  
\}  
\}  
\}  
\}

第一次调用collectObserversLocked()时，是在mRootNode的这个ObserverNode节点中进行收集ContentObserver的。这时候传进来的uri的值为"content://com.cj.mycontentprovider/contact/d"，index的值为0。调用countUriSegments("content://shy.luo.providers.articles/item/n")函数得到的返回值为3(参考前面就知道是3 2+1=3)，于是就会调用下面语句：

segment = getUriSegment(uri, 0);  
// Notify any observers at this level who are interested in descendants  
collectMyObserversLocked(false, observer, observerWantsSelfNotifications,  
targetUserHandle, calls);

这里得到的segment为"com.cj.mycontentprovider"。在我们这个情景中，mRootNode这个节点中没有注册ContentObserver，于是调用collectMyObserversLocked()函数就不会收集到ContentObserver。

在接下来的for循环中，在mRootNode的孩子节点列表mChildren中查找名称等于"com.cj.mycontentprovider"的OberverNode节点。在上面分析ContentObserver的注册过程时，我们已经往mRootNode的孩子节点列表mChildren中增加了一个名称为"com.cj.mycontentprovider"的OberverNode节点，因此，这里会成功找到它，并且调用它的collectObserversLocked()函数来继续收集ContentObserver。

第二次进入到collectObserversLocked()函数时，是在名称为"com.cj.mycontentprovider"的OberverNode节点中收集ContentObserver的。这时候传来的uri值不变，但是index的值为1，于是执行下面语句：

segment = getUriSegment(uri, 1);  
// Notify any observers at this level who are interested in descendants  
collectMyObserversLocked(false, observer, observerWantsSelfNotifications,  
targetUserHandle, calls);

</pre><pre name="code" class="java" style="font-size: 14px;">

这里得到的segment为"contact"。在我们这个情景中，我们没有在名称为"com.cj.mycontentprovider"的OberverNode节点中注册有ContentObserver，因此这里调用collectMyObserversLocked()函数也不会收集到ContentObserver。

在接下来的for循环中，在名称为"com.cj.mycontentprovider"的ObserverNode节点的孩子节点列表mChildren中查找名称等于"contact"的OberverNode节点。在上面分析ContentObserver的注册过程时，我们已经往名称为"com.cj.mycontentprovider"的ObserverNode节点的孩子节点列表mChildren中增加了一个名称为"contact"的OberverNode节点，因此，这里会成功找到它，并且调用它的collectObserversLocked()函数来继续收集ContentObserver。

第三次进入到collectObserversLocked()函数时，是在名称为"com.cj.mycontentprovider"的OberverNode节点的子节点中名称为"contact"的ObserverNode节点中收集ContentObserver的。这时候传来的uri值不变，但是index的值为2，于是执行下面语句：

segment = getUriSegment(uri, 2);  
// Notify any observers at this level who are interested in descendants  
collectMyObserversLocked(false, observer, observerWantsSelfNotifications,  
targetUserHandle, calls);

这里得到的segment为"d"。前面我们已经在名称为"com.cj.mycontentprovider"的OberverNode节点的子节点中名称为"contact"的ObserverNode节点中注册了一个ContentObserver，即MyContentObserver，因此这里调用collectMyObserversLocked()函数会收集到这个ContentObserver。注意，这次调用collectMyObserversLocked()函数时，虽然传进去的参数leaf为false，但是由于我们注册MyContentObserver时，指定了notifyForDescendents参数为true，因此，这里可以把它收集回来。  
在接下来的for循环中，继续在该节点的子节点列表mChildren中查找名称等于"d"的OberverNode节点。在我们这个情景中，不存在这个名称为"d"的子节点了，于是收集ContentObserver的工作就结束了，收集结果是只有一个ContentObserver，即我们在前面注册的MyContentObserver。

返回到第二步中，调用下面语句来通知相应的ContentObserver，它们监控的数据发生变化了：

for (int i=0; i<numCalls; i++) \{  
ObserverCall oc = calls.get(i);  
try \{  
oc.mObserver.onChange(oc.mSelfChange, uri);  
\} catch (RemoteException ex) \{  
  
\}  
\}

前面我们在分析ContentObserver的注册过程的第三步时，介绍到注册到ContentService服务中的mObserver是一个在ContentObserver内部定义的一个类Transport的对象的远程接口，于是这里调用这个接口的onChange()函数时，就会进入到ContentObserver的内部类Transport的onChange()函数中去。

第四步: Transport.onChange()

在frameworks/base/core/java/android/database/ContentObserver.java文件中：

private static final class Transport extends IContentObserver.Stub \{  
private ContentObserver mContentObserver;  
  
public Transport(ContentObserver contentObserver) \{  
mContentObserver = contentObserver;  
\}  
  
@Override  
public void onChange(boolean selfChange, Uri uri) \{  
ContentObserver contentObserver = mContentObserver;  
if (contentObserver != null) \{  
contentObserver.dispatchChange(selfChange, uri);  
\}  
\}  
  
public void releaseContentObserver() \{  
mContentObserver = null;  
\}  
\}

前面我们在分析ContentObserver的注册过程的第三步时，把MyContentObserver这个ContentObserver保存在了这个Transport对象的mContentObserver成员变量中，因此，会调用它的dispatchChange()函数来执行数据更新通知的操作。

第五步:. ContentObserver.dispatchChange()

在frameworks/base/core/java/android/database/ContentObserver.java文件中：

public final void dispatchChange(boolean selfChange, Uri uri) \{  
if (mHandler == null) \{  
onChange(selfChange, uri);  
\} else \{  
mHandler.post(new NotificationRunnable(selfChange, uri));  
\}  
\}

在前面分析MyContentObserver的注册过程时，我们以第二个应用程序的主线程的消息循环创建了一个Handler，并且以这个Handler来创建了这个MyContentObserver，这个Handler就保存在MyContentObserver的父类ContentObserver的成员变量mHandler中。因此，这里的mHandler不为null，于是把这个数据更新通知封装成了一个消息，放到第二个应用程序的主线程中去处理，最终这个消息是由NotificationRunnable类的run()函数来处理的。

第六步:. NotificationRunnable.run()

在frameworks/base/core/java/android/database/ContentObserver.java文件中：

private final class NotificationRunnable implements Runnable \{  
private final boolean mSelfChange;  
private final Uri mUri;  
  
public NotificationRunnable(boolean selfChange, Uri uri) \{  
mSelfChange = selfChange;  
mUri = uri;  
\}  
  
@Override  
public void run() \{  
ContentObserver.this.onChange(mSelfChange, mUri);  
\}  
\}

这个函数就直接调用ContentObserver的子类的onChange函数来处理这个数据更新通知了。在我们这个情景中，这个ContentObserver子类便是MyContentObserver了。  
这里它要执行的操作便是更新界面上的ListView列表中的联系人信息了。  
以上就是ContentProvider的共享数据更新通知机制的运行过程.  
\---------------------  
作者：hehe26  
来源：CSDN  
原文：https://blog.csdn.net/hehe26/article/details/51871610  
\-------------------------------------------------------------以上为转载内容----------------------------------------------------------------

\----------------------------------------------------------------以下为自己的总结内容---------------------------------------------------

1.注册ContentObsever，ContentObsever的构造方法ContentObserver(Handler handler)

，ContentResolver\#registerContentObserver()

/**
         * Register an observer class that gets callbacks when data identified by a
         * given content URI changes.
         * <p>
         * Starting in {@link android.os.Build.VERSION_CODES#O}, all content
         * notifications must be backed by a valid {@link ContentProvider}.
         *
         * @param uri The URI to watch for changes. This can be a specific row URI,
         *            or a base URI for a whole class of content.
         * @param notifyForDescendants When false, the observer will be notified
         *            whenever a change occurs to the exact URI specified by
         *            <code>uri</code> or to one of the URI's ancestors in the path
         *            hierarchy. When true, the observer will also be notified
         *            whenever a change occurs to the URI's descendants in the path
         *            hierarchy.
         * @param observer The object that receives callbacks when changes occur.
         * @see #unregisterContentObserver
         */
    //notifyForDescendants:为false,uri的父URI有变时,也要需要通知该observer；为true，uri的子URI有变时，也需要通知该observer。
        public final void registerContentObserver(@NonNull Uri uri, boolean notifyForDescendants,
                @NonNull ContentObserver observer)

2.通过ContentResolver.getContentService()获取IContentService，从ContentObserver获取IContentObserver，把IContentObserver和URI注册到ContentService。

3在对URI对应的内容增删改后，通过ContentResover\# notifyChange(@NonNull Uri uri, @Nullable ContentObserver observer)

public Uri insert(Uri uri, ContentValues values) {  
            Uri u = null;  
            if(uriMatcher.match(uri) == CONTACT){  
                SQLiteDatabase database = dbHelp.getWritableDatabase();  
      
                long d = database.insert("contact", "_id", values);  
                u = ContentUris.withAppendedId(uri,d);  
                contentResolver.notifyChange(u,null);  
            }  
            return u;  
      
        }

4.ContentService调用IContentObserver\#onChange(boolean selfChange, Uri uri, int userId)，IContentObserver\#onChange调用contentObserver.dispatchChange。

contentObserver.dispatchChange(): (Handler为null时在binder线程调用onChange，否则去到handler的looper所在线程执行)

private void dispatchChange(boolean selfChange, Uri uri, int userId) {
            if (mHandler == null) {
                onChange(selfChange, uri, userId);
            } else {
                mHandler.post(new NotificationRunnable(selfChange, uri, userId));
            }
        }