在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 plaincopy
  1. class ServerThread extends Thread {
  2. ......
  3. @Override
  4. public void run() {
  5. ......
  6. Looper.prepare();
  7. // Critical services...
  8. try {
  9. ......
  10. ContentService.main(context,
  11. factoryTest == SystemServer.FACTORY_TEST_LOW_LEVEL);
  12. ......
  13. }catch (RuntimeException e) {
  14. ......
  15. }
  16. ......
  17. Looper.loop();
  18. ......
  19. }
  20. }

ContentService类定义在frameworks/base/core/java/android/content/ContentService.java文件中，它的main函数的实现如下所示：

[java] view plaincopy
  1. public final class ContentService extends IContentService.Stub {
  2. ......
  3. public static IContentService main(Context context, boolean factoryTest) {
  4. ContentService service = new ContentService(context, factoryTest);
  5. ServiceManager.addService(ContentResolver.CONTENT_SERVICE_NAME, service);
  6. return service;
  7. }
  8. ......
  9. }

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

2. ContentObserver的注册过程分析

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

[java] view plaincopy
  1. public class MainActivity extends Activity implements View.OnClickListener, AdapterView.OnItemClickListener {
  2. ......
  3. private ArticleAdapter adapter = null;
  4. private ArticleObserver observer = null;
  5. ......
  6. @Override
  7. public void onCreate(Bundle savedInstanceState) {
  8. super.onCreate(savedInstanceState);
  9. ......
  10. observer = new ArticleObserver(new Handler());
  11. getContentResolver().registerContentObserver(Articles.CONTENT_URI, true, observer);
  12. ......
  13. }
  14. private class ArticleObserver extends ContentObserver {
  15. public ArticleObserver(Handler handler) {
  16. super(handler);
  17. }
  18. @Override
  19. public void onChange (boolean selfChange) {
  20. adapter.notifyDataSetChanged();
  21. }
  22. }
  23. ......
  24. }

从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 plaincopy
  1. public abstract class ContentResolver {
  2. ......
  3. public final void registerContentObserver(Uri uri, boolean notifyForDescendents,
  4. ContentObserver observer)
  5. {
  6. try {
  7. getContentService().registerContentObserver(uri, notifyForDescendents,
  8. observer.getContentObserver());
  9. } catch (RemoteException e) {
  10. }
  11. }
  12. ......
  13. }

当参数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 plaincopy
  1. public abstract class ContentResolver {
  2. ......
  3. public static IContentService getContentService() {
  4. if (sContentService != null) {
  5. return sContentService;
  6. }
  7. IBinder b = ServiceManager.getService(CONTENT_SERVICE_NAME);
  8. ......
  9. sContentService = IContentService.Stub.asInterface(b);
  10. ......
  11. return sContentService;
  12. }
  13. private static IContentService sContentService;
  14. ......
  15. }

在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 plaincopy
  1. public abstract class ContentObserver {
  2. ......
  3. private Transport mTransport;
  4. ......
  5. private static final class Transport extends IContentObserver.Stub {
  6. ContentObserver mContentObserver;
  7. public Transport(ContentObserver contentObserver) {
  8. mContentObserver = contentObserver;
  9. }
  10. ......
  11. }
  12. ......
  13. public IContentObserver getContentObserver() {
  14. synchronized(lock) {
  15. if (mTransport == null) {
  16. mTransport = new Transport(this);
  17. }
  18. return mTransport;
  19. }
  20. }
  21. ......
  22. }

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 plaincopy
  1. public final class ContentService extends IContentService.Stub {
  2. ......
  3. private final ObserverNode mRootNode = new ObserverNode("");
  4. ......
  5. public void registerContentObserver(Uri uri, boolean notifyForDescendents,
  6. IContentObserver observer) {
  7. ......
  8. synchronized (mRootNode) {
  9. mRootNode.addObserverLocked(uri, observer, notifyForDescendents, mRootNode);
  10. ......
  11. }
  12. }
  13. ......
  14. }

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

Step 5. ObserverNode.addObserverLocked

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

