程序博客网 > mac 恢复 不了

Android应用程序组件Content Provider的共享数据更新通知机制分析

来源：互联网 发布：mac 恢复 不了 编辑：程序博客网 时间：2024/06/06 02:33
 在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来加载这些关键服务：

[java] view plaincopyprint?
  1. class ServerThread extends Thread {
  2. ......
  4. @Override
  5. public void run() {
  6. ......
  8. Looper.prepare();
  10. // Critical services...
  11. try {
  12. ......
  14. ContentService.main(context,
  15. factoryTest == SystemServer.FACTORY_TEST_LOW_LEVEL);
  17. ......
  19. }catch (RuntimeException e) {
  20. ......
  21. }
  23. ......
  25. Looper.loop();
  26. ......
  27. }
  28. }
ContentService类定义在frameworks/base/core/java/android/content/ContentService.java文件中，它的main函数的实现如下所示：

[java] view plaincopyprint?
  1. public finalclass ContentService extends IContentService.Stub {
  2. ......
  4. public static IContentService main(Context context,boolean factoryTest) {
  5. ContentService service = new ContentService(context, factoryTest);
  6. ServiceManager.addService(ContentResolver.CONTENT_SERVICE_NAME, service);
  7. return service;
  8. }
  10. ......
  11. }

从这里我们就可以看到，在ContentService类的main函数中，会创建一个ContentService实例，然后把它添加到ServiceManager中去，这样，ContentService服务就启动起来了， 其它地方可以通过ServiceManager来获得它的一个远程接口来使用它提供的服务。

2. ContentObserver的注册过程分析

在前面这篇文章Android应用程序组件Content Provider应用实例介绍的应用程序Acticle中，主窗口MainActivity在创建的时候，会调用应用程序上下文的ContentResolver接口来注册一个自定义的ContentObserver来监控ArticlesProvider这个Content Provider中的数据变化：

[java] view plaincopyprint?
  1. public class MainActivityextends Activity implements View.OnClickListener, AdapterView.OnItemClickListener {
  2. ......
  4. private ArticleAdapter adapter = null;
  5. private ArticleObserver observer =null;
  7. ......
  9. @Override
  10. public void onCreate(Bundle savedInstanceState) {
  11. super.onCreate(savedInstanceState);
  12. ......
  14. observer = new ArticleObserver(new Handler());
  15. getContentResolver().registerContentObserver(Articles.CONTENT_URI,true, observer);
  17. ......
  18. }
  20. private class ArticleObserverextends ContentObserver {
  21. public ArticleObserver(Handler handler) {
  22. super(handler);
  23. }
  25. @Override
  26. public void onChange (boolean selfChange) {
  27. adapter.notifyDataSetChanged();
  28. }
  29. }
  31. ......
  32. }
从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中的数据变化的过程，首先来看一下这个过程的时序图，然后再详细分析每一个步骤：


Step 1. ContentResolver.registerContentObserver

这个函数定义在frameworks/base/core/java/android/content/ContentResolver.java文件中：

[java] view plaincopyprint?
  1. public abstractclass ContentResolver {
  2. ......
  4. public finalvoid registerContentObserver(Uri uri, boolean notifyForDescendents,
  5. ContentObserver observer)
  6. {
  7. try {
  8. getContentService().registerContentObserver(uri, notifyForDescendents,
  9. observer.getContentObserver());
  10. } catch (RemoteException e) {
  11. }
  12. }
  14. ......
  15. }
当参数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文件中：

[java] view plaincopyprint?
  1. public abstractclass ContentResolver {
  2. ......
  4. public static IContentService getContentService() {
  5. if (sContentService != null) {
  6. return sContentService;
  7. }
  8. IBinder b = ServiceManager.getService(CONTENT_SERVICE_NAME);
  9. ......
  10. sContentService = IContentService.Stub.asInterface(b);
  11. ......
  12. return sContentService;
  13. }
  15. private static IContentService sContentService;
  16. ......
  17. }
在ContentResolver类中，有一个静态成员变量sContentService，开始时它的值为null。当ContentResolver类的getContentService函数第一次被调用时，它便会通过ServiceManager类的getService函数来获得前面已经启动起来了的ContentService服务的远程接口，然后把它保存在sContentService变量中。这样，当下次ContentResolver类的getContentService函数再次被调用时，就可以直接把这个ContentService远程接口返回给调用者了。

