Android应用程序组件ContentProvider的共享数据更新通知机制分析
在Android系统中，应用程序组件ContentProvider为不同的应用程序实现数据共享提供了基础设施，它主要通过Binder进程间通信机制和匿名共享内存机制来实现的。关于数据共享的另一个话题便是数据更新通知机制了，即如果一个应用程序对共享数据做了修改，它应该如何通知其它正在使用这些共享数据的应用程序呢？本文将分析ContentProvider的共享数据更新通知机制，为读者解答这个问题。
Android应用程序组件ContentProvider中的数据更新通知机制和Android系统中的广播（Broadcast）通知机制的实现思路是相似的。在Android的广播机制中，首先是接收者对自己感兴趣的广播进行注册，接着当发送者发出这些广播时，接收者就会得到通知了。更多关于Android系统的广播机制的知识，可以参考前面这一系列文章。然而，ContentProvider中的数据监控机制与Android系统中的广播机制又有三个主要的区别，一是前者是通过URI来把通知的发送者和接收者关联在一起的，而后者是通过Intent来关联的，二是前者的通知注册中心是由ContentService服务来扮演的，而后者是由ActivityManagerService服务来扮演的，三是前者负责接收数据更新通知的类必须要继承ContentObserver类，而后者要继承BroadcastReceiver类。之所以会有这些区别，是由于ContentProivder组件的数据共享功能本身就是建立在URI的基础之上的，因此专门针对URI来设计另外一套通知机制会更实用和方便，而Android系统的广播机制是一种更加通用的事件通知机制，它的适用范围会更广泛一些。
与分析Android系统的广播机制类似，我们把ContentProvider的数据更新机制划分为三个单元进行分析，第一个单元是ContentService的启动过程，第二个单元是监控数据变化的ContentObserver的注册过程，第二个单元是数据更新通知的发送过程。
与前面两篇文章和一样，本文仍然以这篇文章介绍的应用程序为例来分析ContentProvider的数据更新机制。
1.ContentService的启动过程分析
前面提到，在ContentProvider的数据更新通知机制中，ContentService扮演者ContentObserver的注册中心的角色，因此，它必须要系统启动的时候就启动起来，以便后面启动起来的应用程序可以使用它。在前面这篇文章中，我们提到，Android系统进程Zygote在启动的时候，在启动一个System进程来加载系统的一些关键服务，而ContentService就这些关键服务之一了。在System进程中，负责加载系统关键服务的类为SystemServer类，它定义在frameworks/base/services/Java/com/android/server/SystemServer.java文件中，它会通过启动一个线程SystemThread来加载这些关键服务：
[java]viewplaincopy在CODE上查看代码片派生到我的代码片
classServerThreadextendsThread{
......
@Override
publicvoidrun(){
......
Looper.prepare();
//Criticalservices...
try{
......
ContentService.main(context,
factoryTest==SystemServer.FACTORY_TEST_LOW_LEVEL);
......
}catch(RuntimeExceptione){
......
}
......
Looper.loop();
......
}
}
ContentService类定义在frameworks/base/core/java/android/content/ContentService.java文件中，它的main函数的实现如下所示：
[java]viewplaincopy在CODE上查看代码片派生到我的代码片
publicfinalclassContentServiceextendsIContentService.Stub{
......
publicstaticIContentServicemain(Contextcontext,booleanfactoryTest){
ContentServiceservice=newContentService(context,factoryTest);
ServiceManager.addService(ContentResolver.CONTENT_SERVICE_NAME,service);
returnservice;
}
......
}
从这里我们就可以看到，在ContentService类的main函数中，会创建一个ContentService实例，然后把它添加到ServiceManager中去，这样，ContentService服务就启动起来了，其它地方可以通过ServiceManager来获得它的一个远程接口来使用它提供的服务。
2.ContentObserver的注册过程分析
在前面这篇文章介绍的应用程序Acticle中，主窗口MainActivity在创建的时候，会调用应用程序上下文的ContentResolver接口来注册一个自定义的ContentObserver来监控ArticlesProvider这个ContentProvider中的数据变化：
[java]viewplaincopy在CODE上查看代码片派生到我的代码片
publicclassMainActivityextendsActivityimplementsView.OnClickListener,AdapterView.OnItemClickListener{
......
privateArticleAdapteradapter=null;
privateArticleObserverobserver=null;
......
@Override
publicvoidonCreate(BundlesavedInstanceState){
super.onCreate(savedInstanceState);
......
observer=newArticleObserver(newHandler());
getContentResolver().registerContentObserver(Articles.CONTENT_URI,true,observer);
......
}
privateclassArticleObserverextendsContentObserver{
publicArticleObserver(Handlerhandler){
super(handler);
}
@Override
publicvoidonChange(booleanselfChange){
adapter.notifyDataSetChanged();
}
}
......
}
从ContentObserver继承下来的子类必须要实现onChange函数。当这个ContentObserver子类负责监控的数据发生变化时，ContentService就会调用它的onChange函数来处理，参数selfChange表示这个变化是否是由自己引起的，在我们这个情景中，不需要关注这个参数的值。在这个应用程序中，ArticleObserver继承了ContentObserver类，它负责监控的URI是Articles.CONTENT_URI，它的值为"content://shy.luo.providers.articles/item"，这个值是在这篇文章介绍的应用程序ActiclesProvider中的Articles.java文件中定义的。当所有以Articles.CONTENT_URI为前缀的URI对应的数据发生改变时，ContentService都会调用这个ArticleObserver类的onChange函数来处理。在ArticleObserver类的onChange函数中，执行的操作就是重新获取ActiclesProvider中的数据来更新界面上的文章信息列表。
在ArticleObserver类的构造函数中，有一个参数handler，它的类型为Handler，它是从MainActivity类的onCreate函数中创建并传过来的。通过前面这篇文章的学习，我们知道，这个handler是用来分发和处理消息用的。由于MainActivity类的onCreate函数是在应用程序的主线程中被调用的，因此，这个handler参数就是和应用程序主线程的消息循环关联在一起的。在后面我们分析数据更新通知的发送过程时，便会看到这个handler参数是如何使用的了。
下面我们就开始分析注册ArticleObserver来监控ActiclesProvider中的数据变化的过程，首先来看一下这个过程的时序图，然后再详细分析每一个步骤：
这个函数定义在frameworks/base/core/java/android/content/ContentResolver.java文件中：
[java]viewplaincopy在CODE上查看代码片派生到我的代码片
publicabstractclassContentResolver{
......
publicfinalvoidregisterContentObserver(Uriuri,booleannotifyForDescendents,
ContentObserverobserver)
{
try{
getContentService().registerContentObserver(uri,notifyForDescendents,
observer.getContentObserver());
}catch(RemoteExceptione){
}
}
......
}
当参数notifyForDescendents为true时，表示要监控所有以uri为前缀的URI对应的数据变化。这个函数做了三件事情，一是调用getContentService函数来获得前面已经启动起来了的ContentService远程接口，二是调用从参数传进来的ContentObserver对象observer的getContentObserver函数来获得一个Binder对象，三是通过调用这个ContentService远程接口的registerContentObserver函数来把这个Binder对象注册到ContentService中去。
Step2.ContentResolver.getContentService
这个函数定义在frameworks/base/core/java/android/content/ContentResolver.java文件中：
[java]viewplaincopy在CODE上查看代码片派生到我的代码片
publicabstractclassContentResolver{
......
publicstaticIContentServicegetContentService(){
if(sContentService!=null){
returnsContentService;
}
IBinderb=ServiceManager.getService(CONTENT_SERVICE_NAME);
......
sContentService=IContentService.Stub.asInterface(b);
......
returnsContentService;
}
privatestaticIContentServicesContentService;
......
}
在ContentResolver类中，有一个静态成员变量sContentService，开始时它的值为null。当ContentResolver类的getContentService函数第一次被调用时，它便会通过ServiceManager类的getService函数来获得前面已经启动起来了的ContentService服务的远程接口，然后把它保存在sContentService变量中。这样，当下次ContentResolver类的getContentService函数再次被调用时，就可以直接把这个ContentService远程接口返回给调用者了。
Step3.ContentObserver.getContentObserver
这个函数定义在frameworks/base/core/java/android/database/ContentObserver.java文件中：
[java]viewplaincopy在CODE上查看代码片派生到我的代码片
publicabstractclassContentObserver{
......
privateTransportmTransport;
......
privatestaticfinalclassTransportextendsIContentObserver.Stub{
ContentObservermContentObserver;
publicTransport(ContentObservercontentObserver){
mContentObserver=contentObserver;
}
......
}
......
publicIContentObservergetContentObserver(){
synchronized(lock){
if(mTransport==null){
mTransport=newTransport(this);
}
returnmTransport;
}
}
......
}
ContentObserver类的getContentObserver函数返回的是一个成员变量mTransport，它的类型为ContentObserver的内部类Transport。从Transport类的定义我们可以知道，它有一个成员变量mContentObserver，用来保存与对应的ContentObserver对象。同时我们还可以看出，ContentObserver类的成员变量mTransport是一个Binder对象，它是要传递给ContentService服务的，以便当ContentObserver所监控的数据发生变化时，ContentService服务可以通过这个Binder对象通知相应的ContentObserver它监控的数据发生变化了。
Step4.ContentService.registerContentObserver
这个函数定义在frameworks/base/core/java/android/content/ContentService.java文件中：
[java]viewplaincopy在CODE上查看代码片派生到我的代码片
publicfinalclassContentServiceextendsIContentService.Stub{
......
privatefinalObserverNodemRootNode=newObserverNode("");
......
publicvoidregisterContentObserver(Uriuri,booleannotifyForDescendents,
IContentObserverobserver){
......
synchronized(mRootNode){
mRootNode.addObserverLocked(uri,observer,notifyForDescendents,mRootNode);
......
}
}
......
}
它调用了ContentService类的成员变量mRootNode的addObserverLocked函数来注册这个ContentObserver对象observer。成员变量mRootNode的类型为ContentService在内部定义的一个类ObserverNode。
Step5.ObserverNode.addObserverLocked
这个函数定义在frameworks/base/core/java/android/content/ContentService.java文件中：
[java]viewplaincopy在CODE上查看代码片派生到我的代码片
publicfinalclassContentServiceextendsIContentService.Stub{
......
publicstaticfinalclassObserverNode{
......
privateStringmName;
privateArrayListmChildren=newArrayList();
privateArrayListmObservers=newArrayList();
publicObserverNode(Stringname){
mName=name;
}
privateStringgetUriSegment(Uriuri,intindex){
if(uri!=null){
if(index==0){
returnuri.getAuthority();
}else{
returnuri.getPathSegments().get(index-1);
}
}else{
returnnull;
}
}
privateintcountUriSegments(Uriuri){
if(uri==null){
return0;
}
returnuri.getPathSegments().size()+1;
}
publicvoidaddObserverLocked(Uriuri,IContentObserverobserver,
booleannotifyForDescendents,ObjectobserversLock){
addObserverLocked(uri,0,observer,notifyForDescendents,observersLock);
}
privatevoidaddObserverLocked(Uriuri,intindex,IContentObserverobserver,
booleannotifyForDescendents,ObjectobserversLock){
//Ifthisistheleafnodeaddtheobserver
if(index==countUriSegments(uri)){
mObservers.add(newObserverEntry(observer,notifyForDescendents,observersLock));
return;
}
//Looktoseeiftheproperchildalreadyexists
Stringsegment=getUriSegment(uri,index);
if(segment==null){
thrownewIllegalArgumentException("InvalidUri("+uri+")usedforobserver");
}
intN=mChildren.size();
for(inti=0;i
ObserverNodenode=mChildren.get(i);
if(node.mName.equals(segment)){
node.addObserverLocked(uri,index+1,observer,notifyForDescendents,observersLock);
return;
}
}
//Nochildfound,createone
ObserverNodenode=newObserverNode(segment);
mChildren.add(node);
node.addObserverLocked(uri,index+1,observer,notifyForDescendents,observersLock);
}
......
}
......
}
从这里我们就可以看出，注册到ContentService中的ContentObserver按照树形来组织，树的节点类型为ObserverNode，而树的根节点就为ContentService类的成员变量mRootNode。每一个ObserverNode节点都对应一个名字，它是从URI中解析出来的。
在我们这个情景中，传进来的uri为"content://shy.luo.providers.articles/item"，从Step3调用mRootNode的addObserverLocked函数来往树上增加一个ObserverNode节点时，传进来的参数index的值为0，而调用countUriSegments("content://shy.luo.providers.articles/item")函数的返回值为2，不等于index的值，因此就会往下执行，而通过调用getUriSegment("content://shy.luo.providers.articles/item",0)函数得到的返回值为"shy.luo.providers.articles"。假设这里是第一次调用树的根节点mRootNode来增加"content://shy.luo.providers.articles/item"这个URI，那么在接下来的for循环中，就不会在mRootNode的孩子节点列表mChildren中找到与名称"shy.luo.providers.articles"对应的ObserverNode，于是就会以"shy.luo.providers.articles"为名称来创建一个新的ObserverNode，并增加到mRootNode的孩子节点列表mChildren中去，并以这个新的ObserverNode来开始新一轮的addObserverLocked函数调用。
第二次进入到addObserverLocked函数时，countUriSegments("content://shy.luo.providers.articles/item")的值仍为2，而index的值为1，因此就会往下执行，这时候通过调用getUriSegment("content://shy.luo.providers.articles/item",1)函数得到的返回值为"item"。假设这时候在以"shy.luo.providers.articles/item"为名称的ObserverNode中不存在名称为"item"的孩子节点，于是又会以"item"为名称来创建一个新的ObserverNode，并以这个新的ObserverNode来开始新一轮的addObserverLocked函数调用。
第三次进入到addObserverLocked函数时，countUriSegments("content://shy.luo.providers.articles/item")的值仍为2，而index的值也为2，因此就会新建一个ObserverEntry对象，并保存在这个以"item"为名称的ObserverNode的ContentObserver列表mObervers中。
最终我们得到的树形结构如下所示：
mRootNode("")
--ObserverNode("shy.luo.providers.articles")
--ObserverNode("item"),whichhasaContentObserverinmObservers
这样，ContentObserver的注册过程就完成了。
3.数据更新通知的发送过程
在前面这篇文章介绍的应用程序Acticle中，当调用ArticlesAdapter类的insertArticle往ArticlesProvider中增加一个文章信息条目时：
[java]viewplaincopy在CODE上查看代码片派生到我的代码片
publicclassArticlesAdapter{
......
publiclonginsertArticle(Articlearticle){
ContentValuesvalues=newContentValues();
values.put(Articles.TITLE,article.getTitle());
values.put(Articles.ABSTRACT,article.getAbstract());
values.put(Articles.URL,article.getUrl());
Uriuri=resolver.insert(Articles.CONTENT_URI,values);
StringitemId=uri.getPathSegments().get(1);
returnInteger.valueOf(itemId).longValue();
}
......
}
便会进入到应用程序ArticlesProvider中的ArticlesProvider类的insert函数中：
[java]viewplaincopy在CODE上查看代码片派生到我的代码片
publicclassArticlesProviderextendsContentProvider{
......
@Override
publicUriinsert(Uriuri,ContentValuesvalues){
if(uriMatcher.match(uri)!=Articles.ITEM){
thrownewIllegalArgumentException("ErrorUri:"+uri);
}
SQLiteDatabasedb=dbHelper.getWritableDatabase();
longid=db.insert(DB_TABLE,Articles.ID,values);
if(id<0){
thrownewSQLiteException("Unabletoinsert"+values+"for"+uri);
}
UrinewUri=ContentUris.withAppendedId(uri,id);
resolver.notifyChange(newUri,null);
returnnewUri;
}
......
}
从上面传来的参数uri的值为"content://shy.luo.providers.articles/item"。假设当这个函数把数据成功增加到SQLite数据库之后，返回来的id值为n，于是通过调用ContentUris.withAppendedId("content://shy.luo.providers.articles/item",n)得到的newUri的值就为"content://shy.luo.providers.articles/item/n"。这时候就会调用下面语句来通知那些注册了监控"content://shy.luo.providers.articles/item/n"这个URI的ContentObserver，它监控的数据发生变化了：
[java]viewplaincopy在CODE上查看代码片派生到我的代码片
resolver.notifyChange(newUri,null);
下面我们就开始分析这个数据变化通知的发送过程，首先来看一下这个过程的时序图，然后再详细分析每一个步骤：
这个函数定义在frameworks/base/core/java/android/content/ContentResolver.java文件中：
[java]viewplaincopy在CODE上查看代码片派生到我的代码片
publicabstractclassContentResolver{
......
publicvoidnotifyChange(Uriuri,ContentObserverobserver){
notifyChange(uri,observer,true/synctonetwork/);
}
publicvoidnotifyChange(Uriuri,ContentObserverobserver,booleansyncToNetwork){
try{
getContentService().notifyChange(
uri,observer==null?null:observer.getContentObserver(),
observer!=null&&observer.deliverSelfNotifications(),syncToNetwork);
}catch(RemoteExceptione){
}
}
......
}
这里调用了ContentService的远接程口来调用它的notifyChange函数来发送数据更新通知。
Step2.ContentService.notifyChange
这个函数定义在frameworks/base/core/java/android/content/ContentService.java文件中：
[java]viewplaincopy在CODE上查看代码片派生到我的代码片
publicfinalclassContentServiceextendsIContentService.Stub{
......
publicvoidnotifyChange(Uriuri,IContentObserverobserver,
booleanobserverWantsSelfNotifications,booleansyncToNetwork){
......
try{
ArrayListcalls=newArrayList();
synchronized(mRootNode){
mRootNode.collectObserversLocked(uri,0,observer,observerWantsSelfNotifications,
calls);
}
finalintnumCalls=calls.size();
for(inti=0;i
ObserverCalloc=calls.get(i);
try{
oc.mObserver.onChange(oc.mSelfNotify);
......
}catch(RemoteExceptionex){
......
}
}
......
}finally{
......
}
}
......
}
这个函数主要做了两件事情，第一件事情是调用ContentService的成员变量mRootNode的collectObserverLocked函数来收集那些注册了监控"content://shy.luo.providers.articles/item/n"这个URI的ContentObserver，第二件事情是分别调用了这些ContentObserver的onChange函数来通知它们监控的数据发生变化了。
Step3.ObserverNode.collectObserversLocked
这个函数定义在frameworks/base/core/java/android/content/ContentService.java文件中：
[java]viewplaincopy在CODE上查看代码片派生到我的代码片
publicfinalclassContentServiceextendsIContentService.Stub{
......
publicstaticfinalclassObserverNode{
......
privatevoidcollectMyObserversLocked(booleanleaf,IContentObserverobserver,
booleanselfNotify,ArrayListcalls){
intN=mObservers.size();
IBinderobserverBinder=observer==null?null:observer.asBinder();
for(inti=0;i
ObserverEntryentry=mObservers.get(i);
//Don''tnotifytheobserverifitsentthenotificationandisn''tinteresed
//inselfnotwww.sm136.comifications
if(entry.observer.asBinder()==observerBinder&&!selfNotify){
continue;
}
//Makesuretheobserverisinterestedinthenotification
if(leaf||(!leaf&&entry.notifyForDescendents)){
calls.add(newObserverCall(this,entry.observer,selfNotify));
}
}
}
publicvoidcollectObserversLocked(Uriuri,intindex,IContentObserverobserver,
booleanselfNotify,ArrayListcalls){
Stringsegment=null;
intsegmentCount=countUriSegments(uri);
if(index>=segmentCount){
//Thisistheleafnode,notifyallobservers
collectMyObserversLocked(true,observer,selfNotify,calls);
}elseif(index
segment=getUriSegment(uri,index);
//Notifyanyobserversatthislevelwhoareinterestedindescendents
collectMyObserversLocked(false,observer,selfNotify,calls);
}
intN=mChildren.size();
for(inti=0;i
ObserverNodenode=mChildren.get(i);
if(segment==null||node.mName.equals(segment)){
//Wefoundthechild,
node.collectObserversLocked(uri,index+1,observer,selfNotify,calls);
if(segment!=null){
break;
}
}
}
}
}
}
第一次调用collectObserversLocked时，是在mRootNode的这个ObserverNode节点中进行收集ContentObserver的。这时候传进来的uri的值为"content://shy.luo.providers.articles/item/n"，index的值为0。调用countUriSegments("content://shy.luo.providers.articles/item/n")函数得到的返回值为3，于是就会调用下面语句：
[java]viewplaincopy在CODE上查看代码片派生到我的代码片
segment=getUriSegment("content://shy.luo.providers.articles/item/n",0);
//Notifyanyobserversatthislevelwhoareinterestedindescendents
collectMyObserversLocked(false,observer,selfNotify,calls);
这里得到的segment为"shy.luo.providers.articles"。在我们这个情景中，假设mRootNode这个节点中没有注册ContentObserver，于是调用collectMyObserversLocked函数就不会收集到ContentObserver。
在接下来的for循环中，在mRootNode的孩子节点列表mChildren中查找名称等于"shy.luo.providers.articles"的OberverNode节点。在上面分析ContentObserver的注册过程时，我们已经往mRootNode的孩子节点列表mChildren中增加了一个名称为"shy.luo.providers.articles"的OberverNode节点，因此，这里会成功找到它，并且调用它的collectObserversLocked函数来继续收集ContentObserver。
第二次进入到collectObserversLocked函数时，是在名称为"shy.luo.providers.articles"的OberverNode节点中收集ContentObserver的。这时候传来的uri值不变，但是index的值为1，于是执行下面语句：
[java]viewplaincopy在CODE上查看代码片派生到我的代码片
segment=getUriSegment("content://shy.luo.providers.articles/item/n",1);
//Notifyanyobserversatthislevelwhoareinterestedindescendents
collectMyObserversLocked(false,observer,selfNotify,calls);
这里得到的segment为"item"。在我们这个情景中，我们没有在名称为"shy.luo.providers.articles"的OberverNode节点中注册有ContentObserver，因此这里调用collectMyObserversLocked函数也不会收集到ContentObserver。
在接下来的for循环中，在名称为"shy.luo.providers.articles"的ObserverNode节点的孩子节点列表mChildren中查找名称等于"item"的OberverNode节点。在上面分析ContentObserver的注册过程时，我们已经往名称为"shy.luo.providers.articles"的ObserverNode节点的孩子节点列表mChildren中增加了一个名称为"item"的OberverNode节点，因此，这里会成功找到它，并且调用它的collectObserversLocked函数来继续收集ContentObserver。
第三次进入到collectObserversLocked函数时，是在名称为"shy.luo.providers.articles"的OberverNode节点的子节点中名称为"item"的ObserverNode节点中收集ContentObserver的。这时候传来的uri值不变，但是index的值为2，于是执行下面语句：
[java]viewplaincopy在CODE上查看代码片派生到我的代码片
segment=getUriSegment("content://shy.luo.providers.articles/item/n",2);
//Notifyanyobserversatthislevelwhoareinterestedindescendents
collectMyObserversLocked(false,observer,selfNotify,calls);
这里得到的segment为"n"。前面我们已经在名称为"shy.luo.providers.articles"的OberverNode节点的子节点中名称为"item"的ObserverNode节点中注册了一个ContentObserver，即ArticlesObserver，因此这里调用collectMyObserversLocked函数会收集到这个ContentObserver。注意，这次调用collectMyObserversLocked函数时，虽然传进去的参数leaf为false，但是由于我们注册ArticlesObserver时，指定了notifyForDescendents参数为true，因此，这里可以把它收集回来。
在接下来的for循环中，继续在该节点的子节点列表mChildren中查找名称等于"n"的OberverNode节点。在我们这个情景中，不存在这个名称为"n"的子节点了，于是收集ContentObserver的工作就结束了，收集结果是只有一个ContentObserver，即我们在前面注册的ArticlesObserver。
返回到Step2中，调用下面语句来通知相应的ContentObserver，它们监控的数据发生变化了：
[java]viewplaincopy在CODE上查看代码片派生到我的代码片
for(inti=0;i
ObserverCalloc=calls.get(i);
try{
oc.mObserver.onChange(oc.mSelfNotify);
......
}catch(RemoteExceptionex){
......
}
}
前面我们在分析ContentObserver的注册过程的Step3时，介绍到注册到ContentService服务中的ContentObserver是一个在ContentObserver内部定义的一个类Transport的对象的远程接口，于是这里调用这个接口的onChange函数时，就会进入到ContentObserver的内部类Transport的onChange函数中去。
Step4.Transport.onChange
这个函数定义在frameworks/base/core/java/android/database/ContentObserver.java文件中：
[java]viewplaincopy在CODE上查看代码片派生到我的代码片
publicabstractclassContentObserver{
......
privatestaticfinalclassTransportextendsIContentObserver.Stub{
ContentObservermContentObserver;
......
publicvoidonChange(booleanselfChange){
ContentObservercontentObserver=mContentObserver;
if(contentObserver!=null){
contentObserver.dispatchChange(selfChange);
}
}
......
}
......
}
前面我们在分析ContentObserver的注册过程的Step3时，把ArticlesObserver这个ContentObserver保存在了这个Transport对象的mContentObserver成员变量中，因此，会调用它的dispatchChange函数来执行数据更新通知的操作。
Step5.ContentObserver.dispatchChange
这个函数定义在frameworks/base/core/java/android/database/ContentObserver.java文件中：
[java]viewplaincopy在CODE上查看代码片派生到我的代码片
publicabstractclassContentObserver{
......
publicfinalvoiddispatchChange(booleanselfChange){
if(mHandler==null){
onChange(selfChange);
}else{
mHandler.post(newNotificationRunnable(selfChange));
}
}
}
在前面分析ArticlesObserver的注册过程时，我们以应用程序Article的主线程的消息循环创建了一个Handler，并且以这个Handler来创建了这个ArticlesObserver，这个Handler就保存在ArticlesObserver的父类ContentObserver的成员变量mHandler中。因此，这里的mHandler不为null，于是把这个数据更新通知封装成了一个消息，放到应用程序Article的主线程中去处理，最终这个消息是由NotificationRunnable类的run函数来处理的。
Step6.NotificationRunnable.run
这个函数定义在frameworks/base/core/java/android/database/ContentObserver.java文件中：
[java]viewplaincopy在CODE上查看代码片派生到我的代码片
publicabstractclassContentObserver{
......
privatefinalclassNotificationRunnableimplementsRunnable{
privatebooleanmSelf;
publicNotificationRunnable(booleanself){
mSelf=self;
}
publicvoidrun(){
ContentObserver.this.onChange(mSelf);
}
}
......
}
这个函数就直接调用ContentObserver的子类的onChange函数来处理这个数据更新通知了。在我们这个情景中，这个ContentObserver子类便是ArticlesObserver了。
Step7.ArticlesObserver.onChange
这个函数定义在前面一篇文章介绍的应用程序Artilce源代码工程目录下，在文件为packages/experimental/Article/src/shy/luo/article/MainActivity.java中：
[java]viewplaincopy在CODE上查看代码片派生到我的代码片
publicclassMainActivityextendsActivityimplementsView.OnClickListener,AdapterView.OnItemClickListener{
......
privateclassArticleObserverextendsContentObserver{
......
@Override
publicvoidonChange(booleanselfChange){
adapter.notifyDataSetChanged();
}
}
......
}
这里它要执行的操作便是更新界面上的ListView列表中的文章信息了，以便反映ArticlesProvider中的最新数据。这样，Android应用程序组件ContentProvider的共享数据更新通知机制就分析完了。
|
|