[java] view plaincopy
  1. public final class ContentService extends IContentService.Stub {
  2. ......
  3. public static final class ObserverNode {
  4. ......
  5. private String mName;
  6. private ArrayList<ObserverNode> mChildren = new ArrayList<ObserverNode>();
  7. private ArrayList<ObserverEntry> mObservers = new ArrayList<ObserverEntry>();
  8. public ObserverNode(String name) {
  9. mName = name;
  10. }
  11. private String getUriSegment(Uri uri, int index) {
  12. if (uri != null) {
  13. if (index == 0) {
  14. return uri.getAuthority();
  15. } else {
  16. return uri.getPathSegments().get(index - 1);
  17. }
  18. } else {
  19. return null;
  20. }
  21. }
  22. private int countUriSegments(Uri uri) {
  23. if (uri == null) {
  24. return 0;
  25. }
  26. return uri.getPathSegments().size() + 1;
  27. }
  28. public void addObserverLocked(Uri uri, IContentObserver observer,
  29. boolean notifyForDescendents, Object observersLock) {
  30. addObserverLocked(uri, 0, observer, notifyForDescendents, observersLock);
  31. }
  32. private void addObserverLocked(Uri uri, int index, IContentObserver observer,
  33. boolean notifyForDescendents, Object observersLock) {
  34. // If this is the leaf node add the observer
  35. if (index == countUriSegments(uri)) {
  36. mObservers.add(new ObserverEntry(observer, notifyForDescendents, observersLock));
  37. return;
  38. }
  39. // Look to see if the proper child already exists
  40. String segment = getUriSegment(uri, index);
  41. if (segment == null) {
  42. throw new IllegalArgumentException("Invalid Uri (" + uri + ") used for observer");
  43. }
  44. int N = mChildren.size();
  45. for (int i = 0; i < N; i++) {
  46. ObserverNode node = mChildren.get(i);
  47. if (node.mName.equals(segment)) {
  48. node.addObserverLocked(uri, index + 1, observer, notifyForDescendents, observersLock);
  49. return;
  50. }
  51. }
  52. // No child found, create one
  53. ObserverNode node = new ObserverNode(segment);
  54. mChildren.add(node);
  55. node.addObserverLocked(uri, index + 1, observer, notifyForDescendents, observersLock);
  56. }
  57. ......
  58. }
  59. ......
  60. }

从这里我们就可以看出，注册到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 plaincopy
  1. public class ArticlesAdapter {
  2. ......
  3. public long insertArticle(Article article) {
  4. ContentValues values = new ContentValues();
  5. values.put(Articles.TITLE, article.getTitle());
  6. values.put(Articles.ABSTRACT, article.getAbstract());
  7. values.put(Articles.URL, article.getUrl());
  8. Uri uri = resolver.insert(Articles.CONTENT_URI, values);
  9. String itemId = uri.getPathSegments().get(1);
  10. return Integer.valueOf(itemId).longValue();
  11. }
  12. ......
  13. }

便会进入到应用程序ArticlesProvider中的ArticlesProvider类的insert函数中：

[java] view plaincopy
  1. public class ArticlesProvider extends ContentProvider {
  2. ......
  3. @Override
  4. public Uri insert(Uri uri, ContentValues values) {
  5. if(uriMatcher.match(uri) != Articles.ITEM) {
  6. throw new IllegalArgumentException("Error Uri: " + uri);
  7. }
  8. SQLiteDatabase db = dbHelper.getWritableDatabase();
  9. long id = db.insert(DB_TABLE, Articles.ID, values);
  10. if(id < 0) {
  11. throw new SQLiteException("Unable to insert " + values + " for " + uri);
  12. }
  13. Uri newUri = ContentUris.withAppendedId(uri, id);
  14. resolver.notifyChange(newUri, null);
  15. return newUri;
  16. }
  17. ......
  18. }

从上面传来的参数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 plaincopy
  1. resolver.notifyChange(newUri, null);

下面我们就开始分析这个数据变化通知的发送过程，首先来看一下这个过程的时序图，然后再详细分析每一个步骤：

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

[java] view plaincopy
  1. public abstract class ContentResolver {
  2. ......
  3. public void notifyChange(Uri uri, ContentObserver observer) {
  4. notifyChange(uri, observer, true /* sync to network */);
  5. }
  6. public void notifyChange(Uri uri, ContentObserver observer, boolean syncToNetwork) {
  7. try {
  8. getContentService().notifyChange(
  9. uri, observer == null ? null : observer.getContentObserver(),
  10. observer != null && observer.deliverSelfNotifications(), syncToNetwork);
  11. } catch (RemoteException e) {
  12. }
  13. }
  14. ......
  15. }

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

Step 2. ContentService.notifyChange

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