Step 3. ContentObserver.getContentObserver

这个函数定义在frameworks/base/core/java/android/database/ContentObserver.java文件中：

[java] view plaincopyprint?
  1. public abstractclass ContentObserver {
  2. ......
  4. private Transport mTransport;
  6. ......
  8. private staticfinal class Transportextends IContentObserver.Stub {
  9. ContentObserver mContentObserver;
  11. public Transport(ContentObserver contentObserver) {
  12. mContentObserver = contentObserver;
  13. }
  15. ......
  16. }
  18. ......
  20. public IContentObserver getContentObserver() {
  21. synchronized(lock) {
  22. if (mTransport == null) {
  23. mTransport = new Transport(this);
  24. }
  25. return mTransport;
  26. }
  27. }
  29. ......
  30. }
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文件中：

[java] view plaincopyprint?
  1. public finalclass ContentService extends IContentService.Stub {
  2. ......
  4. private final ObserverNode mRootNode =new ObserverNode("");
  6. ......
  8. public void registerContentObserver(Uri uri,boolean notifyForDescendents,
  9. IContentObserver observer) {
  10. ......
  12. synchronized (mRootNode) {
  13. mRootNode.addObserverLocked(uri, observer, notifyForDescendents, mRootNode);
  14. ......
  15. }
  16. }
  18. ......
  19. }
它调用了ContentService类的成员变量mRootNode的addObserverLocked函数来注册这个ContentObserver对象observer。成员变量mRootNode的类型为ContentService在内部定义的一个类ObserverNode。

Step 5. ObserverNode.addObserverLocked

这个函数定义在frameworks/base/core/java/android/content/ContentService.java文件中：

[java] view plaincopyprint?
  1. public finalclass ContentService extends IContentService.Stub {
  2. ......
  4. public staticfinal class ObserverNode {
  5. ......
  7. private String mName;
  8. private ArrayList<ObserverNode> mChildren =new ArrayList<ObserverNode>();
  9. private ArrayList<ObserverEntry> mObservers =new ArrayList<ObserverEntry>();
  11. public ObserverNode(String name) {
  12. mName = name;
  13. }
  15. private String getUriSegment(Uri uri,int index) {
  16. if (uri != null) {
  17. if (index == 0) {
  18. return uri.getAuthority();
  19. } else {
  20. return uri.getPathSegments().get(index -1);
  21. }
  22. } else {
  23. return null;
  24. }
  25. }
  27. private int countUriSegments(Uri uri) {
  28. if (uri == null) {
  29. return 0;
  30. }
  31. return uri.getPathSegments().size() +1;
  32. }
  34. public void addObserverLocked(Uri uri, IContentObserver observer,
  35. boolean notifyForDescendents, Object observersLock) {
  36. addObserverLocked(uri, 0, observer, notifyForDescendents, observersLock);
  37. }
  39. private void addObserverLocked(Uri uri,int index, IContentObserver observer,
  40. boolean notifyForDescendents, Object observersLock) {
  41. // If this is the leaf node add the observer
  42. if (index == countUriSegments(uri)) {
  43. mObservers.add(new ObserverEntry(observer, notifyForDescendents, observersLock));
  44. return;
  45. }
  47. // Look to see if the proper child already exists
  48. String segment = getUriSegment(uri, index);
  49. if (segment == null) {
  50. throw new IllegalArgumentException("Invalid Uri (" + uri +") used for observer");
  51. }
  52. int N = mChildren.size();
  53. for (int i =0; i < N; i++) {
  54. ObserverNode node = mChildren.get(i);
  55. if (node.mName.equals(segment)) {
  56. node.addObserverLocked(uri, index + 1, observer, notifyForDescendents, observersLock);
  57. return;
  58. }
  59. }
  61. // No child found, create one
  62. ObserverNode node = new ObserverNode(segment);
  63. mChildren.add(node);
  64. node.addObserverLocked(uri, index + 1, observer, notifyForDescendents, observersLock);
  65. }
  67. ......
  68. }
  70. ......
  71. }
从这里我们就可以看出，注册到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中增加一个文章信息条目时：

