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

        3. 数据更新通知的发送过程

       在前面这篇文章 Android应用程序组件Content Provider应用实例 介绍的应用程序Acticle中，当调用ArticlesAdapter类的insertArticle往ArticlesProvider中增加一个文章信息条目时：

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函数中：

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

1. resolver.notifyChange(newUri, null);   

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

 

 

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

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

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

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，于是就会调用下面语句：

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

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

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

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函数中去。