Step 1. ContentResolver.registerContentObserver 这个函数定义在frameworks/base/core/java/android/content/ContentResolver.java文件中： 
        
                
  1.            publicabstractclassContentResolver{     
    2.             
  2.            ......     
    3.             
  3.                 
    4.             
  4.            publicfinalvoidregisterContentObserver(Uriuri,booleannotifyForDescendents,     
    5.             
  5.            ContentObserverobserver)     
    6.             
  6.            {     
    7.             
  7.            try{     
    8.             
  8.            getContentService().registerContentObserver(uri,notifyForDescendents,     
    9.             
  9.            observer.getContentObserver());     
    10.             
  10.            }catch(RemoteExceptione){     
    11.             
  11.            }     
    12.             
  12.            }     
    13.             
  13.                 
    14.             
  14.            ......     
    15.             
  15.            }     
    16.
当参数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.            publicabstractclassContentResolver{     
    2.             
  2.            ......     
    3.             
  3.                 
    4.             
  4.            publicstaticIContentServicegetContentService(){     
    5.             
  5.            if(sContentService!=null){     
    6.             
  6.            returnsContentService;     
    7.             
  7.            }     
    8.             
  8.            IBinderb=ServiceManager.getService(CONTENT_SERVICE_NAME);     
    9.             
  9.            ......     
    10.             
  10.            sContentService=IContentService.Stub.asInterface(b);     
    11.             
  11.            ......     
    12.             
  12.            returnsContentService;     
    13.             
  13.            }     
    14.             
  14.                 
    15.             
  15.            privatestaticIContentServicesContentService;     
    16.             
  16.            ......     
    17.             
  17.            }     
    18.

在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.            publicabstractclassContentObserver{     
    2.             
  2.            ......     
    3.             
  3.                 
    4.             
  4.            privateTransportmTransport;     
    5.             
  5.                 
    6.             
  6.            ......     
    7.             
  7.                 
    8.             
  8.            privatestaticfinalclassTransportextendsIContentObserver.Stub{     
    9.             
  9.            ContentObservermContentObserver;     
    10.             
  10.                 
    11.             
  11.            publicTransport(ContentObservercontentObserver){     
    12.             
  12.            mContentObserver=contentObserver;     
    13.             
  13.            }     
    14.             
  14.                 
    15.             
  15.            ......     
    16.             
  16.            }     
    17.             
  17.                 
    18.             
  18.            ......     
    19.             
  19.                 
    20.             
  20.            publicIContentObservergetContentObserver(){     
    21.             
  21.            synchronized(lock){     
    22.             
  22.            if(mTransport==null){     
    23.             
  23.            mTransport=newTransport(this);     
    24.             
  24.            }     
    25.             
  25.            returnmTransport;     
    26.             
  26.            }     
    27.             
  27.            }     
    28.             
  28.                 
    29.             
  29.            ......     
    30.             
  30.            }     
    31.

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.            publicfinalclassContentServiceextendsIContentService.Stub{     
    2.             
  2.            ......     
    3.             
  3.                 
    4.             
  4.            privatefinalObserverNodemRootNode=newObserverNode("");     
    5.             
  5.                 
    6.             
  6.            ......     
    7.             
  7.                 
    8.             
  8.            publicvoidregisterContentObserver(Uriuri,booleannotifyForDescendents,     
    9.             
  9.            IContentObserverobserver){     
    10.             
  10.            ......     
    11.             
  11.                 
    12.             
  12.            synchronized(mRootNode){     
    13.             
  13.            mRootNode.addObserverLocked(uri,observer,notifyForDescendents,mRootNode);     
    14.             
  14.            ......     
    15.             
  15.            }     
    16.             
  16.            }     
    17.             
  17.                 
    18.             
  18.            ......     
    19.             
  19.            }     
    20.

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

