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

最新推荐文章于 2021-11-21 18:40:40 发布
最新推荐文章于 2021-11-21 18:40:40 发布
阅读量2.2k 收藏
点赞数
文章标签： android null 代码分析 listview service system

        在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来加载这些关键服务：

view plain
  1. class ServerThread extends Thread {  
  2.     ......  
  3.   
  4.     @Override  
  5.     public void run() {  
  6.         ......  
  7.   
  8.         Looper.prepare();  
  9.   
  10.         // Critical services...  
  11.         try {  
  12.             ......  
  13.   
  14.             ContentService.main(context,  
  15.                 factoryTest == SystemServer.FACTORY_TEST_LOW_LEVEL);  
  16.   
  17.             ......  
  18.   
  19.         }catch (RuntimeException e) {  
  20.             ......  
  21.         }  
  22.   
  23.         ......  
  24.   
  25.         Looper.loop();  
  26.         ......  
  27.     }  
  28. }  
        ContentService类定义在frameworks/base/core/java/android/content/ContentService.java文件中，它的main函数的实现如下所示：
view plain
  1. public final class ContentService extends IContentService.Stub {  
  2.     ......  
  3.   
  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.     }  
  9.   
  10.     ......  
  11. }  
        从这里我们就可以看到，在ContentService类的main函数中，会创建一个ContentService实例，然后把它添加到ServiceManager中去，这样，ContentService服务就启动起来了，  其它地方可以通过ServiceManager来获得它的一个远程接口来使用它提供的服务。

        2. ContentObserver的注册过程分析

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

view plain
  1. public class MainActivity extends Activity implements View.OnClickListener, AdapterView.OnItemClickListener {  
  2.     ......  
  3.   
  4.     private ArticleAdapter adapter = null;  
  5.     private ArticleObserver observer = null;  
  6.   
  7.     ......  
  8.   
  9.     @Override  
  10.     public void onCreate(Bundle savedInstanceState) {  
  11.         super.onCreate(savedInstanceState);  
  12.         ......  
  13.   
  14.         observer = new ArticleObserver(new Handler());  
  15.         getContentResolver().registerContentObserver(Articles.CONTENT_URI, true, observer);  
  16.   
  17.         ......  
  18.     }  
  19.   
  20.     private class ArticleObserver extends ContentObserver {  
  21.         public ArticleObserver(Handler handler) {  
  22.             super(handler);  
  23.         }  
  24.   
  25.         @Override  
  26.         public void onChange (boolean selfChange) {  
  27.             adapter.notifyDataSetChanged();  
  28.         }  
  29.     }  
  30.   
  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文件中：

view plain
  1. public abstract class ContentResolver {  
  2.     ......  
  3.   
  4.     public final void 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.     }  
  13.   
  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文件中：

view plain
  1. public abstract class ContentResolver {  
  2.     ......  
  3.   
  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.     }  
  14.   
  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文件中：

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

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

        Step 5. ObserverNode.addObserverLocked

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

view plain
  1. public final class ContentService extends IContentService.Stub {  
  2.     ......  
  3.   
  4.     public static final class ObserverNode {  
  5.         ......  
  6.   
  7.         private String mName;  
  8.         private ArrayList<ObserverNode> mChildren = new ArrayList<ObserverNode>();  
  9.         private ArrayList<ObserverEntry> mObservers = new ArrayList<ObserverEntry>();  
  10.   
  11.         public ObserverNode(String name) {  
  12.             mName = name;  
  13.         }  
  14.   
  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.         }  
  26.   
  27.         private int countUriSegments(Uri uri) {  
  28.             if (uri == null) {  
  29.                 return 0;  
  30.             }  
  31.             return uri.getPathSegments().size() + 1;  
  32.         }  
  33.   
  34.         public void addObserverLocked(Uri uri, IContentObserver observer,  
  35.                 boolean notifyForDescendents, Object observersLock) {  
  36.             addObserverLocked(uri, 0, observer, notifyForDescendents, observersLock);  
  37.         }  
  38.   
  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.             }  
  46.   
  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.             }  
  60.   
  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.         }  
  66.   
  67.         ......  
  68.     }  
  69.   
  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中增加一个文章信息条目时：

view plain
  1. public class ArticlesAdapter {  
  2.     ......  
  3.   
  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());  
  9.   
  10.         Uri uri = resolver.insert(Articles.CONTENT_URI, values);  
  11.         String itemId = uri.getPathSegments().get(1);  
  12.   
  13.         return Integer.valueOf(itemId).longValue();  
  14.     }  
  15.   
  16.     ......  
  17. }  
        便会进入到应用程序ArticlesProvider中的ArticlesProvider类的insert函数中：
