Step 1. ContentResolver.registerContentObserver
        这个函数定义在frameworks/base/core/java/android/content/ContentResolver.java文件中:
  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文件中:
  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文件中:
  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文件中:
  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文件中:
  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的注册过程就完成了。