[java] view plaincopyprint?
  1. public class ArticlesAdapter {
  2. ......
  4. public long insertArticle(Article article) {
  5. ContentValues values = new ContentValues();
  6. values.put(Articles.TITLE, article.getTitle());
  7. values.put(Articles.ABSTRACT, article.getAbstract());
  8. values.put(Articles.URL, article.getUrl());
  10. Uri uri = resolver.insert(Articles.CONTENT_URI, values);
  11. String itemId = uri.getPathSegments().get(1);
  13. return Integer.valueOf(itemId).longValue();
  14. }
  16. ......
  17. }
便会进入到应用程序ArticlesProvider中的ArticlesProvider类的insert函数中：

[java] view plaincopyprint?
  1. public class ArticlesProviderextends ContentProvider {
  2. ......
  4. @Override
  5. public Uri insert(Uri uri, ContentValues values) {
  6. if(uriMatcher.match(uri) != Articles.ITEM) {
  7. throw new IllegalArgumentException("Error Uri: " + uri);
  8. }
  10. SQLiteDatabase db = dbHelper.getWritableDatabase();
  12. long id = db.insert(DB_TABLE, Articles.ID, values);
  13. if(id < 0) {
  14. throw new SQLiteException("Unable to insert " + values +" for " + uri);
  15. }
  17. Uri newUri = ContentUris.withAppendedId(uri, id);
  18. resolver.notifyChange(newUri, null);
  20. return newUri;
  21. }
  23. ......
  24. }
从上面传来的参数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] view plaincopyprint?
  1. resolver.notifyChange(newUri, null);
下面我们就开始分析这个数据变化通知的发送过程，首先来看一下这个过程的时序图，然后再详细分析每一个步骤：


Step 1. ContentResolver.notifyChange
这个函数定义在frameworks/base/core/java/android/content/ContentResolver.java文件中：

[java] view plaincopyprint?
  1. public abstractclass ContentResolver {
  2. ......
  4. public void notifyChange(Uri uri, ContentObserver observer) {
  5. notifyChange(uri, observer, true/* sync to network */);
  6. }
  8. public void notifyChange(Uri uri, ContentObserver observer,boolean syncToNetwork) {
  9. try {
  10. getContentService().notifyChange(
  11. uri, observer == null ? null : observer.getContentObserver(),
  12. observer != null && observer.deliverSelfNotifications(), syncToNetwork);
  13. } catch (RemoteException e) {
  14. }
  15. }
  17. ......
  18. }
这里调用了ContentService的远接程口来调用它的notifyChange函数来发送数据更新通知。

Step 2. ContentService.notifyChange

这个函数定义在frameworks/base/core/java/android/content/ContentService.java文件中：

[java] view plaincopyprint?
  1. public finalclass ContentService extends IContentService.Stub {
  2. ......
  4. public void notifyChange(Uri uri, IContentObserver observer,
  5. boolean observerWantsSelfNotifications,boolean syncToNetwork) {
  6. ......
  8. try {
  9. ArrayList<ObserverCall> calls = new ArrayList<ObserverCall>();
  10. synchronized (mRootNode) {
  11. mRootNode.collectObserversLocked(uri, 0, observer, observerWantsSelfNotifications,
  12. calls);
  13. }
  14. final int numCalls = calls.size();
  15. for (int i=0; i<numCalls; i++) {
  16. ObserverCall oc = calls.get(i);
  17. try {
  18. oc.mObserver.onChange(oc.mSelfNotify);
  19. ......
  20. } catch (RemoteException ex) {
  21. ......
  22. }
  23. }
  24. ......
  25. } finally {
  26. ......
  27. }
  28. }
  30. ......
  31. }
这个函数主要做了两件事情，第一件事情是调用ContentService的成员变量mRootNode的collectObserverLocked函数来收集那些注册了监控"content://shy.luo.providers.articles/item/n"这个URI的ContentObserver，第二件事情是分别调用了这些ContentObserver的onChange函数来通知它们监控的数据发生变化了。

Step 3. ObserverNode.collectObserversLocked

这个函数定义在frameworks/base/core/java/android/content/ContentService.java文件中：