view plain
  1. public class ArticlesProvider extends ContentProvider {  
  2.     ......  
  3.   
  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.         }  
  9.   
  10.         SQLiteDatabase db = dbHelper.getWritableDatabase();  
  11.   
  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.         }  
  16.   
  17.         Uri newUri = ContentUris.withAppendedId(uri, id);  
  18.         resolver.notifyChange(newUri, null);  
  19.   
  20.         return newUri;  
  21.     }  
  22.   
  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，它监控的数据发生变化了：
view plain
  1. resolver.notifyChange(newUri, null);  
        下面我们就开始分析这个数据变化通知的发送过程，首先来看一下这个过程的时序图，然后再详细分析每一个步骤：


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

view plain
  1. public abstract class ContentResolver {  
  2.     ......  
  3.   
  4.     public void notifyChange(Uri uri, ContentObserver observer) {  
  5.         notifyChange(uri, observer, true /* sync to network */);  
  6.     }  
  7.   
  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.     }  
  16.   
  17.     ......  
  18. }  
        这里调用了ContentService的远接程口来调用它的notifyChange函数来发送数据更新通知。

        Step 2. ContentService.notifyChange

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

view plain
  1. public final class ContentService extends IContentService.Stub {  
  2.     ......  
  3.   
  4.     public void notifyChange(Uri uri, IContentObserver observer,  
  5.             boolean observerWantsSelfNotifications, boolean syncToNetwork) {  
  6.         ......  
  7.   
  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.     }  
  29.   
  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文件中：

view plain
  1. public final class ContentService extends IContentService.Stub {  
  2.     ......  
  3.   
  4.     public static final class ObserverNode {  
  5.         ......  
  6.   
  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);  
  13.   
  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.                 }  
  19.   
  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.         }  
  26.   
  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.             }  
  39.   
  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，于是就会调用下面语句：
view plain
  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，于是执行下面语句：

view plain
  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，于是执行下面语句：

view plain
  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，它们监控的数据发生变化了：

view plain
  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文件中：

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

        Step 5. ContentObserver.dispatchChange

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

