Android应用程序组件Content Provider的共享数据更新通知机制分析
最后更新于:2022-04-02 05:06:16
原文出处——>[Android应用程序组件Content Provider的共享数据更新通知机制分析](http://blog.csdn.net/luoshengyang/article/details/6985171)
在Android系统中,应用程序组件Content Provider为不同的应用程序实现数据共享提供了基础设施,它主要通过Binder进程间通信机制和匿名共享内存机制来实现的。关于数据共享的另一个话题便是数据更新通知机制了,即如果一个应用程序对共享数据做了修改,它应该如何通知其它正在使用这些共享数据的应用程序呢?本文将分析Content Provider的共享数据更新通知机制,为读者解答这个问题。
Android应用程序组件Content Provider中的数据更新通知机制和Android系统中的广播(Broadcast)通知机制的实现思路是相似的。在Android的广播机制中,首先是接收者对自己感兴趣的广播进行注册,接着当发送者发出这些广播时,接收者就会得到通知了。更多关于Android系统的广播机制的知识,可以参考前面Android系统中的广播(Broadcast)机制简要介绍和学习计划这一系列文章。然而,Content Provider中的数据监控机制与Android系统中的广播机制又有三个主要的区别,一是前者是通过URI来把通知的发送者和接收者关联在一起的,而后者是通过Intent来关联的,二是前者的通知注册中心是由ContentService服务来扮演的,而后者是由ActivityManagerService服务来扮演的,三是前者负责接收数据更新通知的类必须要继承ContentObserver类,而后者要继承BroadcastReceiver类。之所以会有这些区别,是由于Content Proivder组件的数据共享功能本身就是建立在URI的基础之上的,因此专门针对URI来设计另外一套通知机制会更实用和方便,而Android系统的广播机制是一种更加通用的事件通知机制,它的适用范围会更广泛一些。
与分析Android系统的广播机制类似,我们把Content Provider的数据更新机制划分为三个单元进行分析,第一个单元是ContentService的启动过程,第二个单元是监控数据变化的ContentObserver的注册过程,第二个单元是数据更新通知的发送过程。
与前面两篇文章Android应用程序组件Content Provider的启动过程源代码分析和Android应用程序组件Content Provider在应用程序之间共享数据的原理分析一样,本文仍然以Android应用程序组件Content Provider应用实例这篇文章介绍的应用程序为例来分析Content Provider的数据更新机制。
1. ContentService的启动过程分析
前面提到,在Content Provider的数据更新通知机制中,ContentService扮演者ContentObserver的注册中心的角色,因此,它必须要系统启动的时候就启动起来,以便后面启动起来的应用程序可以使用它。在前面这篇文章Android系统进程Zygote启动过程的源代码分析中,我们提到,Android系统进程Zygote在启动的时候,在启动一个System进程来加载系统的一些关键服务,而ContentService就这些关键服务之一了。在System进程中,负责加载系统关键服务的类为SystemServer类,它定义在frameworks/base/services/java/com/android/server/SystemServer.java文件中,它会通过启动一个线程SystemThread来加载这些关键服务:
~~~
class ServerThread extends Thread {
......
@Override
public void run() {
......
Looper.prepare();
// Critical services...
try {
......
ContentService.main(context,
factoryTest == SystemServer.FACTORY_TEST_LOW_LEVEL);
......
}catch (RuntimeException e) {
......
}
......
Looper.loop();
......
}
}
~~~
ContentService类定义在frameworks/base/core/java/android/content/ContentService.java文件中,它的main函数的实现如下所示:
~~~
public final class ContentService extends IContentService.Stub {
......
public static IContentService main(Context context, boolean factoryTest) {
ContentService service = new ContentService(context, factoryTest);
ServiceManager.addService(ContentResolver.CONTENT_SERVICE_NAME, service);
return service;
}
......
}
~~~
从这里我们就可以看到,在ContentService类的main函数中,会创建一个ContentService实例,然后把它添加到ServiceManager中去,这样,ContentService服务就启动起来了, 其它地方可以通过ServiceManager来获得它的一个远程接口来使用它提供的服务。
2. ContentObserver的注册过程分析
在前面这篇文章Android应用程序组件Content Provider应用实例介绍的应用程序Acticle中,主窗口MainActivity在创建的时候,会调用应用程序上下文的ContentResolver接口来注册一个自定义的ContentObserver来监控ArticlesProvider这个Content Provider中的数据变化:
~~~
public class MainActivity extends Activity implements View.OnClickListener, AdapterView.OnItemClickListener {
......
private ArticleAdapter adapter = null;
private ArticleObserver observer = null;
......
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
......
observer = new ArticleObserver(new Handler());
getContentResolver().registerContentObserver(Articles.CONTENT_URI, true, observer);
......
}
private class ArticleObserver extends ContentObserver {
public ArticleObserver(Handler handler) {
super(handler);
}
@Override
public void onChange (boolean selfChange) {
adapter.notifyDataSetChanged();
}
}
......
}
~~~
从ContentObserver继承下来的子类必须要实现onChange函数。当这个ContentObserver子类负责监控的数据发生变化时,ContentService就会调用它的onChange函数来处理,参数selfChange表示这个变化是否是由自己引起的,在我们这个情景中,不需要关注这个参数的值。在这个应用程序中,ArticleObserver继承了ContentObserver类,它负责监控的URI是Articles.CONTENT_URI,它的值为"content://shy.luo.providers.articles/item" ,这个值是在这篇文章Android应用程序组件Content Provider应用实例介绍的应用程序ActiclesProvider中的Articles.java文件中定义的。当所有以Articles.CONTENT_URI为前缀的URI对应的数据发生改变时,ContentService都会调用这个ArticleObserver类的onChange函数来处理。在ArticleObserver类的onChange函数中,执行的操作就是重新获取ActiclesProvider中的数据来更新界面上的文章信息列表。
在ArticleObserver类的构造函数中,有一个参数handler,它的类型为Handler,它是从MainActivity类的onCreate函数中创建并传过来的。通过前面这篇文章Android应用程序消息处理机制(Looper、Handler)分析的学习,我们知道,这个handler是用来分发和处理消息用的。由于MainActivity类的onCreate函数是在应用程序的主线程中被调用的,因此,这个handler参数就是和应用程序主线程的消息循环关联在一起的。在后面我们分析数据更新通知的发送过程时,便会看到这个handler参数是如何使用的了。
下面我们就开始分析注册ArticleObserver来监控ActiclesProvider中的数据变化的过程,首先来看一下这个过程的时序图,然后再详细分析每一个步骤:
![](http://hi.csdn.net/attachment/201111/18/0_1321641196aO8C.gif)
* **Step 1. ContentResolver.registerContentObserver**
这个函数定义在**frameworks/base/core/java/android/content/ContentResolver.java**文件中:
~~~
public abstract class ContentResolver {
......
public final void registerContentObserver(Uri uri, boolean notifyForDescendents,
ContentObserver observer)
{
try {
getContentService().registerContentObserver(uri, notifyForDescendents,
observer.getContentObserver());
} catch (RemoteException e) {
}
}
......
}
~~~
当参数notifyForDescendents为true时,表示要监控所有以uri为前缀的URI对应的数据变化。这个函数做了三件事情,一是调用getContentService函数来获得前面已经启动起来了的ContentService远程接口,二是调用从参数传进来的ContentObserver对象observer的getContentObserver函数来获得一个Binder对象,三是通过调用这个ContentService远程接口的registerContentObserver函数来把这个Binder对象注册到ContentService中去。
* **Step 2.ContentResolver.getContentService**
这个函数定义在**frameworks/base/core/java/android/content/ContentResolver.java**文件中:
~~~
public abstract class ContentResolver {
......
public static IContentService getContentService() {
if (sContentService != null) {
return sContentService;
}
IBinder b = ServiceManager.getService(CONTENT_SERVICE_NAME);
......
sContentService = IContentService.Stub.asInterface(b);
......
return sContentService;
}
private static IContentService sContentService;
......
}
~~~
在ContentResolver类中,有一个静态成员变量sContentService,开始时它的值为null。当ContentResolver类的getContentService函数第一次被调用时,它便会通过ServiceManager类的getService函数来获得前面已经启动起来了的ContentService服务的远程接口,然后把它保存在sContentService变量中。这样,当下次ContentResolver类的getContentService函数再次被调用时,就可以直接把这个ContentService远程接口返回给调用者了。
* **Step 3. ContentObserver.getContentObserver**
这个函数定义在**frameworks/base/core/java/android/database/ContentObserver.java**文件中:
~~~
public abstract class ContentObserver {
......
private Transport mTransport;
......
private static final class Transport extends IContentObserver.Stub {
ContentObserver mContentObserver;
public Transport(ContentObserver contentObserver) {
mContentObserver = contentObserver;
}
......
}
......
public IContentObserver getContentObserver() {
synchronized(lock) {
if (mTransport == null) {
mTransport = new Transport(this);
}
return mTransport;
}
}
......
}
~~~
ContentObserver类的getContentObserver函数返回的是一个成员变量mTransport,它的类型为ContentObserver的内部类Transport。从Transport类的定义我们可以知道,它有一个成员变量mContentObserver,用来保存与对应的ContentObserver对象。同时我们还可以看出,ContentObserver类的成员变量mTransport是一个Binder对象,它是要传递给ContentService服务的,以便当ContentObserver所监控的数据发生变化时,ContentService服务可以通过这个Binder对象通知相应的ContentObserver它监控的数据发生变化了。
* **Step 4. ContentService.registerContentObserver**
这个函数定义在**frameworks/base/core/java/android/content/ContentService.java**文件中:
~~~
public final class ContentService extends IContentService.Stub {
......
private final ObserverNode mRootNode = new ObserverNode("");
......
public void registerContentObserver(Uri uri, boolean notifyForDescendents,
IContentObserver observer) {
......
synchronized (mRootNode) {
mRootNode.addObserverLocked(uri, observer, notifyForDescendents, mRootNode);
......
}
}
......
}
~~~
它调用了ContentService类的成员变量mRootNode的addObserverLocked函数来注册这个ContentObserver对象observer。成员变量mRootNode的类型为ContentService在内部定义的一个类ObserverNode。
* **Step 5. ObserverNode.addObserverLocked**
这个函数定义在**frameworks/base/core/java/android/content/ContentService.java**文件中:
~~~
public final class ContentService extends IContentService.Stub {
......
public static final class ObserverNode {
......
private String mName;
private ArrayList mChildren = new ArrayList();
private ArrayList mObservers = new ArrayList();
public ObserverNode(String name) {
mName = name;
}
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;
}
}
private int countUriSegments(Uri uri) {
if (uri == null) {
return 0;
}
return uri.getPathSegments().size() + 1;
}
public void addObserverLocked(Uri uri, IContentObserver observer,
boolean notifyForDescendents, Object observersLock) {
addObserverLocked(uri, 0, observer, notifyForDescendents, observersLock);
}
private void addObserverLocked(Uri uri, int index, IContentObserver observer,
boolean notifyForDescendents, Object observersLock) {
// If this is the leaf node add the observer
if (index == countUriSegments(uri)) {
mObservers.add(new ObserverEntry(observer, notifyForDescendents, observersLock));
return;
}
// Look to see if the proper child already exists
String segment = getUriSegment(uri, index);
if (segment == null) {
throw new IllegalArgumentException("Invalid Uri (" + uri + ") used for observer");
}
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, notifyForDescendents, observersLock);
return;
}
}
// No child found, create one
ObserverNode node = new ObserverNode(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" ,从Step 3调用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") , which has a ContentObserver in mObservers
~~~
这样,ContentObserver的注册过程就完成了。
3. 数据更新通知的发送过程
在前面这篇文章Android应用程序组件Content Provider应用实例介绍的应用程序Acticle中,当调用ArticlesAdapter类的insertArticle往ArticlesProvider中增加一个文章信息条目时:
~~~
public class ArticlesAdapter {
......
public long insertArticle(Article article) {
ContentValues values = new ContentValues();
values.put(Articles.TITLE, article.getTitle());
values.put(Articles.ABSTRACT, article.getAbstract());
values.put(Articles.URL, article.getUrl());
Uri uri = resolver.insert(Articles.CONTENT_URI, values);
String itemId = uri.getPathSegments().get(1);
return Integer.valueOf(itemId).longValue();
}
......
}
~~~
便会进入到应用程序ArticlesProvider中的ArticlesProvider类的insert函数中:
~~~
public class ArticlesProvider extends ContentProvider {
......
@Override
public Uri insert(Uri uri, ContentValues values) {
if(uriMatcher.match(uri) != Articles.ITEM) {
throw new IllegalArgumentException("Error Uri: " + uri);
}
SQLiteDatabase db = dbHelper.getWritableDatabase();
long id = db.insert(DB_TABLE, Articles.ID, values);
if(id < 0) {
throw new SQLiteException("Unable to insert " + values + " for " + uri);
}
Uri newUri = ContentUris.withAppendedId(uri, id);
resolver.notifyChange(newUri, null);
return newUri;
}
......
}
~~~
从上面传来的参数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,它监控的数据发生变化了:
~~~
resolver.notifyChange(newUri, null);
~~~
下面我们就开始分析这个数据变化通知的发送过程,首先来看一下这个过程的时序图,然后再详细分析每一个步骤:
![](http://hi.csdn.net/attachment/201111/18/0_13216412164L75.gif)
* **Step 1. ContentResolver.notifyChange**
这个函数定义在frameworks/base/core/java/android/content/ContentResolver.java文件中:
~~~
public abstract class ContentResolver {
......
public void notifyChange(Uri uri, ContentObserver observer) {
notifyChange(uri, observer, true /* sync to network */);
}
public void notifyChange(Uri uri, ContentObserver observer, boolean syncToNetwork) {
try {
getContentService().notifyChange(
uri, observer == null ? null : observer.getContentObserver(),
observer != null && observer.deliverSelfNotifications(), syncToNetwork);
} catch (RemoteException e) {
}
}
......
}
~~~
这里调用了ContentService的远接程口来调用它的notifyChange函数来发送数据更新通知。
* **Step 2. ContentService.notifyChange**
这个函数定义在frameworks/base/core/java/android/content/ContentService.java文件中:
~~~
public final class ContentService extends IContentService.Stub {
......
public void notifyChange(Uri uri, IContentObserver observer,
boolean observerWantsSelfNotifications, boolean syncToNetwork) {
......
try {
ArrayList calls = new ArrayList();
synchronized (mRootNode) {
mRootNode.collectObserversLocked(uri, 0, observer, observerWantsSelfNotifications,
calls);
}
final int numCalls = calls.size();
for (int i=0; i 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 interesed
// in self notifications
if (entry.observer.asBinder() == observerBinder && !selfNotify) {
continue;
}
// Make sure the observer is interested in the notification
if (leaf || (!leaf && entry.notifyForDescendents)) {
calls.add(new ObserverCall(this, entry.observer, selfNotify));
}
}
}
public void collectObserversLocked(Uri uri, int index, IContentObserver observer,
boolean selfNotify, ArrayList calls) {
String segment = null;
int segmentCount = countUriSegments(uri);
if (index >= segmentCount) {
// This is the leaf node, notify all observers
collectMyObserversLocked(true, observer, selfNotify, calls);
} else if (index < segmentCount){
segment = getUriSegment(uri, index);
// Notify any observers at this level who are interested in descendents
collectMyObserversLocked(false, observer, selfNotify, 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, 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,于是就会调用下面语句:
~~~
segment = getUriSegment("content://shy.luo.providers.articles/item/n",0);
// Notify any observers at this level who are interested in descendents
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,于是执行下面语句:
~~~
segment = getUriSegment("content://shy.luo.providers.articles/item/n",1);
// Notify any observers at this level who are interested in descendents
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,于是执行下面语句:
~~~
segment = getUriSegment("content://shy.luo.providers.articles/item/n",2);
// Notify any observers at this level who are interested in descendents
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。
返回到Step 2中,调用下面语句来通知相应的ContentObserver,它们监控的数据发生变化了:
~~~
for (int i=0; i
';