[java] view plaincopyprint?
  1. public finalclass ContentService extends IContentService.Stub {
  2. ......
  4. public staticfinal class ObserverNode {
  5. ......
  7. private void collectMyObserversLocked(boolean leaf, IContentObserver observer,
  8. boolean selfNotify, ArrayList<ObserverCall> calls) {
  9. int N = mObservers.size();
  10. IBinder observerBinder = observer == null ?null : observer.asBinder();
  11. for (int i =0; i < N; i++) {
  12. ObserverEntry entry = mObservers.get(i);
  14. // Don't notify the observer if it sent the notification and isn't interesed
  15. // in self notifications
  16. if (entry.observer.asBinder() == observerBinder && !selfNotify) {
  17. continue;
  18. }
  20. // Make sure the observer is interested in the notification
  21. if (leaf || (!leaf && entry.notifyForDescendents)) {
  22. calls.add(new ObserverCall(this, entry.observer, selfNotify));
  23. }
  24. }
  25. }
  27. public void collectObserversLocked(Uri uri,int index, IContentObserver observer,
  28. boolean selfNotify, ArrayList<ObserverCall> calls) {
  29. String segment = null;
  30. int segmentCount = countUriSegments(uri);
  31. if (index >= segmentCount) {
  32. // This is the leaf node, notify all observers
  33. collectMyObserversLocked(true, observer, selfNotify, calls);
  34. } else if (index < segmentCount){
  35. segment = getUriSegment(uri, index);
  36. // Notify any observers at this level who are interested in descendents
  37. collectMyObserversLocked(false, observer, selfNotify, calls);
  38. }
  40. int N = mChildren.size();
  41. for (int i =0; i < N; i++) {
  42. ObserverNode node = mChildren.get(i);
  43. if (segment == null || node.mName.equals(segment)) {
  44. // We found the child,
  45. node.collectObserversLocked(uri, index + 1, observer, selfNotify, calls);
  46. if (segment != null) {
  47. break;
  48. }
  49. }
  50. }
  51. }
  52. }
  53. }
第一次调用collectObserversLocked时，是在mRootNode的这个ObserverNode节点中进行收集ContentObserver的。这时候传进来的uri的值为"content://shy.luo.providers.articles/item/n"，index的值为0。调用countUriSegments("content://shy.luo.providers.articles/item/n")函数得到的返回值为3，于是就会调用下面语句：

[java] view plaincopyprint?
  1. segment = getUriSegment("content://shy.luo.providers.articles/item/n",0);
  2. // Notify any observers at this level who are interested in descendents
  3. 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] view plaincopyprint?
  1. segment = getUriSegment("content://shy.luo.providers.articles/item/n",1);
  2. // Notify any observers at this level who are interested in descendents
  3. 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] view plaincopyprint?
  1. segment = getUriSegment("content://shy.luo.providers.articles/item/n",2);
  2. // Notify any observers at this level who are interested in descendents
  3. 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，它们监控的数据发生变化了：

[java] view plaincopyprint?
  1. for (int i=0; i<numCalls; i++) {
  2. ObserverCall oc = calls.get(i);
  3. try {
  4. oc.mObserver.onChange(oc.mSelfNotify);
  5. ......
  6. } catch (RemoteException ex) {
  7. ......
  8. }
  9. }
前面我们在分析ContentObserver的注册过程的Step 3时，介绍到注册到ContentService服务中的ContentObserver是一个在ContentObserver内部定义的一个类Transport的对象的远程接口，于是这里调用这个接口的onChange函数时，就会进入到ContentObserver的内部类Transport的onChange函数中去。

Step 4. Transport.onChange

这个函数定义在frameworks/base/core/java/android/database/ContentObserver.java文件中：

[java] view plaincopyprint?
  1. public abstractclass ContentObserver {
  2. ......
  4. private staticfinal class Transportextends IContentObserver.Stub {
  5. ContentObserver mContentObserver;
  7. ......
  9. public void onChange(boolean selfChange) {
  10. ContentObserver contentObserver = mContentObserver;
  11. if (contentObserver != null) {
  12. contentObserver.dispatchChange(selfChange);
  13. }
  14. }
  16. ......
  17. }
  19. ......
  20. }
前面我们在分析ContentObserver的注册过程的Step 3时，把ArticlesObserver这个ContentObserver保存在了这个Transport对象的mContentObserver成员变量中，因此，会调用它的dispatchChange函数来执行数据更新通知的操作。

Step 5. ContentObserver.dispatchChange