[java] view plaincopy
  1. public final class ContentService extends IContentService.Stub {
  2. ......
  3. public void notifyChange(Uri uri, IContentObserver observer,
  4. boolean observerWantsSelfNotifications, boolean syncToNetwork) {
  5. ......
  6. try {
  7. ArrayList<ObserverCall> calls = new ArrayList<ObserverCall>();
  8. synchronized (mRootNode) {
  9. mRootNode.collectObserversLocked(uri, 0, observer, observerWantsSelfNotifications,
  10. calls);
  11. }
  12. final int numCalls = calls.size();
  13. for (int i=0; i<numCalls; i++) {
  14. ObserverCall oc = calls.get(i);
  15. try {
  16. oc.mObserver.onChange(oc.mSelfNotify);
  17. ......
  18. } catch (RemoteException ex) {
  19. ......
  20. }
  21. }
  22. ......
  23. } finally {
  24. ......
  25. }
  26. }
  27. ......
  28. }

这个函数主要做了两件事情，第一件事情是调用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 plaincopy
  1. public final class ContentService extends IContentService.Stub {
  2. ......
  3. public static final class ObserverNode {
  4. ......
  5. private void collectMyObserversLocked(boolean leaf, IContentObserver observer,
  6. boolean selfNotify, ArrayList<ObserverCall> calls) {
  7. int N = mObservers.size();
  8. IBinder observerBinder = observer == null ? null : observer.asBinder();
  9. for (int i = 0; i < N; i++) {
  10. ObserverEntry entry = mObservers.get(i);
  11. // Don't notify the observer if it sent the notification and isn't interesed
  12. // in self notifications
  13. if (entry.observer.asBinder() == observerBinder && !selfNotify) {
  14. continue;
  15. }
  16. // Make sure the observer is interested in the notification
  17. if (leaf || (!leaf && entry.notifyForDescendents)) {
  18. calls.add(new ObserverCall(this, entry.observer, selfNotify));
  19. }
  20. }
  21. }
  22. public void collectObserversLocked(Uri uri, int index, IContentObserver observer,
  23. boolean selfNotify, ArrayList<ObserverCall> calls) {
  24. String segment = null;
  25. int segmentCount = countUriSegments(uri);
  26. if (index >= segmentCount) {
  27. // This is the leaf node, notify all observers
  28. collectMyObserversLocked(true, observer, selfNotify, calls);
  29. } else if (index < segmentCount){
  30. segment = getUriSegment(uri, index);
  31. // Notify any observers at this level who are interested in descendents
  32. collectMyObserversLocked(false, observer, selfNotify, calls);
  33. }
  34. int N = mChildren.size();
  35. for (int i = 0; i < N; i++) {
  36. ObserverNode node = mChildren.get(i);
  37. if (segment == null || node.mName.equals(segment)) {
  38. // We found the child,
  39. node.collectObserversLocked(uri, index + 1, observer, selfNotify, calls);
  40. if (segment != null) {
  41. break;
  42. }
  43. }
  44. }
  45. }
  46. }
  47. }

第一次调用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 plaincopy
  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 plaincopy
  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 plaincopy
  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 plaincopy
  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 plaincopy
  1. public abstract class ContentObserver {
  2. ......
  3. private static final class Transport extends IContentObserver.Stub {
  4. ContentObserver mContentObserver;
  5. ......
  6. public void onChange(boolean selfChange) {
  7. ContentObserver contentObserver = mContentObserver;
  8. if (contentObserver != null) {
  9. contentObserver.dispatchChange(selfChange);
  10. }
  11. }
  12. ......
  13. }
  14. ......
  15. }

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

Step 5. ContentObserver.dispatchChange

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

[java] view plaincopy
  1. public abstract class ContentObserver {
  2. ......
  3. public final void dispatchChange(boolean selfChange) {
  4. if (mHandler == null) {
  5. onChange(selfChange);
  6. } else {
  7. mHandler.post(new NotificationRunnable(selfChange));
  8. }
  9. }
  10. }

在前面分析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 plaincopy
  1. public abstract class ContentObserver {
  2. ......
  3. private final class NotificationRunnable implements Runnable {
  4. private boolean mSelf;
  5. public NotificationRunnable(boolean self) {
  6. mSelf = self;
  7. }
  8. public void run() {
  9. ContentObserver.this.onChange(mSelf);
  10. }
  11. }
  12. ......
  13. }

这个函数就直接调用ContentObserver的子类的onChange函数来处理这个数据更新通知了。在我们这个情景中，这个ContentObserver子类便是ArticlesObserver了。

Step 7. ArticlesObserver.onChange

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

[java] view plaincopy
  1. public class MainActivity extends Activity implements View.OnClickListener, AdapterView.OnItemClickListener {
  2. ......
  3. private class ArticleObserver extends ContentObserver {
  4. ......
  5. @Override
  6. public void onChange (boolean selfChange) {
  7. adapter.notifyDataSetChanged();
  8. }
  9. }
  10. ......
  11. }