Step 5.ObserverNode.addObserverLocked 这个函数定义在frameworks/base/core/java/android/content/ContentService.java文件中： 
        
                
  1.            publicfinalclassContentServiceextendsIContentService.Stub{     
    2.             
  2.            ......     
    3.             
  3.                 
    4.             
  4.            publicstaticfinalclassObserverNode{     
    5.             
  5.            ......     
    6.             
  6.                 
    7.             
  7.            privateStringmName;     
    8.             
  8.            privateArrayList<ObserverNode>mChildren=newArrayList<ObserverNode>();     
    9.             
  9.            privateArrayList<ObserverEntry>mObservers=newArrayList<ObserverEntry>();     
    10.             
  10.                 
    11.             
  11.            publicObserverNode(Stringname){     
    12.             
  12.            mName=name;     
    13.             
  13.            }     
    14.             
  14.                 
    15.             
  15.            privateStringgetUriSegment(Uriuri,intindex){     
    16.             
  16.            if(uri!=null){     
    17.             
  17.            if(index==0){     
    18.             
  18.            returnuri.getAuthority();     
    19.             
  19.            }else{     
    20.             
  20.            returnuri.getPathSegments().get(index-1);     
    21.             
  21.            }     
    22.             
  22.            }else{     
    23.             
  23.            returnnull;     
    24.             
  24.            }     
    25.             
  25.            }     
    26.             
  26.                 
    27.             
  27.            privateintcountUriSegments(Uriuri){     
    28.             
  28.            if(uri==null){     
    29.             
  29.            return0;     
    30.             
  30.            }     
    31.             
  31.            returnuri.getPathSegments().size()+1;     
    32.             
  32.            }     
    33.             
  33.                 
    34.             
  34.            publicvoidaddObserverLocked(Uriuri,IContentObserverobserver,     
    35.             
  35.            booleannotifyForDescendents,ObjectobserversLock){     
    36.             
  36.            addObserverLocked(uri,0,observer,notifyForDescendents,observersLock);     
    37.             
  37.            }     
    38.             
  38.                 
    39.             
  39.            privatevoidaddObserverLocked(Uriuri,intindex,IContentObserverobserver,     
    40.             
  40.            booleannotifyForDescendents,ObjectobserversLock){     
    41.             
  41.            //Ifthisistheleafnodeaddtheobserver     
    42.             
  42.            if(index==countUriSegments(uri)){     
    43.             
  43.            mObservers.add(newObserverEntry(observer,notifyForDescendents,observersLock));     
    44.             
  44.            return;     
    45.             
  45.            }     
    46.             
  46.                 
    47.             
  47.            //Looktoseeiftheproperchildalreadyexists     
    48.             
  48.            Stringsegment=getUriSegment(uri,index);     
    49.             
  49.            if(segment==null){     
    50.             
  50.            thrownewIllegalArgumentException("InvalidUri("+uri+")usedforobserver");     
    51.             
  51.            }     
    52.             
  52.            intN=mChildren.size();     
    53.             
  53.            for(inti=0;i<N;i++){     
    54.             
  54.            ObserverNodenode=mChildren.get(i);     
    55.             
  55.            if(node.mName.equals(segment)){     
    56.             
  56.            node.addObserverLocked(uri,index+1,observer,notifyForDescendents,observersLock);     
    57.             
  57.            return;     
    58.             
  58.            }     
    59.             
  59.            }     
    60.             
  60.                 
    61.             
  61.            //Nochildfound,createone     
    62.             
  62.            ObserverNodenode=newObserverNode(segment);     
    63.             
  63.            mChildren.add(node);     
    64.             
  64.            node.addObserverLocked(uri,index+1,observer,notifyForDescendents,observersLock);     
    65.             
  65.            }     
    66.             
  66.                 
    67.             
  67.            ......     
    68.             
  68.            }     
    69.             
  69.                 
    70.             
  70.            ......     
    71.             
  71.            }     
    72.

从这里我们就可以看出，注册到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的注册过程就完成了。

更多相关文章

  1. C语言函数以及函数的使用
  2. [Android Studio] Android Studio如何提示函数用法
  3. 设置环境变量ANDROID_SDK_HOME有什么用？
  4. android 调用draw(canvas) 函数自动退出
  5. Xposed框架之函数Hook学习
  6. Android用Application设置全局变量以及使用
  7. android中去掉空格--trim函数
  8. android adb配置环境变量
  9. Android三角函数

随机推荐

  1. Android的webview研究
  2. android各sdk，cpu_img,source,doc下载
  3. Android(安卓)AsyncTask介绍
  4. Android(安卓)DVM [1]
  5. Android--取得MD5指纹，取得MapKey
  6. Android(安卓)SDK 2.2 离线安装
  7. Android推送通知指南
  8. android开发（二）：android结构
  9. Android入门教程(二)之------环境搭建
  10. android EditText中的inputType