这个函数定义在frameworks/base/core/java/android/database/ContentObserver.java文件中：

[java] view plaincopyprint?
  1. public abstractclass ContentObserver {
  2. ......
  4. public finalvoid dispatchChange(boolean selfChange) {
  5. if (mHandler == null) {
  6. onChange(selfChange);
  7. } else {
  8. mHandler.post(new NotificationRunnable(selfChange));
  9. }
  10. }
  11. }
在前面分析ArticlesObserver的注册过程时，我们以应用程序Article的主线程的消息循环创建了一个Handler，并且以这个Handler来创建了这个ArticlesObserver，这个Handler就保存在ArticlesObserver的父类ContentObserver的成员变量mHandler中。因此，这里的mHandler不为null，于是把这个数据更新通知封装成了一个消息，放到应用程序Article的主线程中去处理，最终这个消息是由NotificationRunnable类的run函数来处理的。

Step 6. NotificationRunnable.run

这个函数定义在frameworks/base/core/java/android/database/ContentObserver.java文件中：

[java] view plaincopyprint?
  1. public abstractclass ContentObserver {
  2. ......
  4. private finalclass NotificationRunnable implements Runnable {
  5. private boolean mSelf;
  7. public NotificationRunnable(boolean self) {
  8. mSelf = self;
  9. }
  11. public void run() {
  12. ContentObserver.this.onChange(mSelf);
  13. }
  14. }
  16. ......
  17. }
这个函数就直接调用ContentObserver的子类的onChange函数来处理这个数据更新通知了。在我们这个情景中，这个ContentObserver子类便是ArticlesObserver了。

Step 7. ArticlesObserver.onChange

这个函数定义在前面一篇文章Android应用程序组件Content Provider应用实例介绍的应用程序Artilce源代码工程目录下，在文件为packages/experimental/Article/src/shy/luo/article/MainActivity.java中：

[java] view plaincopyprint?
  1. public class MainActivityextends Activity implements View.OnClickListener, AdapterView.OnItemClickListener {
  2. ......
  4. private class ArticleObserverextends ContentObserver {
  5. ......
  7. @Override
  8. public void onChange (boolean selfChange) {
  9. adapter.notifyDataSetChanged();
  10. }
  11. }
  13. ......
  14. }
这里它要执行的操作便是更新界面上的ListView列表中的文章信息了，以便反映ArticlesProvider中的最新数据。

这样，Android应用程序组件Content Provider的共享数据更新通知机制就分析完了，整个Android应用程序组件Content Provider的学习也结束了，重新学习请回到Android应用程序组件Content Provider简要介绍和学习计划一文。

mac 恢复 不了 mac 恢复 不了
原创粉丝点击
热门IT博客
c语言register变量c语言register变量
java导入excel 带函数java导入excel 带函数
孤岛危机2和3优化
js回调函数是什么意思
docker 连接 数据库
mac os 安装 websphere
沉迷网络的危害
淘宝粮票豆子
淘宝怎样解绑实名认证
浏览器不加载js
淘宝开店叫什么名字好
vscode golang 运行
数据清洗与特征选择
期货自动化交易软件
.net 性能优化 lambda
程序员客栈官网
广东省加工贸易数据
新日铁住金软件面试
巴基斯坦留学生 知乎
访客网络关闭
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 中国军校排名及分数线 考军校的条件 烈火军校结局 黄埔军校现在还有吗 中国一本军校排名 烈火军校免费看 烈火军校免费 烈火军校潇湘冬儿 黄埔军校一共出来多少名将 军校生by蝶之灵 军校有哪些学校 黄埔军校旧址纪念馆 烈火军校曲曼婷 烈火军校在线 军校排名及分数线 考军校要多少分 烈火军校全集免费1到48 2018军校排名及分数线 黄埔军校名将 军校毕业后分配去向和待遇 读军校需要什么条件 考上军校有前途吗 军校报考条件 湖南军校录取分数线 大专军校有哪些 少年军校招生条件 报考军校的分数线 2016军校招生计划 石家庄军校有哪些 中国军校有哪些 多少分能上军校 全国军校排名 中国军校排行榜 中国军校排名及录取线 军校的生活是怎样的 二本军校排名及分数线 中国军校招生网 四川军校录取分数线 军校录取分数 军校多少分录取 怎样报考军校

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里