view plain
  1. public abstract class ContentObserver {  
  2.     ......  
  3.   
  4.     public final void 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文件中：

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

        Step 7. ArticlesObserver.onChange

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

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

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


yzhang8703
关注
专栏目录
深入理解ContentProvider共享数据更新通知机制
kevin's cache的专栏
03-12 557
前面一篇文章 深入理解Android四大组件之一ContentProvider 讲了ContentProvider的简单使用和它的启动过程. 这里接着讲解一下关于ContentProvider共享数据更新通知机制. 数据更新通知是很有必要的,比如我们在第二个应用程序中添加了一个联系人(接着上一篇文章例子),返回到显示主界面时,我们不会去更新列表数据,所以就没有刚刚添加的联系人信息,这样数据不同步...
Android ContentProvider的使用
最新发布
xiaokangss的博客
08-17 1443
`ContentProvider`是Android中的一个组件，用于实现应用程序之间的数据共享。它提供了一种标准化的接口，允许应用程序访问和操作其他应用程序的数据。`ContentProvider`可以提供对数据的增删改查操作，并支持跨进程的数据共享。
linux基础编程 共享内存 通过消息队列实现同步 shmget
ghostyu的专栏
07-11 6344
共享内存可以被描述成内存一个区域(段)的映射，这个区域可以被更多的进程所共享。这是IPC机制中最快的一种形式，因为它不需要中间环节，而是把信息直接从一个内存段映射到调用进程的地址空间。 一个段可以直接由一个进程创建，随后，可以有任意多的进程对其读和写。但是，一旦内存被共享之后，对共享内存的访问同步需要由其他 IPC 机制，例如消息队列来实现。 包含文件 1、msg.c 2、msg.h 3、
解决Android11APP在后台时ContentObserver.onChange延时10秒的问题
Poployal
10-13 3181
延时源码： //services/core/java/com/android/server/content/ContentService.java public void dispatch() { for (int i = 0; i < collected.size(); i++) { final Key key = collected.keyAt(i); final List<Uri> value
Android应用程序组件Content Provider的共享数据更新通知机制分析.doc
07-08
分析Content Provider的数据更新机制，我们可以将其分为三个关键步骤： 1. **ContentService的启动过程**： 当Android系统启动时，Zygote进程会孵化出System进程，并在System进程中加载一系列关键服务，其中包括...
Android组件content provider使用解析
08-30
Android 组件 Content Provider 使用解析 ...Content Provider 是 Android 四大组件之一，提供了跨应用程序之间的数据共享机制，实现了统一的接口，简化了数据的存储和获取，并对数据进行封装，隐藏了数据存储的细节。
Content Provider在Android中的数据更新通知机制解析
"这篇文档详细分析了Android应用程序组件Content Provider的共享数据更新通知机制，探讨了Content Provider如何在不同应用间实现数据共享，并且对比了Content Provider的数据更新通知机制与Android广播机制的异同。...
解析Android应用程序运行机制
09-04
Content Provider则提供了数据共享和交换的机制。 总的来说，Android应用程序运行机制以Activity为中心，通过Activity Manager维护应用堆栈，支持用户友好且高效的多任务切换。同时，通过分离Activity和进程的生命...
Android应用程序之间数据共享ContentResolver.pdf
07-13
Android 应用程序之间数据共享是一种非常重要的机制，它允许不同的应用程序之间共享数据，并且提供了一个标准的接口来访问和操作这些共享数据。ContentResolver 是 Android 中一个非常重要的组件，它提供了一个统一...
Android App 开源项目使用统计
small-dream的博客
09-04 1703
Android的开源项目越来越来多，很多时候，我们选择开源项目时不知道选择哪个好，因此，我决定反编译当前一些用户量大，比较知名的App,看看他们是用了什么开源项目，一方面，在我们选择开源项目时可以参考，另一方面，也可以发现一些比较流行的开源项目，可以学习学习，对找工作用帮助。美团 ：JakeWharton/ViewPagerIndicator JakeWharton/NineOldAndroid
Android R ContentObserver内容变动通知延时
qq_33240707的博客
05-28 1659
frameworks/base/services/core/java/com/android/server/content/ContentService.java /** * Delay to apply to content change notifications dispatched to apps running * in the background. This is used to help prevent stampeding when the user * is performing
Content Providers--概述
Tibib的专栏
01-27 894
Content Providers 管理应用如何去访问一组结构化的数据，把数据压缩并为之提供安全机制。Content Providers 是一个固定的接口使两个进程之间的数据能够共享，当你想访问一个content provider提供的数据时，你可以在你的应用中使用ContentRessolver对象去和它交流，content provider接收你应用中ContentRessolver对象传过来
android 监听变量变化,Android 如何监听一个线程的开始和结束
weixin_28888459的博客
05-26 405
方法一：轮训比如主线程要等子线程在得到变量“val”值的时候开始用“val”的值来进行工作，使用轮训的方法如下：public classSubThread extends Thread{private boolean flag = false;//标志位，用来标识是否应该通知主线程或者其他对象改做事情了@Overridepublic voidrun() {super.run();for(int i...
使用ContentProvider（内容提供者）共享数据
adxj46627377的博客
08-23 241
ContentProvider 在android中的作用是对外共享数据，也就是说你可以通过ContentProvider把应用中的数据共享给其他应用访问，其他应用可以通过ContentProvider 对你应用中的数据进行添删改查。关于数据共享，以前我们学习过文件操作模式，知道通过指定文件的操作模式为Context.MODE_WORLD_READABLE 或Context.MODE_WO...
我的android 第26天 - 当ContentProvider中数据发生变化时向其用户发出通知
u012458883的专栏
12-12 843
我的android 第26天 - 当ContentProvider中数据发生变化时向其用户发出通知        如果ContentProvider的访问者需要得知ContentProvider中的数据发生了变化，可以在ContentProvider 发生数据变化时调用getContentResolver().notifyChange(uri, null)来通知注册在此URI上的访问
使用ContentProvider实现数据共享
u012906122的专栏
11-21 3282
Content Provider用于在不同的应用程序之间实现数据共享。应用程序使用一个ContentResolver对象去操作指定数据。 1 Content Provider概述 Content Provider实现一组通用的方法，用来提供数据的增、删、改、查功能。 应用程序通过调用Activity或其他组件类的getContentResolver()方法来获得ContentResolver对象。例如： ContentResolver resolver = getContentResolver(
【个人】Content Provider个人见解
wp6687的博客
07-23 443
草稿 每个Content Providers都会对外提供一个公共的URI(包装成Uri对象)，如果应用程序有数据需要共享时，就需要使用Content Providers为这些数据定义一个URI，然后其他的应用程序就可以通过Content Providers传入这个URI来对数据进行操作。URI由3个部分组成:"content://"、数据的路径、标识ID(可选)。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值