提示这两个Service的难度都不大，它们在设计结构上有较大的相似性，在内容上也有一定的关联。另外，作为本书最后一章，笔者照例会留一些难度适中的问题或知识点供读者自行分析研究。

提示在设计模式中，通知机制对应的模式是Observer模式，即观察者模式。

public void run() {

   ......

  ContentService.main(context,

                   factoryTest == SystemServer.FACTORY_TEST_LOW_LEVEL);

   ......

public static IContentService main(Contextcontext, boolean factoryTest) {

   //构造ContentService实例

  ContentService service = new ContentService(context, factoryTest);

   //将ContentService注册到ServiceManager中，其注册名叫“content”

  ServiceManager.addService(ContentResolver.CONTENT_SERVICE_NAME,

                                 service);

   returnservice;

ContentService(Context context, booleanfactoryTest) {

    mContext = context;

   mFactoryTest = factoryTest;

    getSyncManager(); //获取同步服务管理对象，接下来看它的代码

private SyncManager getSyncManager() {

   synchronized(mSyncManagerLock) {

          //创建一个SyncManager实例，它是ContentService中负责数据同步服务的

          //主力成员。留待8.4节再详细分析它

           if (mSyncManager == null) mSyncManager = new

                                        SyncManager(mContext,mFactoryTest);

       }......

           return mSyncManager;

public final void registerContentObserver(Uri uri,

            booleannotifyForDescendents,ContentObserver observer){

   注意registerContentObserver传递的参数，其中：

   uri是客户端设置的它所需要监听的数据项的地址，用Uri来表示

   notifyForDescendents：如果该值为true，则所有地址包含此uri的数据项发生变化时

   都会触发通知。否则只有完全符合该uri地址的数据项发生变化时才会触发通知。以文件夹和

   其中的文件为例，若uri指向某文件夹，则需设置notifyForDescendents为true。即该文件

   夹下的任何文件发生变化，都需要通知监听者。

   observer是客户端设置的监听对象。当数据项发生变化时，该对象的onChange函数将被调用

            调用ContentService的registerContentObserver函数，其第三个参数是

             observer.getContentObserver的返回值，它是什么呢？

           getContentService().registerContentObserver(uri,

                                   notifyForDescendents,

                                   observer.getContentObserver());

        } ......

注意IContentObserver.java由aidl处理IContentObserver.aidl生成，其位置在out/targer/common/obj/JAVA_LIBRARIES/framework_intermediates/src/core/java/android/database/IContentObserver.java中。

public void registerContentObserver(Uri uri,boolean notifyForDescendents,

               IContentObserver observer) {

     ......

   synchronized (mRootNode) {

    //ContentService要做的事情其实很简单，就是保存uri和observer的对应关系到

     //其内部变量mRootNode中

    mRootNode.addObserverLocked(uri, observer, notifyForDescendents,

                    mRootNode, Binder.getCallingUid(),

                   Binder.getCallingPid());

public int update(Uri uri, ContentValuesinitialValues, String userWhere,

                     String[] whereArgs) {

   int count;

   int match= URI_MATCHER.match(uri);

  DatabaseHelper database = getDatabaseForUri(uri);

   //找到对应的数据库对象

  SQLiteDatabase db = database.getWritableDatabase();

   ......

   synchronized (sGetTableAndWhereParam) {

    getTableAndWhere(uri, match, userWhere, sGetTableAndWhereParam);

     switch(match) {

         ......

        case VIDEO_MEDIA:

        case VIDEO_MEDIA_ID:{

          ContentValues values = newContentValues(initialValues);

          values.remove(ImageColumns.BUCKET_ID);

          values.remove(ImageColumns.BUCKET_DISPLAY_NAME);

          ......//调用SQLiteDatabase的update函数更新数据库

          count =db.update(sGetTableAndWhereParam.table, values,

                               sGetTableAndWhereParam.where, whereArgs);

         .......

         }......//其他处理

     }......//synchronized处理结束

    if (count > 0 &&!db.inTransaction()) //调用notifyChange触发通知

        getContext().getContentResolver().notifyChange(uri,null);

   returncount;

public void notifyChange(Uri uri, ContentObserverobserver) {

     //在一般情况下，observer参数为null。调用另一个notifyChange函数，直接来看它

    notifyChange(uri, observer, true);

public void notifyChange(Uri uri, ContentObserverobserver,

                               boolean syncToNetwork) {

  //第三个参数syncToNetwork用于控制是否需要发起一次数据同步请求

       //调用ContentService的notifyChange函数

       getContentService().notifyChange(

             uri, observer == null ? null : observer.getContentObserver(),

             observer != null && observer.deliverSelfNotifications(),

             syncToNetwork);

        } ......

public void notifyChange(Uri uri, IContentObserverobserver,

     boolean observerWantsSelfNotifications, boolean syncToNetwork) {

  longidentityToken = clearCallingIdentity();

         ArrayList<ObserverCall> calls = newArrayList<ObserverCall>();

          //从根节点开始搜索需要通知的观察者，结果保存在calls数组中

         synchronized (mRootNode) {

               mRootNode.collectObserversLocked(uri, 0, observer,

                               observerWantsSelfNotifications,calls);

        final int numCalls = calls.size();

         for(int i=0; i<numCalls; i++) {

              ObserverCall oc = calls.get(i);

                     调用客户端IContentObserver Bn端，即ContentObserver

                     内部类Transport的onChange函数。最后再由Transport调用

                     客户端提供的ContentObserver子类的onChange函数

                   oc.mObserver.onChange(oc.mSelfNotify);

               } ......//异常处理

           if (syncToNetwork) {

               SyncManager syncManager = getSyncManager();

               if (syncManager != null) {

                   //发起一次同步请求，相关内容留待8.4节再分析

                   syncManager.scheduleLocalSync(null,

                                           uri.getAuthority());

        }finally {

           restoreCallingIdentity(identityToken);

private static class Proxy implementsandroid.database.IContentObserver {

     privateandroid.os.IBinder mRemote;

     ......

     publicvoid onChange(boolean selfUpdate)

                      throws android.os.RemoteException {

        android.os.Parcel_data = android.os.Parcel.obtain();

           _data.writeInterfaceToken(DESCRIPTOR);

           _data.writeInt(((selfUpdate)? (1) : (0)));

          //调用客户端1的ContentObserver Bn端的onChange函数

           mRemote.transact(Stub.TRANSACTION_onChange,_data, null,

                                        android.os.IBinder.FLAG_ONEWAY);

        } finally {

            _data.recycle();

     ......

public booleanonPreferenceTreeClick(PreferenceScreen preferenceScreen,

                             Preference preference) {

   ......

   if(preference == mMtp) {

        mUsbManager.setCurrentFunction(UsbManager.USB_FUNCTION_MTP,true);

       updateToggles(UsbManager.USB_FUNCTION_MTP);

   } else if(preference == mPtp) {

        mUsbManager.setCurrentFunction(UsbManager.USB_FUNCTION_PTP, true);

         updateToggles(UsbManager.USB_FUNCTION_PTP);

   returntrue;

public void onClick(DialogInterface dialog, intwhich) {

  if (which == DialogInterface.BUTTON_POSITIVE){

       mOkClicked = true;

       //设置Settings数据库ADB对应的数据项值为1

       Settings.Secure.putInt(getActivity().getContentResolver(),

                   Settings.Secure.ADB_ENABLED, 1);

   } else

       mEnableAdb.setChecked(false);//界面更新

private class AdbSettingsObserver extendsContentObserver {

   ......

   publicvoid onChange(boolean selfChange) {

        //从数据库中取出对应项的值

        boolean enable =(Settings.Secure.getInt(mContentResolver,

                            Settings.Secure.ADB_ENABLED, 0) > 0);

          //发送MSG_ENABLE_ADB消息，UsbDeviceManager将处理此消息

           mHandler.sendMessage(MSG_ENABLE_ADB, enable);

  ......

  //注册AccountManagerService到ServiceManager，服务名为“account”

  ServiceManager.addService(Context.ACCOUNT_SERVICE,

                                    newAccountManagerService(context));

public AccountManagerService(Context context) {

   //调用另外一个构造函数，其第三个参数将构造一个AccountAuthenticatorCache对象，它是

   //什么呢？见下文分析

   this(context,context.getPackageManager(),

            new  AccountAuthenticatorCache(context));

public AccountAuthenticatorCache(Context context){

  ACTION_AUTHENTICATOR_INTENT值为"android.accounts.AccountAuthenticator"

  AUTHENTICATOR_META_DATA_NAME值为"android.accounts.AccountAuthenticator"

  AUTHENTICATOR_ATTRIBUTES_NAME值为"account-authenticator"

  super(context,

           AccountManager.ACTION_AUTHENTICATOR_INTENT,

          AccountManager.AUTHENTICATOR_META_DATA_NAME,

          AccountManager.AUTHENTICATOR_ATTRIBUTES_NAME, sSerializer);

public RegisteredServicesCache(Context context,String interfaceName,

                                     StringmetaDataName, String attributeName,

                            XmlSerializerAndParser<V>serializerAndParser) {

    mContext= context;

    //保存传递进来的参数

   mInterfaceName = interfaceName;

   mMetaDataName = metaDataName;

   mAttributesName = attributeName;

   mSerializerAndParser = serializerAndParser;

    FiledataDir = Environment.getDataDirectory();

    FilesystemDir = new File(dataDir, "system");

   //syncDir指向/data/system/registered_service目录

    FilesyncDir = new File(systemDir, "registered_services");

    //下面这个文件指向syncDir目录下的android.accounts.AccountAuthenticator.xml

   mPersistentServicesFile = new AtomicFile(new File(syncDir,

                                          interfaceName+ ".xml"));

    //生成服务信息

   generateServicesMap();

    finalBroadcastReceiver receiver = new BroadcastReceiver() {

      public void onReceive(Context context1, Intent intent) {

         generateServicesMap();

    //注册Package安装、卸载和更新等广播监听者

   mReceiver = new AtomicReference<BroadcastReceiver>(receiver);

    IntentFilter intentFilter = newIntentFilter();

   intentFilter.addAction(Intent.ACTION_PACKAGE_ADDED);

   intentFilter.addAction(Intent.ACTION_PACKAGE_CHANGED);

   intentFilter.addAction(Intent.ACTION_PACKAGE_REMOVED);

   intentFilter.addDataScheme("package");

   mContext.registerReceiver(receiver, intentFilter);

    IntentFilter sdFilter = new IntentFilter();

   sdFilter.addAction(Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE);

   sdFilter.addAction(Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE);

   mContext.registerReceiver(receiver, sdFilter);

void generateServicesMap() {

   //获取PackageManager接口，用来和PackageManagerService交互

  PackageManager pm = mContext.getPackageManager();

  ArrayList<ServiceInfo<V>> serviceInfos = newArrayList<ServiceInfo<V>>();

   在本例中，查询PKMS中满足Intent Action为"android.accounts.AccountAuthenticator"

   的服务信息。由以下代码可知，这些信息指的是Service中声明的MetaData信息

  List<ResolveInfo> resolveInfos = pm.queryIntentServices(

               new Intent(mInterfaceName),PackageManager.GET_META_DATA);

   for(ResolveInfo resolveInfo : resolveInfos) {

            调用parserServiceInfo函数解析从PKMS中获得的MetaData信息，该函数

            返回的是一个模板类对象。就本例而言，这个函数返回一个

            ServiceInfo<AccountAuthenticator>类型的对象

          ServiceInfo<V> info = parseServiceInfo(resolveInfo);

          serviceInfos.add(info);

   synchronized (mServicesLock) {

       if(mPersistentServices == null)

           readPersistentServicesLocked();

      mServices = Maps.newHashMap();

      StringBuilder changes = new StringBuilder();

       ......//检查mPersistentServices保存的服务信息和当前从PKMS中取出来的PKMS

      //信息，判断是否有变化，如果有变化，需要通知监听者。读者可自行阅读这段代码，

     //注意其中uid的作用

       mPersistentServicesFileDidNotExist = false;

private ServiceInfo<V>parseServiceInfo(ResolveInfo service)

                     throws XmlPullParserException, IOException {

  android.content.pm.ServiceInfo si = service.serviceInfo;

  ComponentName componentName = new ComponentName(si.packageName, si.name);

  PackageManager pm = mContext.getPackageManager();

  XmlResourceParser parser = null;

        //解析MetaData信息

       parser = si.loadXmlMetaData(pm, mMetaDataName);

       AttributeSet attrs = Xml.asAttributeSet(parser);

        inttype;

       ......

      StringnodeName = parser.getName();

      //调用子类实现的parseServiceAttributes得到一个真实的对象，在本例中它是

      //AuthenticatorDescription。注意，传递给parseServiceAttributes的第一个

      //参数代表MetaData中的resource信息。详细内容见下文的图例

     V v=parseServiceAttributes(

                     pm.getResourcesForApplication(si.applicationInfo),

                    si.packageName, attrs);

    finalandroid.content.pm.ServiceInfo serviceInfo = service.serviceInfo;

    finalApplicationInfo applicationInfo = serviceInfo.applicationInfo;

    finalint uid = applicationInfo.uid;

    returnnew ServiceInfo<V>(v, componentName, uid);

   } ...... finally {

           if (parser != null) parser.close();

提示uid是在为PackageManagerService解析APK文件时赋予APK的。读者不妨自行阅读frameworks/base/services/java/com/android/server/pm/Settings.java中的newUserIdLPw函数。

public AccountManagerService(Context context,PackageManager packageManager,

           IAccountAuthenticatorCache authenticatorCache) {

    mContext= context;

   mPackageManager = packageManager;

  synchronized (mCacheLock) {

      //此数据库文件对应为/data/system/accounts.db

     mOpenHelper = new DatabaseHelper(mContext);

  mMessageThread = new HandlerThread("AccountManagerService");

  mMessageThread.start();

  mMessageHandler = new MessageHandler(mMessageThread.getLooper());

  mAuthenticatorCache = authenticatorCache;

   //为AccountAuthenticatorCache设置一个监听者，一旦AAS服务发生变化，

  //AccountManagerService需要做对应处理

  mAuthenticatorCache.setListener(this, null /* Handler */);

  sThis.set(this);

   //监听ACTION_PACKAGE_REMOVED广播

  IntentFilter intentFilter = new IntentFilter();

  intentFilter.addAction(Intent.ACTION_PACKAGE_REMOVED);

  intentFilter.addDataScheme("package");

  mContext.registerReceiver(new BroadcastReceiver() {

   publicvoid onReceive(Context context1, Intent intent) {

       purgeOldGrants();

   },intentFilter);

    accounts.db数据库中有一个grants表，用于存储授权信息，该信息用于保存哪些Package

    有权限获取账户信息。下面的函数将根据grants表中的数据查询PKMS，以判断这些

    Package是否还存在。如果系统中已经不存在这些Package，则grants表需要更新

   purgeOldGrants();

  accounts.db中有一个accounts表，该表中存储了账户类型和账户名。其中，账户类型

   就是AuthenticatorDescription中的accountType，它和具体应用有关。下面这个

   函数将比较accounts表中的内容与AccountAuthenticatorCache中服务的信息，如果

   AccountAuthenticatorCache已经不存在对应账户类型的服务，则需要删除accounts表

   中的对应项

  validateAccountsAndPopulateCache();

public AccountManagerFuture<Bundle>addAccount(

   finalString accountType,

   finalString authTokenType,

   finalString[] requiredFeatures,

   finalBundle addAccountOptions,

   finalActivity activity,

   AccountManagerCallback<Bundle>callback,

   Handlerhandler)

public AccountManagerFuture<Bundle>addAccount(final String accountType,

     finalString authTokenType, final String[] requiredFeatures,

     finalBundle addAccountOptions, final Activity activity,

    AccountManagerCallback<Bundle> callback, Handler handler) {

    if(accountType == null) //accountType不能为null

            thrownew IllegalArgumentException("accountType is null");

   finalBundle optionsIn = new Bundle();

   if(addAccountOptions != null)//保存客户端传入的addAccountOptions

      optionsIn.putAll(addAccountOptions);

  optionsIn.putString(KEY_ANDROID_PACKAGE_NAME,

                        mContext.getPackageName());

    //构造一个匿名类对象，该类继承自AmsTask，并实现了doWork函数。addAccount返回前

    //将调用该对象的start函数

    returnnew AmsTask(activity, handler, callback) {

      publicvoid doWork() throws RemoteException {

           //mService用于和AccountManagerService通信

           mService.addAcount(mResponse, accountType, authTokenType,

                     requiredFeatures, activity!= null, optionsIn);

      }.start();

public AmsTask(Activity activity, Handler handler,

                       AccountManagerCallback<Bundle> callback){

   ......//调用基类构造函数

   //保存客户端传递的参数

    mHandler= handler;

   mCallback = callback;

   mActivity = activity;

   mResponse = new Response();//构造一个Response对象，并保存到mResponse中

public final AccountManagerFuture<Bundle>start() {

          doWork(); //调用匿名类实现的doWork函数

     }......

    returnthis;

public void doWork() throws RemoteException {

   //调用AccountManagerService的addAccount函数，其第一个参数是mResponse

   mService.addAcount(mResponse, accountType, authTokenType,

           requiredFeatures, activity != null, optionsIn);

public void addAcount(finalIAccountManagerResponse response,

        finalString accountType, final String authTokenType,

       final String[] requiredFeatures, final boolean expectActivityLaunch,

       final Bundle optionsIn) {

   ......

   //检查客户端进程是否有“android.permission.MANAGE_ACCOUNTS”的权限

   checkManageAccountsPermission();

   final intpid = Binder.getCallingPid();

   final intuid = Binder.getCallingUid();

   //构造一个Bundle类型的options变量，并保存传入的optionsIn

   finalBundle options = (optionsIn == null) ? new Bundle() : optionsIn;

  options.putInt(AccountManager.KEY_CALLER_UID, uid);

  options.putInt(AccountManager.KEY_CALLER_PID, pid);

    longidentityToken = clearCallingIdentity();

          //创建一个匿名类对象，该匿名类派生自Session类。最后调用该匿名类的bind函数

          new Session(response, accountType, expectActivityLaunch,true){

             public void run() throws RemoteException {

                mAuthenticator.addAccount(this, mAccountType,

                           authTokenType,requiredFeatures, options);

               protected String toDebugString(longnow) {

                   ......//实现toDebugString函数

           }.bind();

        }finally {

           restoreCallingIdentity(identityToken);

public Session(IAccountManagerResponse response,String accountType,

      boolean expectActivityLaunch, boolean stripAuthTokenFromResult) {

      super();

       ......

       注意其中的参数，expectActivityLaunch由客户端传来，如果用户调用

       AccountManager addAccount时传入了activity参数，则该值为true，

       stripAuthTokenFromResult的默认值为true

      mStripAuthTokenFromResult = stripAuthTokenFromResult;

       mResponse = response;

      mAccountType = accountType;

      mExpectActivityLaunch = expectActivityLaunch;

      mCreationTime = SystemClock.elapsedRealtime();

       synchronized(mSessions) {

          //将这个匿名类对象保存到AccountManagerService中的mSessions成员中

          mSessions.put(toString(), this);

        try{  //监听客户端死亡消息

               response.asBinder().linkToDeath(this, 0);

          } ......

void bind() {

   //绑定到mAccountType指定的AAS。在本例中，AAS的类型是“com.android.email”

   if(!bindToAuthenticator(mAccountType)) {

      onError(AccountManager.ERROR_CODE_REMOTE_EXCEPTION, "bindfailure");

private boolean bindToAuthenticator(StringauthenticatorType) {

    //从mAuthenticatorCache中查询满足指定类型的服务信息

   AccountAuthenticatorCache.ServiceInfo<AuthenticatorDescription>

            authenticatorInfo =

             mAuthenticatorCache.getServiceInfo(

                           AuthenticatorDescription.newKey(authenticatorType));

   ......

    Intentintent = new Intent();

   intent.setAction(AccountManager.ACTION_AUTHENTICATOR_INTENT);

    //设置目标服务的ComponentName

   intent.setComponent(authenticatorInfo.componentName);

     //通过bindService启动指定的服务，成功与否将通过第二个参数传递的

    //ServiceConnection接口返回

    if(!mContext.bindService(intent, this, Context.BIND_AUTO_CREATE)) {

          ......

     returntrue;

public void onServiceConnected(ComponentName name,IBinder service) {

   //得到远端AAS返回的IAccountAuthenticator接口，这个接口用于

  //AccountManagerService和该远端AAS交互

   mAuthenticator = IAccountAuthenticator.Stub.asInterface(service);

           run();//调用匿名类实现的run函数

     } ......

new Session(response, accountType,expectActivityLaunch,true) {

     publicvoid run() throws RemoteException {

          //调用远端AAS实现的addAccount函数

         mAuthenticator.addAccount(this, mAccountType,

                            authTokenType, requiredFeatures,options);

public IBinder onBind(Intent intent) {

  if(AccountManager.ACTION_AUTHENTICATOR_INTENT.equals(

                                intent.getAction())){

       //创建一个EasAuthenticator类型的对象，并调用其getIBinder函数

      return new EasAuthenticator(this).getIBinder();

   }else  return null;

private class Transport extendsIAccountAuthenticator.Stub {

   publicvoid addAccount(IAccountAuthenticatorResponse response,

               String accountType, String authTokenType,

               String[] features, Bundle options)

               throws RemoteException {

     //检查权限

    checkBinderPermission();

           //调用AbstractAccountAuthenticator子类实现的addAccount函数

           final Bundle result =

                AbstractAccountAuthenticator.this.addAccount(

                   new AccountAuthenticatorResponse(response),

                        accountType,authTokenType, features, options);

               //如果返回的result不为空，则调用response的onResult返回结果。

              //这个response是IAccountAuthenticatorResponse类型，它的onResult

              //将触发位于Session匿名类中mResponse变量的onResult函数被调用

              if (result != null)

                   response.onResult(result);

       }......

public BundleaddAccount(AccountAuthenticatorResponse response,

               String accountType, StringauthTokenType,

               String[] requiredFeatures, Bundle options)

               throws NetworkErrorException {

    //EasAuthenticatoraddAccount的处理逻辑和Email应用有关。只做简单了解即可

    //如果用户传递的账户信息保护了密码和用户名，则走if分支。注意，其中有一些参数名是

    //通用的，例如OPTIONS_PASSWORD，OPTIONS_USERNAME等

    if(options != null && options.containsKey(OPTIONS_PASSWORD)

                   && options.containsKey(OPTIONS_USERNAME)) {

     //创建一个Account对象，该对象仅包括两个成员，一个是name，用于表示账户名；

    //另一个是type，用于表示账户类型

     finalAccount account = new

                           Account(options.getString(OPTIONS_USERNAME),

                       AccountManagerTypes.TYPE_EXCHANGE);

    //调用AccountManager的addAccountExplicitly将account对象和password传递

    //给AccountManagerService处理。读者可自行研究这个函数，在其内部将这些信息写入

   //accounts.db的account表中

     AccountManager.get(EasAuthenticatorService.this).

                     addAccountExplicitly(account,

                        options.getString(OPTIONS_PASSWORD), null);

    //根据Email应用的规则，下面将判断和该账户相关的数据是否需要设置自动数据同步

    //首先判断是否需要处理联系人自动数据同步

     booleansyncContacts = false;

      if(options.containsKey(OPTIONS_CONTACTS_SYNC_ENABLED) &&

            options.getBoolean(OPTIONS_CONTACTS_SYNC_ENABLED))

                   syncContacts = true;

     ContentResolver.setIsSyncable(account,

                       ContactsContract.AUTHORITY,1);

    ContentResolver.setSyncAutomatically(account,

                           ContactsContract.AUTHORITY,syncContacts);

     booleansyncCalendar = false;

     ......//判断是否需要设置Calendar自动数据同步

     booleansyncEmail = false;

    //如果选项中包含Email同步相关的功能，则需要设置Email数据同步的相关参数

    if(options.containsKey(OPTIONS_EMAIL_SYNC_ENABLED) &&

          options.getBoolean(OPTIONS_EMAIL_SYNC_ENABLED))

          syncEmail = true;

     下面这两个函数将和ContentService中的SyncManager交互。注意这

     两个函数：第一个函数setIsSyncable将设置Email对应的同步服务功能标志，

     第二个函数setSyncAutomatically将设置是否自动同步Email。

     数据同步的内容留待8.4节再详细分析

     ContentResolver.setIsSyncable(account,EmailContent.AUTHORITY, 1);

     ContentResolver.setSyncAutomatically(account,EmailContent.AUTHORITY,

                                                    syncEmail);

     //构造返回结果，注意，下面这些参数名是Android统一定义的，如KEY_ACCOUNT_NAME等

     Bundleb = new Bundle();

     b.putString(AccountManager.KEY_ACCOUNT_NAME,

                              options.getString(OPTIONS_USERNAME));

   b.putString(AccountManager.KEY_ACCOUNT_TYPE,

                                AccountManagerTypes.TYPE_EXCHANGE);

    returnb;

   } else {

        //如果没有传递password，则需要启动一个Activity，该Activity对应的Intent

        //由actionSetupExchangeIntent返回。注意下面几个通用的参数,如

        // KEY_ACCOUNT_AUTHENTICATOR_RESPONSE和KEY_INTENT

       Bundle b = new Bundle();

       Intent intent =AccountSetupBasics.actionSetupExchangeIntent(

                                         EasAuthenticatorService.this);

        intent.putExtra(

                AccountManager.KEY_ACCOUNT_AUTHENTICATOR_RESPONSE, response);

        b.putParcelable(AccountManager.KEY_INTENT,intent);

       return b;

public void onResult(Bundle result) {

   mNumResults++;

    //从返回的result中取出相关信息，关于下面这个if分支处理和状态栏中相关的逻辑，

   //读者可自行研究    if (result != null&&!TextUtils.isEmpty(

               result.getString(AccountManager.KEY_AUTHTOKEN))) {

       String accountName = result.getString(AccountManager.KEY_ACCOUNT_NAME);

       String accountType =

              result.getString(AccountManager.KEY_ACCOUNT_TYPE);

         if(!TextUtils.isEmpty(accountName) &&

                         !TextUtils.isEmpty(accountType)){

           Account account = new Account(accountName, accountType);

            cancelNotification(

                     getSigninRequiredNotificationId(account));

   IAccountManagerResponse response;

   //如果客户端传递了activity参数，则mExpectActivityLaunch为true。如果

  //AAS返回的结果中包含KEY_INTENT，则表明需要弹出Activity以输入账户和密码

   if(mExpectActivityLaunch && result != null

                   && result.containsKey(AccountManager.KEY_INTENT)) {

        response = mResponse;

    } else {

         getResponseAndClose返回的也是mResponse，不过它会调用unBindService

         断开和AAS服务的连接。就整个流程而言，此时addAccount已经完成AAS和

       AccountManagerService的工作，故无需再保留和AAS服务的连接。而由于上面的if

        分支还需要输入用户密码，因此以AAS和AccountManagerService之间的工作

        还没有真正完成

       response = getResponseAndClose();

    if(response != null) {

               ......

               if (mStripAuthTokenFromResult)

                     result.remove(AccountManager.KEY_AUTHTOKEN);

               //调用位于客户端的IAccountManagerResponse的onResult函数

               response.onResult(result);

          } ......

public void onResult(Bundle bundle) {

    Intentintent = bundle.getParcelable(KEY_INTENT);

    //如果需要弹出Activity，则要利用客户端传入的那个activity去启动AAS指定的

   //Activity。这个Activity由AAS返回的Intent来表示

    if(intent != null && mActivity != null) {

         mActivity.startActivity(intent);

     } elseif (bundle.getBoolean("retry")) {

          //如果需要重试，则再次调用doWork

                  doWork();

           }......

       }else{

         //将返回结果保存起来，当客户端调用getResult时，就会得到相关结果

          set(bundle);

public SyncManager(Context context, booleanfactoryTest) {

   mContext= context;

  //SyncManager中的几位重要成员登场。见下文的解释

  SyncStorageEngine.init(context);

   mSyncStorageEngine =SyncStorageEngine.getSingleton();

   mSyncAdapters = newSyncAdaptersCache(mContext);

   mSyncQueue = newSyncQueue(mSyncStorageEngine, mSyncAdapters);

   HandlerThread syncThread = newHandlerThread("SyncHandlerThread",

                          Process.THREAD_PRIORITY_BACKGROUND);

  syncThread.start();

  mSyncHandler = new SyncHandler(syncThread.getLooper());

  mMainHandler = new Handler(mContext.getMainLooper());

    mSyncAdapters类似AccountManagerService中的AccountAuthenticatorCache，

    它用于管理系统中和SyncService相关的服务信息。下边的函数为mSyncAdapters增加一个

    监听对象，一旦系统中的SyncService发生变化（例如安装了一个提供同步服务的APK包），则

    SyncManager需要针对该服务发起一次同步请求。同步请求由scheduleSync函数发送，

    后文再分析此函数

  mSyncAdapters.setListener(new

             RegisteredServicesCacheListener<SyncAdapterType>() {

           public void onServiceChanged(SyncAdapterType type,

                                              boolean removed) {

               if (!removed) {

                   scheduleSync(null, type.authority, null, 0,false);

        },mSyncHandler);

   ......

    //创建一个用于广播发送的PendingIntent，该PendingIntent用于和

    //AlarmManagerService交互

    mSyncAlarmIntent= PendingIntent.getBroadcast(

                          mContext, 0, new Intent(ACTION_SYNC_ALARM),0);

   //注册CONNECTIVITY_ACTION广播监听对象，用于同步操作需要使用网络，所以

   //此处需要监听和网络相关的广播

  IntentFilter intentFilter =

             new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION);

       context.registerReceiver(mConnectivityIntentReceiver, intentFilter);

   if(!factoryTest) {

         //监听BOOT_COMPLETED广播

        intentFilter = new IntentFilter(Intent.ACTION_BOOT_COMPLETED);

        context.registerReceiver(mBootCompletedReceiver, intentFilter);

   //监听BACKGROUND_DATA_SETTING_CHANGED广播。该广播与是否允许后台传输数据有关，

   //用户可在Settings应用程序中设置对应选项

  intentFilter =

               new IntentFilter(ConnectivityManager.

                          ACTION_BACKGROUND_DATA_SETTING_CHANGED);

  context.registerReceiver(mBackgroundDataSettingChanged, intentFilter);

   //监视设备存储空间状态广播。由于SyncStorageEngine会保存同步时的一些信息到存储

   //设备中，所以此处需要监视存储设备的状态

  intentFilter = new IntentFilter(Intent.ACTION_DEVICE_STORAGE_LOW);

  intentFilter.addAction(Intent.ACTION_DEVICE_STORAGE_OK);

  context.registerReceiver(mStorageIntentReceiver, intentFilter);

   //监听SHUTDOWN广播。此处设置优先级为100，即优先接收此广播

  intentFilter = new IntentFilter(Intent.ACTION_SHUTDOWN);

  intentFilter.setPriority(100);

  context.registerReceiver(mShutdownIntentReceiver, intentFilter);

   if(!factoryTest) {//和通知服务交互，用于在状态栏上提示用户

      mNotificationMgr = (NotificationManager)

               context.getSystemService(Context.NOTIFICATION_SERVICE);

      //注意，以下函数注册的广播将针对前面创建的mSyncAlarmIntent

      context.registerReceiver(new SyncAlarmIntentReceiver(),

                          newIntentFilter(ACTION_SYNC_ALARM));

   }......

  mPowerManager = (PowerManager)

               context.getSystemService(Context.POWER_SERVICE);

  //创建WakeLock，防止同步过程中掉电

  mHandleAlarmWakeLock =

              mPowerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,

                                             HANDLE_SYNC_ALARM_WAKE_LOCK);

  mHandleAlarmWakeLock.setReferenceCounted(false);

  mSyncManagerWakeLock =

              mPowerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,

                                            SYNC_LOOP_WAKE_LOCK);

  mSyncManagerWakeLock.setReferenceCounted(false);

   //知识点一：监听SyncStorageEngine的状态变化，如下文解释

  mSyncStorageEngine.addStatusChangeListener(

               ContentResolver.SYNC_OBSERVER_TYPE_SETTINGS,

                     newISyncStatusObserver.Stub() {

           public void onStatusChanged(int which) {

               sendCheckAlarmsMessage();

    //知识点二：监视账户的变化。如果用户添加或删除了某个账户，则需要做相应处理。

    //如下文解释

    if(!factoryTest) {

           AccountManager.get(mContext).addOnAccountsUpdatedListener(

                 SyncManager.this,

               mSyncHandler, false);

           onAccountsUpdated(AccountManager.get(mContext).getAccounts());

public void setSyncAutomatically(Account account,String providerName,

                                       booleansync) {

    ......//检查WRITE_SYNC_SETTINGS权限

   longidentityToken = clearCallingIdentity();

     SyncManager syncManager = getSyncManager();

       if(syncManager != null) {

            通过SyncManager找到SyncStorageEngine，并调用它的

             setSyncAutomatically函数。在其内部会修改对应账户的同步服务信息，然后通知

             监听者，而这个监听者就是SyncManager设置的那个状态监听对象

           syncManager.getSyncStorageEngine().setSyncAutomatically(

                       account, providerName,sync);

     }finally {

         restoreCallingIdentity(identityToken);

提示上述两个知识点涉及的内容都是一些非常细节的问题，本章拟将它们作为小任务，读者可自行研究它们。

public static void init(Context context) {

  if(sSyncStorageEngine != null) return;

    得到系统中加密文件系统的路径，如果手机中没有加密的文件系统（根据系统属性

    “persist.security.efs.enabled”的值来判断），则返回的路径为/data，

    目前的Android手机大部分都没有加密文件系统，故dataDir为/data

   FiledataDir = Environment.getSecureDataDirectory();

   //创建SyncStorageEngine对象

  sSyncStorageEngine = new SyncStorageEngine(context, dataDir);

private SyncStorageEngine(Context context, FiledataDir) {

   mContext= context;

  sSyncStorageEngine = this;

   mCal =Calendar.getInstance(TimeZone.getTimeZone("GMT+0"));

   FilesystemDir = new File(dataDir, "system");

   FilesyncDir = new File(systemDir, "sync");

  syncDir.mkdirs();

   //mAccountInfoFile指向/data/system/sync/accounts.xml

  mAccountInfoFile = new AtomicFile(new File(syncDir,"accounts.xml"));

   //mStatusFile指向/data/system/sync/status.bin，该文件记录

  //一些和同步服务相关的状态信息

  mStatusFile = new AtomicFile(new File(syncDir, "status.bin"));

   //mStatusFile指向/data/system/sync/pending.bin，该文件记录了当前处于pending

   //状态的同步请求

  mPendingFile = new AtomicFile(new File(syncDir,"pending.bin"));

   //mStatusFile指向/data/system/sync/stats.bin，该文件记录同步服务管理运行过程

   //中的一些统计信息

  mStatisticsFile = new AtomicFile(new File(syncDir,"stats.bin"));

   解析上述四个文件，从下面的代码看，似乎是先读（readXXX）后写（writeXXX），这是怎么

   回事？答案在于AtomicFile，它内部实际包含两个文件，其中一个用于备份，防止数据丢失。

   感兴趣的读者可以研究AtomicFile类，其实现非常简单

   readAccountInfoLocked();

  readStatusLocked();

  readPendingOperationsLocked();

  readStatisticsLocked();

  readAndDeleteLegacyAccountInfoLocked();

  writeAccountInfoLocked();

  writeStatusLocked();

  writePendingOperationsLocked();

  writeStatisticsLocked();

 Set by theSyncManager to request that the SyncAdapter initialize itself for

 the givenaccount/authority pair. One required initialization step is to

 ensure thatsetIsSyncable()has been called with a >= 0 value.

  When thisflag is set the SyncAdapter does not need to do a full sync,

 though itis allowed to do so.

 publicstatic final String SYNC_EXTRAS_INITIALIZE = "initialize";

  //添加完账户后，将设置对应的同步服务状态为1

  ContentResolver.setIsSyncable(account,EmailContent.AUTHORITY, 1);

  ContentResolver.setSyncAutomatically(account,EmailContent.AUTHORITY,

                                                    syncEmail);

注意是否设置syncable状态和具体应用有关，图8-12第二个框中的gmail邮件同步服务就没有因为笔者添加了账户而设置syncable为1。

SyncAdaptersCache(Context context) {

   调用基类RegisteredServicesCache的构造函数，其中SERVICE_INTERFACE和

   和SERVICE_META_DATA的值为“android.content.SyncAdapter”，

   ATTRIBUTES_NAME为字符串"sync-adapter"

 super(context, SERVICE_INTERFACE, SERVICE_META_DATA,

              ATTRIBUTES_NAME, sSerializer);

public SyncQueue(SyncStorageEnginesyncStorageEngine,

                         finalSyncAdaptersCache syncAdapters) {

  mSyncStorageEngine = syncStorageEngine;

   //从SyncStorageEngine中取出上次没有完成的同步操作信息，这类信息由

  //PendingOperations表示

  ArrayList<SyncStorageEngine.PendingOperation> ops

                           = mSyncStorageEngine.getPendingOperations();

   final intN = ops.size();

   for (inti=0; i<N; i++) {

    SyncStorageEngine.PendingOperation op = ops.get(i);

     //从SyncStorageEngine中取出该同步操作的backoff信息

     finalPair<Long, Long> backoff =

                      syncStorageEngine.getBackoff(op.account,op.authority);

     //从SyncAdaptersCache中取出该同步操作对应的同步服务信息，如果同步服务已经不存在，

     //则无须执行后面的流程

    finalRegisteredServicesCache.ServiceInfo<SyncAdapterType>

           syncAdapterInfo= syncAdapters.getServiceInfo(

                           SyncAdapterType.newKey(op.authority,

                             op.account.type));

    if (syncAdapterInfo == null)  continue;

    //构造一个SyncOperation对象

    SyncOperation syncOperation = newSyncOperation(

            op.account, op.syncSource, op.authority, op.extras, 0,

            backoff != null ? backoff.first : 0,

            syncStorageEngine.getDelayUntilTime(op.account, op.authority),

            syncAdapterInfo.type.allowParallelSyncs());

    syncOperation.expedited = op.expedited;

    syncOperation.pendingOperation = op;

     //将SyncOperation对象保存到mOperationsMap变量中

    add(syncOperation, op);

Account emailSyncAccount = newAccount("fanping.deng@gmail",

                                               "com.google");

String emailAuthority ="com.android.email.provider";

Bundle emailBundle = new Bundle();

......//为emailBundle添加相关的参数。这些内容和具体的同步服务有关

//发起Email同步请求

ContentResolver.requesetSync(emailSyncAccount,emailAuthority,emailBundle);

public static void requestSync(Account account,String authority,

                     Bundle extras) {

   //检查extras携带的参数的数据类型，目前只支持float、int和String等几种类型

  validateSyncExtrasBundle(extras);

         //调用ContentService的requestSync函数

        getContentService().requestSync(account, authority, extras);

    }......

public void requestSync(Account account, Stringauthority, Bundle extras) {

   ContentResolver.validateSyncExtrasBundle(extras);

    longidentityToken = clearCallingIdentity();

        SyncManager syncManager = getSyncManager();

         if(syncManager != null) {

               //调用syncManager的scheduleSync

               syncManager.scheduleSync(account, authority, extras,

                          0,false);

        }finally {

           restoreCallingIdentity(identityToken);

  scheduleSync一共5个参数，其作用分别如下。

  requestedAccount表明要进行同步操作的账户。如果为空，SyncManager将同步所有账户。

 requestedAuthority表明要同步的数据项。如果为空，SyncManager将同步所有数据项。

  extras指定同步操作中的一些参数信息。这部分内容后续分析时再来介绍。

  delay指定本次同步请求是否延迟执行。单位为毫秒。

  onlyThoseWithUnkownSyncableState是否只同步那些处于unknown状态的同步服务。该参数

  在代码中没有注释。结合前面对syncable为unknown的分析，如果该参数为true，则

  本次同步请求的主要作用就是通知同步服务进行初始化操作

public void scheduleSync(Account requestedAccount,String requestedAuthority,

        Bundleextras, long delay,boolean onlyThoseWithUnkownSyncableState)

boopublic void scheduleSync(AccountrequestedAccount,

            StringrequestedAuthority, Bundle extras,

           long delay, boolean onlyThoseWithUnkownSyncableState)

  //判断是否允许后台数据传输

  finalboolean backgroundDataUsageAllowed = !mBootCompleted ||

               getConnectivityManager().getBackgroundDataSetting();

  if (extras== null) extras = new Bundle();

   //下面将解析同步服务中特有的一些参数信息，下面将逐条解释

   //SYNC_EXTRAS_EXPEDITED参数表示是否立即执行。如果设置了该选项，则delay参数不起作用

   //delay参数用于设置延迟执行时间，单位为毫秒

   Booleanexpedited = extras.getBoolean(

                     ContentResolver.SYNC_EXTRAS_EXPEDITED,false);

   if (expedited)

       delay = -1;

   Account[]accounts;

   if (requestedAccount != null) {

      accounts = new Account[]{requestedAccount};

    } ......

   //SYNC_EXTRAS_UPLOAD参数设置本次同步是否对应为上传。从本地同步到服务端为Upload，

   //反之为download

   finalboolean uploadOnly = extras.getBoolean(

                   ContentResolver.SYNC_EXTRAS_UPLOAD, false);

   //SYNC_EXTRAS_MANUAL等同于SYNC_EXTRAS_IGNORE_BACKOFF加

   //SYNC_EXTRAS_IGNORE_SETTINGS

   final boolean manualSync = extras.getBoolean(

                   ContentResolver.SYNC_EXTRAS_MANUAL, false);
   //如果是手动同步，则忽略backoff和settings参数的影响

   if(manualSync) {

       //知识点一：SYNC_EXTRAS_IGNORE_BACKOFF：该参数和backoff有关，见下文的解释

      extras.putBoolean(

                  ContentResolver.SYNC_EXTRAS_IGNORE_BACKOFF, true);

       //SYNC_EXTRAS_IGNORE_SETTINGS：忽略设置

      extras.putBoolean(

                  ContentResolver.SYNC_EXTRAS_IGNORE_SETTINGS, true);

   finalboolean ignoreSettings = extras.getBoolean(

                  ContentResolver.SYNC_EXTRAS_IGNORE_SETTINGS,false);

   //定义本次同步操作的触发源，见下文解释

   int source;

   if(uploadOnly) {

      source = SyncStorageEngine.SOURCE_LOCAL;

   } else if(manualSync) {

      source = SyncStorageEngine.SOURCE_USER;

   } else if(requestedAuthority == null) {

       source = SyncStorageEngine.SOURCE_POLL;

   } else {

       source = SyncStorageEngine.SOURCE_SERVER;

public void setBackoff(Account account, StringproviderName,

                           long nextSyncTime, long nextDelay)

/* Enumvalue for a local-initiated sync. */

 public static final int SOURCE_LOCAL = 1;

/**  Enum value for a poll-based sync (e.g., upon connectionto network)*/

 public static final int SOURCE_POLL = 2;

/* Enumvalue for a user-initiated sync. */

  public static final int SOURCE_USER = 3;

/* Enumvalue for a periodic sync. */

publicstatic final int SOURCE_PERIODIC = 4;

   //从SyncAdaptersCache中取出所有SyncService信息

   final HashSet<String>syncableAuthorities = new HashSet<String>();

   for(RegisteredServicesCache.ServiceInfo<SyncAdapterType>

               syncAdapter :mSyncAdapters.getAllServices()) {

           syncableAuthorities.add(syncAdapter.type.authority);

   //如果指定了本次同步的authority，则从上述同步服务信息中找到满足要求的SyncService

   if(requestedAuthority != null) {

        final boolean hasSyncAdapter =

                      syncableAuthorities.contains(requestedAuthority);

           syncableAuthorities.clear();

         if(hasSyncAdapter) syncableAuthorities.add(requestedAuthority);

   finalboolean masterSyncAutomatically =

                           mSyncStorageEngine.getMasterSyncAutomatically();

   for(String authority : syncableAuthorities) {

       for(Account account : accounts) {

         //取出AuthorityInfo中的syncable状态，如果为1，则syncable为true，

        //如果为-1，则状态为unknown

        intisSyncable = mSyncStorageEngine.getIsSyncable(

                                     account,authority);

        if(isSyncable == 0) continue;//syncable为false，则不能进行同步操作

       final RegisteredServicesCache.ServiceInfo<SyncAdapterType>

                  syncAdapterInfo =

                    mSyncAdapters.getServiceInfo(

                             SyncAdapterType.newKey(authority, account.type));

       ......

        //有些同步服务支持多路并发同步操作

       final boolean allowParallelSyncs =

                          syncAdapterInfo.type.allowParallelSyncs();

       finalboolean isAlwaysSyncable = syncAdapterInfo.type.

                                              isAlwaysSyncable();

      //如果该同步服务此时的状态为unknown，而它又是永远可同步的（AlwaysSyncable），

      //那么通过setIsSyncable设置该服务的状态为1

       if(isSyncable < 0 && isAlwaysSyncable) {

            mSyncStorageEngine.setIsSyncable(account, authority, 1);

            isSyncable = 1;

      //如果只操作unknow状态的同步服务，并且该服务的状态不是unknown，则不允许后续操作

      if(onlyThoseWithUnkownSyncableState && isSyncable >= 0)

         continue;

      //如果此同步服务不支持上传，而本次同步又需要上传，则不允许后续操作

       if(!syncAdapterInfo.type.supportsUploading() && uploadOnly)

            continue;

      //判断是否允许执行本次同步操作。如果同步服务状态为unknown，则总是允许发起同步请求，

     //因为这时的同步请求只是为了初始化SyncService

      boolean syncAllowed = (isSyncable < 0) ||ignoreSettings

                 || (backgroundDataUsageAllowed && masterSyncAutomatically

                 && mSyncStorageEngine.getSyncAutomatically(

                              account,authority));

        ......

      //取出对应的backoff参数

     Pair<Long, Long> backoff = mSyncStorageEngine.getBackoff(

                                  account,authority);

      //获取延迟执行时间

      longdelayUntil = mSyncStorageEngine.getDelayUntilTime(

                                  account,authority);

      finallong backoffTime = backoff != null ? backoff.first : 0;

      if(isSyncable < 0) {

           Bundle newExtras = new Bundle();

           //如果syncable状态为unknown，则需要设置一个特殊的参数，即

           //SYNC_EXTRAS_INITIALIZE，它将通知SyncService进行初始化操作

           newExtras.putBoolean(ContentResolver.SYNC_EXTRAS_INITIALIZE, true);

           scheduleSyncOperation(

                new SyncOperation(account, source, authority, newExtras, 0,

                         backoffTime,delayUntil,allowParallelSyncs));

        if(!onlyThoseWithUnkownSyncableState)

            scheduleSyncOperation(

                   new SyncOperation(account,source, authority, extras, delay,

                         backoffTime, delayUntil,allowParallelSyncs));

         }//for循环结束

public void handleMessage(Message msg) {

   longearliestFuturePollTime = Long.MAX_VALUE;

   longnextPendingSyncTime = Long.MAX_VALUE;

          waitUntilReadyToRun();

          mDataConnectionIsConnected = readDataConnectionState();

          //获得WakeLock，防止在同步过程中掉电

          mSyncManagerWakeLock.acquire();

          //处理周期同步的操作

           earliestFuturePollTime= scheduleReadyPeriodicSyncs();

          switch (msg.what) {

             ......

             case SyncHandler.MESSAGE_CHECK_ALARMS:

                //调用maybeStartNextSyncLocked函数，返回一个时间。见下文解释

                nextPendingSyncTime = maybeStartNextSyncLocked();

               break;

             ......

              }//switch结束

     } finally{

         manageSyncNotificationLocked();

          将上边函数调用的返回值传递给manageSyncAlarmLocked，该函数内部与

          AlarmManagerService交互，其实就是定义一个定时提醒。在Alarm超时后，就会广播

          在SyncManager构造函数中定义的那个PendingIntent mSyncAlarmIntent，

          而SyncManager收到该广播后又会做对应处理。相关内容读者可自行阅读

         manageSyncAlarmLocked(earliestFuturePollTime,nextPendingSyncTime);

         mSyncTimeTracker.update();

         mSyncManagerWakeLock.release();

提示maybeStartNextSyncLocked是笔者在本节留给读者自行分析的函数中最难的一个。读者务必阅读完下面的分析后，尝试去研究此函数。

private booleandispatchSyncOperation(SyncOperation op) {

  SyncAdapterType syncAdapterType = SyncAdapterType.

                            newKey(op.authority,op.account.type);

  RegisteredServicesCache.ServiceInfo<SyncAdapterType>

          syncAdapterInfo=

                   mSyncAdapters.getServiceInfo(syncAdapterType);

   ......

   //构造一个ActiveSyncContext对象，它就是前面提到的同步操作上下文对象

   ActiveSyncContextactiveSyncContext =

          new ActiveSyncContext(op,

                 insertStartSyncEvent(op), syncAdapterInfo.uid);

   activeSyncContext.mSyncInfo =

               mSyncStorageEngine.addActiveSync(activeSyncContext);

    // mActiveSyncContexts保存了当前系统中所有的ActiveSyncContext对象

   mActiveSyncContexts.add(activeSyncContext);

    //为该对象绑定到具体的同步服务上

    if(!activeSyncContext.bindToSyncAdapter(syncAdapterInfo)) {

         closeActiveSyncContext(activeSyncContext);

         return false;

     returntrue;

booleanbindToSyncAdapter(RegisteredServicesCache.ServiceInfo info) {

    Intentintent = new Intent();

   intent.setAction("android.content.SyncAdapter");

    //设置目标同步服务的ComponentName

   intent.setComponent(info.componentName);

    intent.putExtra(Intent.EXTRA_CLIENT_LABEL,

                   com.android.internal.R.string.sync_binding_label);

   intent.putExtra(Intent.EXTRA_CLIENT_INTENT,

                 PendingIntent.getActivity(

                   mContext, 0,

                   new Intent(Settings.ACTION_SYNC_SETTINGS),0));

      mBound= true;

      //调用bindService启动指定的同步服务

      finalboolean bindResult = mContext.bindService(intent, this,

                   Context.BIND_AUTO_CREATE | Context.BIND_NOT_FOREGROUND

                   | Context.BIND_ALLOW_OOM_MANAGEMENT);

       if(!bindResult)

           mBound = false;

      returnbindResult;

public void onServiceConnected(ComponentName name,IBinder service) {

    Messagemsg = mSyncHandler.obtainMessage();

    msg.what= SyncHandler.MESSAGE_SERVICE_CONNECTED;

    //构造一个ServiceConnectionData对象，并发送MESSAGE_SERVICE_CONNECTED消息

    //给mSyncHandler。第二个参数就是SyncService在onBind函数中返回的ISyncAdapter的

    //Binder通信对象。不过在ActiveSyncContext中，它是Bp端

    msg.obj= new ServiceConnectionData(this,

                          ISyncAdapter.Stub.asInterface(service));

   mSyncHandler.sendMessage(msg);

case SyncHandler.MESSAGE_SERVICE_CONNECTED: {

    ServiceConnectionData msgData = (ServiceConnectionData)msg.obj;

     if(isSyncStillActive(msgData.activeSyncContext))

          //调用runBoundToSyncAdapter函数处理

         runBoundToSyncAdapter(msgData.activeSyncContext,

                             msgData.syncAdapter);

    break;

private void runBoundToSyncAdapter(final ActiveSyncContextactiveSyncContext,

      ISyncAdapter syncAdapter) {

   activeSyncContext.mSyncAdapter = syncAdapter;

    finalSyncOperation syncOperation = activeSyncContext.mSyncOperation;

        activeSyncContext.mIsLinkedToDeath = true;

        syncAdapter.asBinder().linkToDeath(activeSyncContext, 0);

        //调用目标同步服务的startSync函数

        syncAdapter.startSync(activeSyncContext, syncOperation.authority,

                   syncOperation.account, syncOperation.extras);

       } ......

public IBinder onBind(Intent intent) {

     //sSyncAdapter是EmailSyncAdapterService的内部类对象，见下文解释

      returnsSyncAdapter.getSyncAdapterBinder();

public void startSync(ISyncContext syncContext,String authority,

              Account account,Bundle extras) {

     //构造一个SyncContext对象，用于保存上下文信息

     finalSyncContext syncContextClient = new SyncContext(syncContext);

     booleanalreadyInProgress;

     finalAccount threadsKey = toSyncKey(account);

    synchronized (mSyncThreadLock) {

        //判断是否存在已经在执行的SyncThread

        if(!mSyncThreads.containsKey(threadsKey)) {

            if (mAutoInitialize

                && extras != null&& extras.getBoolean(

                 ContentResolver.SYNC_EXTRAS_INITIALIZE, false)) {

              //一般而言，mAutoInitialize都为true，表示同步服务支持自动初始化

             //如果该服务对应的syncable状态为unknown，则重新设置syncable为1

              if (ContentResolver.getIsSyncable(account, authority) < 0)

                       ContentResolver.setIsSyncable(account,authority, 1);

                //直接返回，不再做后续的处理，实际上后续的流程是可以继续进行的

                syncContextClient.onFinished(new SyncResult());

               return;

                //创建一个新的SyncThread对象

               SyncThread syncThread = new SyncThread(

                           "SyncAdapterThread-" +

                                      mNumSyncStarts.incrementAndGet(),

                        syncContextClient,authority, account, extras);

                mSyncThreads.put(threadsKey, syncThread);

                syncThread.start();//启动工作线程

                alreadyInProgress = false;

           }else {

                alreadyInProgress = true;

   if(alreadyInProgress)

        syncContextClient.onFinished(SyncResult.ALREADY_IN_PROGRESS);

public void run() {

    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);

    SyncResult syncResult = new SyncResult();

    ContentProviderClient provider = null;

          if(isCanceled()) return;

          //获得同步操作指定的ContentProvider，provider是ContentProviderClient

         //类型，用于和目标ContentProvider交互

         provider = mContext.getContentResolver().

                       acquireContentProviderClient(mAuthority);

          if (provider != null) {

             //调用AbstractThreadedSyncAdapter子类的onPerformSync函数

             AbstractThreadedSyncAdapter.this.onPerformSync(mAccount,

                               mExtras,mAuthority,provider, syncResult);

              } else

                  syncResult.databaseError = true;

      }finally {

          if (provider != null)

                   provider.release();

          if (!isCanceled()) //通知结果

              mSyncContext.onFinished(syncResult);

        //工作完成，将该线程从mSyncThreads中移除

       synchronized (mSyncThreadLock) {

            mSyncThreads.remove(mThreadsKey);

public void onPerformSync(Account account, Bundleextras, String authority,

         ContentProviderClient provider,SyncResult syncResult) {

        //调用EmailSyncAdapterService performSync完成真正的同步，这部分代码和

       //Email业务逻辑相关，此处不再深入研究

       EmailSyncAdapterService.performSync(mContext, account, extras,

                     authority, provider,syncResult);

   }......