这里它要执行的操作便是更新界面上的ListView列表中的文章信息了，以便反映ArticlesProvider中的最新数据。

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

老罗的新浪微博：http://weibo.com/shengyangluo，欢迎关注！

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

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

            3. 数据更新通知的发送过程        在前面这篇文章Android应用程序组件Content Provider应用实例介绍的应用程序Acticle中,当调用ArticlesAda ...

  2. Android应用程序组件Content Provider在应用程序之间共享数据的原理分析（1）

             在Android系统中,不同的应用程序是不能直接读写对方的数据文件的,如果它们想共享数据的话,只能通过Content Provider组件来实现.那么,Content Provide ...

  3. Android应用程序组件Content Provider的启动过程源代码分析（6）

        Step 17. ActivityThread.installProvider         这个函数定义在frameworks/base/core/java/android/app/Act ...

  4. Android应用程序组件Content Provider的启动过程源代码分析（1）

             通过前面的学习,我们知道在Android系统中,Content Provider可以为不同的应用程序访问相同的数据提供统一的入口.Content Provider一般是运行在独立的进 ...

  5. Android应用程序组件Content Provider简要介绍和学习计划

    在Android系统中,Content Provider作为应用程序四大组件之一,它起到在应用程序之间共享数据的作用,同时,它还是标准的数据访问接口.前面的一系列文章已经分析过Android应用程序的 ...

  6. Android应用程序组件Content Provider在应用程序之间共享数据的原理分析（2）

        Step 7. ContentProviderProxy.query       这个函数定义在frameworks/base/core/java/android/content/Conten ...

  7. Android应用安全之Content Provider安全

    android平台提供了Content Provider,将一个应用程序的指定数据集提供给其它应用程序.这些数据可以存储在文件系统.SQLite数据库中,或以任何其它合理的方式存储.其他应用可以通过C ...

  8. Android四大组件Content Provider使用实例

    本文包含两个应用程序,其中,第一个应用程序命名为ArticlesProvider,它使用了SQLite数据库来维护一个文章信息列表,同时,它定义了访问这个文章信息列表的URI,这样,我们就可以通过一个 ...

  9. Android应用程序绑定服务（bindService）的过程源代码分析

    Android应用程序组件Service与Activity一样,既可以在新的进程中启动,也可以在应用程序进程内部启动:前面我们已经分析了在新的进程中启动Service的过程,本文将要介绍在应用程序内部 ...

最新文章

  1. 如何使用htmlq提取html文件内容
  2. uniapp 界面拖动，去掉半圆形阴影
  3. 菜鸟要飞java_Java Android视频教程 下载
  4. VC里的#define new DEBUG_NEW
  5. 深入理解MSTP域和端口角色
  6. 【2016年第6期】面向国际的生命组学大数据管理体系建设
  7. html 源码_HTML从零开始——简单介绍
  8. 源码编译安装php-3.5.8
  9. sql中的一些通用函数
  10. 算法大亨Carl的面试简历长啥样？同款模板让你脱胎换骨
  11. 如何查看局域网络计算机资料,怎么查看局域网内所有电脑的信息
  12. CANoe-第2个仿真工程-XVehicle—2Panel设计（原理，思路）
  13. FishEye Crucible分析
  14. Scrapy 出现DEBUG:Filtered duplicate request
  15. YOLOV5dataset.py代码注释与解析
  16. 例5-3 安迪的第一个字典（Andy‘s First Dictionary,UVa 10815）
  17. 全国计算机考试有代码提示吗,全国计算机等级考试它又来啦~快来获取报名攻略！...
  18. C语言:成绩等级划分!
  19. oracle 11g 新特性之动态绑定变量窥视(一)
  20. python---控制时间的函数time（）

热门文章

  1. 7-14 求整数段和 (15 分)
  2. 如何监测服务器网络稳定性centos,centos下网络监测工具nethogs
  3. 神的战争god无法显示服务器,神的战争god快速升级抢资源攻略
  4. 递增的整数序列链表的插入
  5. java mysql存储过程_JAVA调用MySQL存储过程
  6. Spring MVC对象转换说明
  7. KNN算法——分类部分
  8. 【bzoj1727】[Usaco2006 Open]The Milk Queue 挤奶队列 贪心
  9. WPF仿制IOS UI（未完待续）
  10. Codeforces Round #169 (Div. 2)