void QueryImage(Context context){

  //①得到ContentResolver对象

 ContentResolver cr = context.getContentResover();

  Uri uri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;

  //②查询数据库

  Cursorcursor = MediaStore.Images.Media.query(cr,uri,null);

 cursor.moveToFirst();//③移动游标到头部

  ......//从游标中取出数据集

  cursor.close();//④关闭游标

public ContentResolver getContentResolver() {

   returnmContentResolver;

final void init(LoadedApk packageInfo, IBinder activityToken,

       ActivityThreadmainThread, Resources container,String basePackageName) {

   ......

  mMainThread = mainThread;//mainThread指向AcitivityThread对象

  //mContentResolver的真实类型是ApplicationContentResolver

  mContentResolver = new ApplicationContentResolver(this, mainThread);

   ......

提示为了书写方便，将ContentProvider简称为CP，将ContentResolver简称为CR。

提示MediaStore类较为复杂，主要原因是它定义了一些同名类。读者阅读代码时务须仔细。

public static final class Media implementsImageColumns {

   public static final Cursor query(ContentResolvercr,Uri uri,

                                           String[]projection) {

   //直接调用ContentResolver的query函数

   returncr.query(uri, projection, null,

                      null,DEFAULT_SORT_ORDER);

提示追求运行效率的程序员也许会对上边这段代码的实现略有微词，因为Image.Media的query函数基本上没做任何有意义的工作。假如客户端直接调用cr.query函数，则此处的query就增加了一次函数调用和返回的开销（即Image.Media query调用和返回时参数的入栈/出栈）。但是，通过Image.Media的封装将使程序更清晰和易读（与直接使用ContentResolver的query相比，代码阅读者一看Image.Media就知道其query函数应该和Image有关，否则需要通过解析uri参数才能确定查询的信息是什么）。代码清晰易读和运行效率高，往往是软件开发中的熊掌和鱼，它们之间的对立性，将在本章中体现得淋漓尽致。笔者建议读者在实际开发中结合具体情况决定取舍，万不可钻牛角尖。

public final Cursor query(Uri uri, String[]projection,

           String selection, String[] selectionArgs, String sortOrder) {

   //调用acquireProvider函数，参数为uri，函数也由ContentResolver实现

  IContentProvider provider = acquireProvider(uri);

  //注意：下面将和ContentProvider交互， 相关知识留待7.4节再分析

   ......

public final IContentProvider acquireProvider(Uriuri) {

  if(!SCHEME_CONTENT.equals(uri.getScheme())) return null;

  Stringauth = uri.getAuthority();

  if (auth!= null) {

     //acquireProvider是一个抽象函数，由ContentResolver的子类实现。在本例中，该函数

     //将由ApplicationContentResolver实现。uri.getAuthority将返回代表目标

     //ContentProvider的名字

      returnacquireProvider(mContext, uri.getAuthority());

  returnnull;

protected IContentProvider acquireProvider(Contextcontext, String name) {

   //mMainThread指向代表应用进程主线程的ActivityThread对象，每个应用进程只有一个

   //ActivityThread对象

    return mMainThread.acquireProvider(context,name);

public final IContentProvideracquireProvider(Context c, String name) {

  //①调用getProvider函数，它很重要。见下文分析

  IContentProvider provider = getProvider(c,name);

  ......

  IBinderjBinder = provider.asBinder();

  synchronized(mProviderMap) {

     //客户端进程将本进程使用的ContentProvider信息保存到mProviderRefCountMap中，

     //其主要功能与引用计数和资源释放有关，读者暂可不理会它

     ProviderRefCount prc = mProviderRefCountMap.get(jBinder);

      if(prc== null)

          mProviderRefCountMap.put(jBinder, newProviderRefCount(1));

     else   prc.count++;

 returnprovider;

private IContentProvider getProvider(Contextcontext, String name) {

   查询该应用进程是否已经保存了用于和远端ContentProvider通信的对象existing。

   此处，我们知道existing的类型是IContentProvider，不过IContentProvider是一

   个interface，那么existing的真实类型是什么呢？稍后再揭示

 IContentProvider existing = getExistingProvider(context, name);

  if(existing != null) return existing;//如果existing存在，则直接返回

 IActivityManager.ContentProviderHolder holder = null;

      //如果existing不存在，则需要向AMS查询，返回值的类型为ContentProviderHolder

      holder= ActivityManagerNative.getDefault().getContentProvider(

               getApplicationThread(), name);

  }......

   //注意：记住下面这个函数调用，此时是在客户端进程中

 IContentProvider prov = installProvider(context, holder.provider,

               holder.info, true);

   ......

  returnprov;

 privatefinal ContentProviderHolder getContentProviderImpl(

                          IApplicationThread caller, String name) {

 ContentProviderRecord cpr;

 ProviderInfo cpi = null;

 synchronized(this) {

    ProcessRecord r = null;

     if(caller != null) {

          r= getRecordForAppLocked(caller);

          if (r == null)......//如果查询不到调用者信息，则抛出SecurityException

      }// if (caller != null)判断结束

    //name参数为调用进程指定的代表目标ContentProvider的authority

    cpr =mProvidersByName.get(name);

    //如果cpr不为空，表明该ContentProvider已经在AMS中注册

    booleanproviderRunning = cpr != null;

    if(providerRunning){

       ......//如果该ContentProvider已经存在，则进行对应处理, 相关内容可自行阅读

   //如果目标ContentProvider对应进程还未启动

   if(!providerRunning) {

           //查询PKMS，得到指定的ProviderInfo信息

           cpi = AppGlobals.getPackageManager().resolveContentProvider(

                   name,STOCK_PM_FLAGS |

                   PackageManager.GET_URI_PERMISSION_PATTERNS);

        }......

        String msg;

      //权限检查，此处不作讨论

      if((msg=checkContentProviderPermissionLocked(cpi, r)) != null)

         throw new SecurityException(msg);

      如果system_server还没启动完毕，并且该ContentProvider不运行在system_server

      中，则此时不允许启动ContentProvider。读者还记得哪个ContentProvider运行在

     system_server进程中吗？答案是SettingsProvider

     .......

    ComponentName comp = new ComponentName(cpi.packageName, cpi.name);

     cpr =mProvidersByClass.get(comp);

     finalboolean firstClass = cpr == null;

     //初次启动MediaProvider对应进程时，firstClass一定为true

     if (firstClass) {

             //查询PKMS，得到MediaProvider所在的Application信息

              ApplicationInfoai =

                      AppGlobals.getPackageManager().getApplicationInfo(

                          cpi.applicationInfo.packageName, STOCK_PM_FLAGS);

             if (ai == null) return null;

            //在AMS内部通过ContentProviderRecord来保存ContentProvider的信息，类似

            //ActivityRecord，BroadcastRecord等

             cpr = new ContentProviderRecord(cpi, ai,comp);

         }......

    }// if(firstClass)判断结束

   canRunHere函数用于判断目标CP能否运行在r所对应的进程（即调用者所在进程）

   该函数内部做如下判断：

   (info.multiprocess|| info.processName.equals(app.processName))

    && (uid == Process.SYSTEM_UID || uid == app.info.uid)

    就本例而言，MediaProvider不能运行在客户端进程中

    if (r !=null && cpr.canRunHere(r))  returncpr;

    finalint N = mLaunchingProviders.size();

    ......//查找目标ContentProvider对应的进程是否正处于启动状态

    //如果i大于等于N，表明目标进程的信息不在mLaunchingProviders中

    if (i>= N) {

       finallong origId = Binder.clearCallingIdentity();

       ......

       //调用startProcessLocked函数创建目标进程

      ProcessRecord proc = startProcessLocked(cpi.processName,

                         cpr.appInfo, false, 0,"content provider",

                         newComponentName(cpi.applicationInfo.packageName,

                          cpi.name), false);

       if(proc == null)return null;

      cpr.launchingApp = proc;

       //将该进程信息保存到mLaunchingProviders中

      mLaunchingProviders.add(cpr);

     if(firstClass) mProvidersByClass.put(comp, cpr);

    mProvidersByName.put(name, cpr);

       下面这个函数将为客户端进程和目标CP进程建立紧密的关系，即当目标CP进程死亡后，

        AMS将根据该函数建立的关系找到客户端进程并杀死（kill）它们。在7.2.3节

        有对这个函数的相关解释

     incProviderCount(r, cpr);

     if(cpr.launchingApp == null) return null;

          cpr.wait();//等待目前进程的启动

      } ......

   }// synchronized(this)结束

  returncpr;

private final booleanattachApplicationLocked(IApplicationThread thread,

           int pid) {

   ......

   //通过PKMS查询运行在该进程中的CP信息，并保存到mProvidersByClass中

   Listproviders = normalMode ?

               generateApplicationProvidersLocked(app) : null;

  //调用目标应用进程的bindApplication函数，此处将providers信息传递给目标进程

   thread.bindApplication(processName,appInfo, providers,

                             app.instrumentationClass, profileFile,

                              ......);

   ......

private void handleBindApplication(AppBindDatadata) {

   ......

   if(!data.restrictedBackupMode){

       List<ProviderInfo> providers = data.providers;

        if(providers != null) {

           //调用installContentProviders安装

           installContentProviders(app, providers);

           ......

   ......

private void installContentProviders(Contextcontext,

                                              List<ProviderInfo>providers) {

  finalArrayList<IActivityManager.ContentProviderHolder> results =

                newArrayList<IActivityManager.ContentProviderHolder>();

 Iterator<ProviderInfo> i = providers.iterator();

  while(i.hasNext()) {

     //①也调用installProvider，注意该函数传递的第二个参数为null

    IContentProvider cp = installProvider(context, null, cpi, false);

     if (cp!= null) {

         IActivityManager.ContentProviderHolder cph =

                          newIActivityManager.ContentProviderHolder(cpi);

         cph.provider = cp;

          results.add(cph);//将信息添加到results数组中

           ......//创建引用计数

    }//while循环结束

    try {  //②调用AMS的publishContentProviders发布ContentProviders

           ActivityManagerNative.getDefault().publishContentProviders(

               getApplicationThread(), results);

        } ......

private IContentProvider installProvider(Contextcontext,

           IContentProvider provider, ProviderInfo info, boolean noisy) {

  ContentProvider localProvider = null;

   if(provider == null) {//针对目标进程的情况

       Context c = null;

        ApplicationInfo ai = info.applicationInfo;

         if(context.getPackageName().equals(ai.packageName)) {

               c = context;

           }......//这部分代码已经在6.2.3节分析过了，其目的就是为了得到正确的

          //Context用于加载Java字节码

            final java.lang.ClassLoader cl = c.getClassLoader();

            //通过Java反射机制创建MediaProvider实例

            localProvider = (ContentProvider)cl.

                                     loadClass(info.name).newInstance();

            //注意下面这句代码

            provider = localProvider.getIContentProvider();

     } elseif (localLOGV) {

           Slog.v(TAG, "Installing external provider " + info.authority +": "

                   + info.name);

    }// if(provider == null)判断结束

     由以上代码可知，对于provider不为null 的情况（即客户端调用的情况），该函数没有

     什么特殊的处理

    ......

      引用计数及设置DeathReceipient等相关操作。在6.2.3节的第2个小标题中

      曾说过，目标进程为自己进程中的CP实例设置DeathReceipient没有作用，因为二者在同一个

      进程中，自己怎么能接收自己的讣告消息呢？不过，如果客户端进程为目标进程的CP设置

     DeathReceipient又有作用吗？仔细思考这个问题

    returnprovider;//最终返回的对象是IContentProvider类型，它到底是什么呢？

public Cursor query(Uri uri, String[] projection,

               String selection, String[] selectionArgs, String sortOrder) {

  enforceReadPermission(uri);

  //Transport为ContentProvider的内部类，此处将调用ContentProvider的query函数

   //本例中，该query函数由MediaProvider实现，故最终会调用MediaProvider的query

   returnContentProvider.this.query(uri, projection, selection,

                   selectionArgs, sortOrder);

public final voidpublishContentProviders(IApplicationThread caller,

         List<ContentProviderHolder> providers) {

   ......

  synchronized(this) {

     finalProcessRecord r = getRecordForAppLocked(caller);

     finallong origId = Binder.clearCallingIdentity();

     final int N = providers.size();

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

       ContentProviderHolder src = providers.get(i);

       ContentProviderRecord dst = r.pubProviders.get(src.info.name);

       if(dst != null) {

           ......//将相关信息分别保存到mProviderByClass和mProvidersByName中

           int NL = mLaunchingProviders.size();

         ...... //目标进程已经启动，将其从mLaunchingProviders移除

         synchronized (dst) {

            dst.provider = src.provider;//将信息保存在dst中

            dst.proc = r;

           //触发还等在（wait）getContentProvider中的那个客户端进程

            dst.notifyAll();

       updateOomAdjLocked(r);//调节目标进程的oom_adj等相关参数

     }// if(dst != null)判断结束

   ......

提示读者可能觉得，这条路线是对第6章的补充和延续。不过，虽然目标进程由AMS创建和启动，而且ContentProvider的发布也需和AMS交互，但是对于ContentProvider来说，我们更关注客户端和目标进程中ContentProvider实例间的交互。事实上，客户端得到IContentProvider Bp端对象后，即可直接与目标进程的CP实例交互，也就无需借助AMS了，所以笔者将这条路线放到了本章进行分析。

注意本书后文所说的SQLite API特指libsqlite.so提供的Native层的API。

#include <unistd.h>

#include <sqlite3.h> //包含sqlite API头文件，这里的3是SQLite的版本号

#include <stdlib.h>

#define LOG_TAG "SQLITE_TEST"  //定义该进程logcat输出的标签

#include <utils/Log.h>

#ifndef NULL

   #defineNULL (0)

#endif

//声明数据库文件的路径

#define DB_PATH"/mnt/sdcard/sqlite3test.db"

   声明一个全局的SQLite句柄，开发者无需了解该数据结构的具体内容，只要知道它代表了使用者

   和数据库的一种连接关系即可。以后凡是针对特定数据库的操作，都需要传入对应的SQLite句柄

static sqlite3* g_pDBHandle = NULL;

   定义一个宏，用于检测SQLite API调用的返回值，如果value不等于expectValue，则打印警告，

   并退出程序。注意，进程退出后，系统会自动回收分配的内存资源。对如此简单的例子来说，读者大可

    不必苛责。其中，sqlite3_errmsg函数用于打印错误信息

#define CHECK_DB_ERR(value,expectValue) \

   if(value!= expectValue)\

    LOGE("Sqlite db fail:%s",g_pDBHandle==NULL?"db not \

           connected":sqlite3_errmsg(g_pDBHandle));\

    exit(0);\

}while(0)

int main(int argc, char* argv[])

  LOGD("Delete old DB file");

  unlink(DB_PATH);//先删除旧的数据库文件

  LOGD("Create new DB file");

    调用sqlite3_open创建一个数据库，并将和该数据库的连接环境保存在全局的SQLite句柄

     g_pDBHandle中，以后操作g_pDBHandle就是操作DB_PATH对应的数据库

   int ret =sqlite3_open(DB_PATH,&g_pDBHandle);

  CHECK_DB_ERR(ret,SQLITE_OK);

  LOGD("Create Table personal_info:");

    定义宏TABLE_PERSONAL_INFO，用于描述为本例数据库建立一个表所用的SQL语句，

    不熟悉SQL语句的读者可先学习相关知识。从该宏的定义可知，将建立一个名为

   personal_info的表，该表有4列，第一列是主键，类型是整型（SQLite中为INTEGER），

    每加入一行数据该值会自动递增；第二列名为"name"，数据类型是字符串（SQLite中为TEXT）；

     第三列名为“age”，数据类型是整型；第四列名为“sex”，数据类型是字符串

   #defineTABLE_PERSONAL_INFO  \

          "CREATETABLE personal_info" \

           "(ID INTEGER primary keyautoincrement," \

           "nameTEXT," \

           "age INTEGER,"\

           "sex TEXT"\

   //打印TABLE_PERSONAL_INFO所对应的SQL语句

  LOGD("\t%s\n",TABLE_PERSONAL_INFO);

  //调用sqlite3_exec执行前面那条SQL语句

   ret =sqlite3_exec(g_pDBHandle,TABLE_PERSONAL_INFO,NULL,NULL,NULL);

  CHECK_DB_ERR(ret,SQLITE_OK);

    定义插入一行数据所使用的SQL语句，注意最后一行中的问号，它表示需要在插入数据

   前和具体的值绑定。插入数据库对应的SQL语句是标准的INSERT命令

  LOGD("Insert one personal info into personal_info table");

   #defineINSERT_PERSONAL_INFO  \

  "INSERT INTO personal_info"\

  "(name,age,sex)"\

  "VALUES"\

  "(?,?,?)"   //注意这一行语句中的问号

  LOGD("\t%s\n",INSERT_PERSONAL_INFO);

   //sqlite3_stmt是SQLite中很重要的一个结构体，它代表了一条SQL语句

   sqlite3_stmt* pstmt = NULL;

    调用sqlite3_prepare初始化pstmt，并将其和INSERT_PERSONAL_INFO绑定。

    也就是说，如果执行pstmt，就会执行INSERT_PERSONAL_INFO语句

   ret =sqlite3_prepare(g_pDBHandle,INSERT_PERSONAL_INFO,-1,&pstmt,NULL);

  CHECK_DB_ERR(ret,SQLITE_OK);

    调用sqlite3_bind_xxx为该pstmt中对应的问号绑定具体的值，该函数的第二个参数用于

    指定第几个问号

   ret =sqlite3_bind_text(pstmt,1,"dengfanping",-1,SQLITE_STATIC);

   ret =sqlite3_bind_int(pstmt,2,30);

   ret =sqlite3_bind_text(pstmt,3,"male",-1,SQLITE_STATIC);

   //调用sqlite3_step执行对应的SQL语句，该函数如果执行成功，我们的personal_info

   //表中将添加一条新记录，对应值为（1，dengfanping，30，male）

   ret =sqlite3_step(pstmt);

  CHECK_DB_ERR(ret,SQLITE_DONE);

   //调用sqlite3_finalize销毁该SQL语句

   ret =sqlite3_finalize(pstmt);

   //下面将从表中查询name为"dengfanping"的person的age值

  LOGD("select dengfanping's age from personal_info table");

   pstmt =NULL;

    重新初始化该pstmt，并将其和SQL语句“SELECT age FROM personal_info WHERE name

     = ?”绑定

   ret =sqlite3_prepare(g_pDBHandle,"SELECT age FROM personal_info WHERE name

                                              =? ",-1,&pstmt,NULL);

  CHECK_DB_ERR(ret,SQLITE_OK);  

    绑定pstmt中第一个问号为字符串“dengfanping”，最终该SQL语句为

    SELECTage FROM personal_info WHERE name = 'dengfanping'

   ret =sqlite3_bind_text(pstmt,1,"dengfanping",-1,SQLITE_STATIC);

  CHECK_DB_ERR(ret,SQLITE_OK);

   //执行这条查询语句

 while(true)//在一个循环中遍历结果集

    ret =sqlite3_step(pstmt);

   if(ret ==SQLITE_ROW)

      //从结果集中取出第一列（由于执行SELECT时只选择了age，故最终结果只有一列），

      //调用sqlite3_column_int返回结果集的第一列（从0开始）第一行的值

      intmyage = sqlite3_column_int(pstmt, 0);

      LOGD("Gotdengfanping's age: %d\n",myage);

   else //如果ret为其他值，则退出循环

     break;

   else  LOGD("Find nothing\n"); //SELECT执行失败

   ret =sqlite3_finalize(pstmt);//销毁pstmt

  if(g_pDBHandle)

     LOGD("CloseDB");

    //调用sqlite3_close关闭数据库连接并释放g_pDBHandle

   sqlite3_close(g_pDBHandle);

   g_pDBHandle = NULL;

  return 0;

提示读者见识了SQLiteDatabase家族中这几位成员后有何感想？是否觉得要真正搞清楚它们还需要花费一番工夫呢？

private Uri attachVolume(String volume) {

  Contextcontext = getContext();

 DatabaseHelper db;

  if(INTERNAL_VOLUME.equals(volume)) {

        ......//针对内部存储空间的数据库

     } elseif (EXTERNAL_VOLUME.equals(volume)) {

       ......

        String dbName = "external-" +Integer.toHexString(volumeID) + ".db";

        //①构造一个DatabaseHelper对象

       db =new DatabaseHelper(context, dbName, false,

                                   false, mObjectRemovedCallback);

       ......//省略不相关的内容

    }......

  if(!db.mInternal) {

     //②调用DatabaseHelper的getWritableDatabase函数，该函数返回值的类型为

   //SQLiteDatabase，即代表SQLite数据库的对象

    createDefaultFolders(db.getWritableDatabase());

     .......

  ......

public DatabaseHelper(Context context, Stringname, boolean internal,

                    boolean earlyUpgrade,

                   SQLiteDatabase.CustomFunction objectRemovedCallback) {

      //重点关注其基类的构造函数

      super(context, name, null,DATABASE_VERSION);

     mContext = context;

      mName= name;

     mInternal = internal;

     mEarlyUpgrade = earlyUpgrade;

     mObjectRemovedCallback = objectRemovedCallback;

public SQLiteOpenHelper(Context context, Stringname, CursorFactory factory,

                             int version) {

  //调用另外一个构造函数，注意它新建了一个默认的错误处理对象

 this(context, name, factory, version, newDefaultDatabaseErrorHandler());

public SQLiteOpenHelper(Context context, Stringname, CursorFactory factory,

            int version, DatabaseErrorHandlererrorHandler) {

    ......

    mContext= context;

    mName =name;

   //看到”factory“一词，读者要能想到设计模式中的工厂模式，在本例中该变量为null

    mFactory= factory;

   mNewVersion = version;

    mErrorHandler= errorHandler;

建议此框架虽更完善、更具扩展性，但是使用它比直接使用SQLite API要复杂得多，因此在开发过程中，应当根据实际情况综合考虑是否使用该框架。例如，笔者在开发公司的DLNA解决方案时，就直接使用了SQLiteAPI，而没使用这个框架。

public synchronized SQLiteDatabasegetWritableDatabase() {

  if(mDatabase != null) {

    //第一次调用该函数时mDatabase还未创建。以后的调用将直接返回已经创建好的mDatabase

   booleansuccess = false;

  SQLiteDatabase db = null;

   if (mDatabase != null) mDatabase.lock();

        mIsInitializing = true;

        if(mName == null) {

            db = SQLiteDatabase.create(null);

         }else {

            //①调用Context的openOrCreateDatabase创建数据库

            db = mContext.openOrCreateDatabase(mName, 0,

                                                 mFactory, mErrorHandler);

     intversion = db.getVersion();

     if(version != mNewVersion) {

         db.beginTransaction();

               if (version == 0) {

              如果初次创建该数据库（即对应的数据库文件不存在），则调用子类实现的

              onCreate函数。子类实现的onCreate函数将完成数据库建表等操作。读者不妨

              查看MediaProviderDatabaseHelper实现的onCreate函数

                 onCreate(db);

               } else {

                  //如果从数据库文件中读出来的版本号与MediaProvider设置的版本号不一致，

                  //则调用子类实现的onDowngrade或onUpgrade做相应处理

                  if (version > mNewVersion)

                    onDowngrade(db, version,mNewVersion);

                    onUpgrade(db, version,mNewVersion);

              db.setVersion(mNewVersion);

             db.setTransactionSuccessful();

       }finally {

          db.endTransaction();

   }// if (version != mNewVersion)判断结束

  onOpen(db);//调用子类实现的onOpen函数

   success =true;

   return db;

  }......

public SQLiteDatabase openOrCreateDatabase(Stringname, int mode,

               CursorFactory factory,DatabaseErrorHandler errorHandler) {

  File f =validateFilePath(name, true);

  //调用SQLiteDatabase的静态函数openOrCreateDatabase创建数据库

 SQLiteDatabase db = SQLiteDatabase.openOrCreateDatabase(f.getPath(),

                                             factory, errorHandler);

 setFilePermissionsFromMode(f.getPath(), mode, 0);

  return db;

public static SQLiteDatabase openDatabase(Stringpath, CursorFactory

            factory, int flags,DatabaseErrorHandlererrorHandler) {

    //又调用openDatabase创建SQLiteDatabase实例，真的是层层转包啊

   SQLiteDatabase sqliteDatabase = openDatabase(path, factory,

                                              flags, errorHandler,(short) 0);

    if(sBlockSize == 0)  sBlockSize = newStatFs("/data").getBlockSize();

     //为该SQLiteDatabase实例设置一些参数。这些内容和SQLite本身的特性有关，本书不

    //拟深入讨论这方面的内容，感兴趣的读者不妨参考SQLite官网提供的资料

    sqliteDatabase.setPageSize(sBlockSize);

    sqliteDatabase.setJournalMode(path, "TRUNCATE");

    synchronized(mActiveDatabases) {

           mActiveDatabases.add(

                     newWeakReference<SQLiteDatabase>(sqliteDatabase));

    returnsqliteDatabase;

private static SQLiteDatabase openDatabase(Stringpath, CursorFactory factory,

                             int flags,DatabaseErrorHandler errorHandler,

                             shortconnectionNum) {

   //构造一个SQLiteDatabase实例

  SQLiteDatabase db = new SQLiteDatabase(path, factory, flags,errorHandler,

                                                 connectionNum);

        db.dbopen(path, flags);//打开数据库,dbopen是一个native函数

        db.setLocale(Locale.getDefault());//设置Locale

        ......

         returndb;

    }......

private SQLiteDatabase(String path, CursorFactoryfactory, int flags,

           DatabaseErrorHandler errorHandler, short connectionNum) {

  setMaxSqlCacheSize(DEFAULT_SQL_CACHE_SIZE);

   mFlags =flags;

   mPath = path;

   mFactory= factory;

   mPrograms= new WeakHashMap<SQLiteClosable,Object>();

   // config_cursorWindowSize值为2048，所以下面得到的limit值应该为8MB

   int limit= Resources.getSystem().getInteger(

               com.android.internal.R.integer.config_cursorWindowSize)

                * 1024 * 4;

  native_setSqliteSoftHeapLimit(limit);

static void dbopen(JNIEnv* env, jobject object,jstring pathString, jint flags)

    int err;

    sqlite3* handle = NULL;

   sqlite3_stmt * statement = NULL;

    charconst * path8 = env->GetStringUTFChars(pathString, NULL);

    intsqliteFlags;

   registerLoggingFunc(path8);

    if(flags & CREATE_IF_NECESSARY) {

       sqliteFlags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;

    } ......

    //调用sqlite3_open_v2函数创建数据库,sqlite3_open_v2和示例中的sqlite3_open类似

    //handle用于存储新创建的sqlite3*类型的实例

    err =sqlite3_open_v2(path8, &handle, sqliteFlags, NULL);

    ......

   sqlite3_soft_heap_limit(sSqliteSoftHeapLimit);

    err =sqlite3_busy_timeout(handle, 1000 /* ms */);

    ......

    //Android在原生SQLite之上还做了一些特殊的定制，相关内容留待本节最后分析

    err =register_android_functions(handle, UTF16_STORAGE);

    //将handle保存到Java层的SQLiteDatabase对象中，这样Java层SQLiteDatabase实例

    //就和一个Native层的sqlite3实例绑定到一起了

   env->SetIntField(object, offset_db_handle, (int) handle);

    handle =NULL;  // The caller owns the handle now.

done:

    if(path8 != NULL) env->ReleaseStringUTFChars(pathString, path8);

    if(statement != NULL) sqlite3_finalize(statement);

    if(handle != NULL) sqlite3_close(handle);

SQLiteCompiledSql(SQLiteDatabase db, String sql) {

   db.verifyDbIsOpen();

   db.verifyLockOwner();

   mDatabase = db;

    mSqlStmt= sql;

    ......

    nHandle= db.mNativeHandle;

   native_compile(sql);//调用native_compile函数，代码如下

static void native_compile(JNIEnv* env, jobjectobject, jstring sqlString)

   compile(env, object, GET_HANDLE(env, object), sqlString);

//来看compile的实现

sqlite3_stmt * compile(JNIEnv* env, jobjectobject,

                       sqlite3 * handle,jstring sqlString)

    int err;

    jcharconst * sql;

    jsizesqlLen;

   sqlite3_stmt * statement = GET_STATEMENT(env, object);

   if(statement != NULL) ....//释放之前的sqlite3_stmt实例

    sql = env->GetStringChars(sqlString,NULL);

    sqlLen =env->GetStringLength(sqlString);

   //调用sqlite3_prepare16_v2得到一个sqlite3_stmt实例

    err =sqlite3_prepare16_v2(handle, sql, sqlLen * 2, &statement, NULL);

   env->ReleaseStringChars(sqlString, sql);

    if (err== SQLITE_OK) {

        //保存到Java层的SQLiteCompliteSql对象中

       env->SetIntField(object, gStatementField, (int)statement);

       return statement;

    } ......

db.execSQL("CREATE TRIGGER IF NOT EXISTSimages_cleanup DELETE ON images " +

            "BEGIN " +

            "DELETE FROM thumbnails WHERE image_id = old._id;" +

            "SELECT _DELETE_FILE(old._data);" +

            "END");

提示_DELETE_FILE这个操作曾给笔者及同仁带来极大困扰，因为最开始并不知道有这个触发器。结果好不容易下载的测试文件全部被删除了。另外，由于MediaProvider本身的设计缺陷，频繁挂/卸载SD卡时也会错误删除数据库信息（这个缺陷只能尽量避免，无法彻底根除），结果实体文件也被删除掉了。

//dbopen调用它时，第二个参数设置为0

extern "C" intregister_android_functions(sqlite3 * handle, int utf16Storage)

    int err;

   UErrorCode status = U_ZERO_ERROR;

   UCollator * collator = ucol_open(NULL, &status);

    ......

    if(utf16Storage) {

       err =sqlite3_exec(handle, "PRAGMA encoding = 'UTF-16'", 0, 0, 0);

      ......

    } else {

        //sqlite3_create_collation_xx定义一个用于排序的文本比较函数，读者可自行阅读

      //SQLite官方文档以获得更详细的说明

       err = sqlite3_create_collation_v2(handle,"UNICODE",

                SQLITE_UTF8, collator, collate8,

               (void(*)(void*))localized_collator_dtor);

     调用sqlite3_create_function创建一个名为"PHONE_NUMBERS_EQUAL"的函数，

     第三个参数2表示该函数有两个参数，SQLITE_UTF8表示字符串编码为UTF8,

     phone_numbers_equal为该函数对应的函数指针，也就是真正会执行的函数。注意

     "PHONE_NUMBERS_EQUAL"是SQL语句中使用的函数名，phone_numbers_equal是Native

     层对应的函数

    err =sqlite3_create_function(

       handle, "PHONE_NUMBERS_EQUAL", 2,

       SQLITE_UTF8, NULL, phone_numbers_equal, NULL, NULL);

    ......

    //注册_DELETE_FILE对应的函数为delete_file

    err =sqlite3_create_function(handle, "_DELETE_FILE", 1, SQLITE_UTF8,

                                 NULL, delete_file, NULL, NULL);

    if (err!= SQLITE_OK) {

       return err;

#if ENABLE_ANDROID_LOG

    err =sqlite3_create_function(handle, "_LOG", 1, SQLITE_UTF8,

                                    NULL, android_log,NULL, NULL);

    ......

#endif

   ......//和PHONE相关的一些函数

    returnSQLITE_OK;

static void delete_file(sqlite3_context * context,int argc,

                                          sqlite3_value** argv)

    if (argc!= 1) {

       sqlite3_result_int(context, 0);

       return;

    //从argv中取出第一个参数，这个参数是触发器调用_DELETE_FILE时传递的

    charconst * path = (char const *)sqlite3_value_text(argv[0]);

    ......

     Android4.0之后，系统支持多个存储空间（很多平板都有一块很大的内部存储空间）。

     为了保持兼容性，环境变量EXTERNAL_STORAGE还是指向sd卡的挂载目录,而其他存储设备的

    挂载目录由SECCONDARY_STORAGE表示，各个挂载目录由冒号分隔。

    下面这段代码用于判断_DELETE_FILE函数所传递的文件路径是不是正确的

    boolgood_path = false;

    charconst * external_storage = getenv("EXTERNAL_STORAGE");

    if(external_storage && strncmp(external_storage,

                                     path,strlen(external_storage)) == 0) {

       good_path = true;

    } else {

        charconst * secondary_paths = getenv("SECONDARY_STORAGE");

       while (secondary_paths && secondary_paths[0]) {

           const char* colon = strchr(secondary_paths, ':');

           int length = (colon ? colon - secondary_paths :

                                              strlen(secondary_paths));

           if (strncmp(secondary_paths, path, length) == 0) {

               good_path = true;

           secondary_paths += length;

            while (*secondary_paths == ':')secondary_paths++;

    if(!good_path) {

       sqlite3_result_null(context);

       return;

    //调用unlink删除文件

    int err= unlink(path);

    if (err!= -1) {

       sqlite3_result_int(context, 1);//设置返回值

    } else {

      sqlite3_result_int(context, 0);

建议先从SQLiteDatabase开始分析，学习成本会较大，因此，可尝试自己封装一个轻量级的C++SQLite库，通过这次尝试，学习并掌握如何设计一个良好的框架。

   注意query中的参数，它们组合后得到的SQL语句如下（方括号中的语句为笔者添加的注释）

   SELECT projection指定的列名[如果projection为null，则使用“*”]

   FROM 表名[由目标CP根据uri参数设置] WHERE

   （selection）[如果selection中有通配符，具体参数由selectionArgs指定]

    ORDERYEDBY sortOrder

public final Cursor query(Uri uri, String[]projection,

           String selection, String[] selectionArgs, String sortOrder) {

    根据前面的分析，下面这个函数返回的provider的真实类型是ContentProviderProxy，

     对应的Bn端对象的真实类型是ContentProvider的内部类Transport。本次执行query的

    目标CP是MediaProvider

  IContentProvider provider = acquireProvider(uri);

  //来看下面的代码

           long startTime = SystemClock.uptimeMillis();

           //①调用远端进程的query函数

           Cursor qCursor = provider.query(uri, projection,

                              selection, selectionArgs, sortOrder);

           if (qCursor == null) {

               //如果返回的结果为空，则释放provider，这个函数的作用在7.2.3节介绍过

               releaseProvider(provider);

               return null;

           //②计算查询结果包含的数据项条数，结果保存在qCursor的内部变量中

           qCursor.getCount();

           long durationMillis = SystemClock.uptimeMillis() - startTime;

          //③最终返回给客户端一个游标对象，其真实数据类型为CursorWrapperInner

           return new CursorWrapperInner(qCursor, provider);

public Cursor query(Uri url, String[] projection,String selection,

           String[] selectionArgs, String sortOrder) throws RemoteException {

  //①构造一个BulkCursorToCursorAdaptor对象

 BulkCursorToCursorAdaptor adaptor = new BulkCursorToCursorAdaptor();

  Parceldata = Parcel.obtain();

  Parcel reply = Parcel.obtain();

      data.writeInterfaceToken(IContentProvider.descriptor);

      ......//将参数打包到data请求包中

      //②adaptor.getObserver()返回一个IContentObserver类型的对象，把它

     //也打包到data请求包中。ContentObserver相关的知识留到第8章再分析

      data.writeStrongBinder(adaptor.getObserver().asBinder());

       //发送请求给远端的Bn端

      mRemote.transact(IContentProvider.QUERY_TRANSACTION, data, reply, 0);

       DatabaseUtils.readExceptionFromParcel(reply);

      //③从回复包中得到一个IBulkCursor类型的对象

       IBulkCursor bulkCursor =

                     BulkCursorNative.asInterface(reply.readStrongBinder());

       if(bulkCursor != null) {

           int rowCount = reply.readInt();

           int idColumnPosition = reply.readInt();

            boolean wantsAllOnMoveCalls = reply.readInt() != 0;

            //④调用adaptor的initialize函数

            adaptor.initialize(bulkCursor, rowCount,

                          idColumnPosition, wantsAllOnMoveCalls);

           } ......

           return adaptor;

        } ......

       finally {

           data.recycle();

           reply.recycle();

public boolean onTransact(int code, Parcel data, Parcelreply, int flags)

                                throws RemoteException {

       switch (code) {

        case QUERY_TRANSACTION://处理query请求

         data.enforceInterface(IContentProvider.descriptor);

         Uri url = Uri.CREATOR.createFromParcel(data);

         ......//从请求包中提取参数

          //⑤创建ContentObserver Binder通信的Bp端

         IContentObserver observer = IContentObserver.Stub.asInterface(

                           data.readStrongBinder());

          //⑥调用MediaProvider实现的query函数。Cursor是一个接口类，那么变量

        //cursor的真实类型是什么？

         Cursor cursor = query(url, projection, selection, selectionArgs,

                                      sortOrder);

          if(cursor != null) {

           //⑦创建一个CursorToBulkCursorAdaptor类型的对象

               CursorToBulkCursorAdaptor adaptor = new

                         CursorToBulkCursorAdaptor(

                                cursor,observer, getProviderName());

                final IBinder binder = adaptor.asBinder();

                //⑧返回结果集所含记录项的条数，这个函数看起来极不起眼，但却非常为关键

                final int count = adaptor.count();

                //返回名为"_id"的列在结果集中的索引位置，该列由数据库在创建表时自动添加

                final int index = BulkCursorToCursorAdaptor.findRowIdColumnIndex(

                              adaptor.getColumnNames());

                //wantsAllOnMoveCalls一般为false，读者阅读完本章后再自行分析它

                final boolean wantsAllOnMoveCalls =

                                    adaptor.getWantsAllOnMoveCalls();

                 reply.writeNoException();

                //将binder的信息写到reply回复包中

                reply.writeStrongBinder(binder);

                reply.writeInt(count);//将结果集包含的记录项行数返回给客户端

                reply.writeInt(index);

                reply.writeInt(wantsAllOnMoveCalls ? 1 : 0);

           }......

        return true;

       }......//其他情况处理

     ......

注意图7-5借用了UML的序列图来展示query调用顺序，其中ContentProvider框和MediaProviderer框代表同一个对象。另外，图7-5中的调用函数编号并不完全对应代码中的关键函数调用编号。

public Cursor query(Uri uri, String[]projectionIn, String selection,

           String[] selectionArgs, String sort) {

   int table= URI_MATCHER.match(uri);

   ......

  //根据uri取出对应的DatabaseHelper对象，MediaProvider针对内部存储中的媒体文件和

  //外部存储(即SD卡)中的媒体文件分别创建了两个数据库

 DatabaseHelper database = getDatabaseForUri(uri);

  //我们在7.3.2节分析过getReadableDatabase函数的兄弟getWritableDatabase函数

 SQLiteDatabase db = database.getReadableDatabase();

  //创建一个SQLiteQueryBuilder对象，用于方便开发人员编写SQL语句

 SQLiteQueryBuilder qb = new SQLiteQueryBuilder();

   ......//设置qb的参数，例如调用setTables函数为本次查询设定目标Table

  //①调用SQLiteQueryBuilder的query函数

  Cursor c =qb.query(db, projectionIn, selection,

               combine(prependArgs, selectionArgs), groupBy, null, sort, limit);

  if (c !=null) {

    //2调用该Cursor对象的setNotificationUri函数，这部分内容和ContentObserver

   //有关,相关内容留到第8章再进行分析

    c.setNotificationUri(getContext().getContentResolver(), uri);

  return c;

public Cursor query(SQLiteDatabase db, String[]projectionIn,

           String selection, String[] selectionArgs, String groupBy,

           String having, String sortOrder, String limit) {

  ......

  //调用buildQuery函数得到对应SQL语句的字符串

  String sql= buildQuery(

               projectionIn, selection, groupBy, having,

               sortOrder, limit);

    调用SQLiteDatbase的rawQueryWithFactory函数，mFactory是SQLiteQueryBuilder

    的成员变量，初始值为null，本例也没有设置它，故mFactory为null

   returndb.rawQueryWithFactory(

               mFactory, sql, selectionArgs,

               SQLiteDatabase.findEditTable(mTables));

public Cursor rawQueryWithFactory(

    CursorFactory cursorFactory, String sql, String[] selectionArgs,

     StringeditTable) {

  verifyDbIsOpen();

  BlockGuard.getThreadPolicy().onReadFromDisk();

   //数据库开发中经常碰到连接池的概念，其目的也是缓存重型资源。有兴趣的读者不妨自行

   //研究一下面这个getDbConnection函数

  SQLiteDatabase db = getDbConnection(sql);

   //创建一个SQLiteDirectCursorDriver对象

  SQLiteCursorDriver driver = new SQLiteDirectCursorDriver(

                                     db, sql,editTable);

   Cursorcursor = null;

         //调用SQLiteCursorDriver的query函数

         cursor = driver.query(

                   cursorFactory != null ? cursorFactory : mFactory,

                   selectionArgs);

        }finally {

           releaseDbConnection(db);

  returncursor;

public Cursor query(CursorFactory factory,String[] selectionArgs) {

   //本例中，factory为空

  SQLiteQuery query = null;

       mDatabase.lock(mSql);

       mDatabase.closePendingStatements();

        //①构造一个SQLiteQuery对象

       query = new SQLiteQuery(mDatabase, mSql, 0, selectionArgs);

       //原来，最后返回的游标对象其真实类型是SQLiteCursor

       if(factory == null) {//②构造一个SQLiteCursor对象

            mCursor = new SQLiteCursor(this, mEditTable, query);

        }else {

             mCursor =factory.newCursor(mDatabase, this,

                                mEditTable, query);

       mQuery = query;

       query = null;

       return mCursor;//原来返回的cursor对象其真实类型是SQLiteCursor

        }finally {

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

        mDatabase.unlock();

注意这里的MediaProvider query指的是图7-5中的编号为8关键调用。

SQLiteQuery(SQLiteDatabase db, String query, intoffsetIndex,

             String[] bindArgs) {

   //注意，在本例中offsetIndex为0，offsetIndex的意义到后面再解释

   super(db,query);//调用基类构造函数

  mOffsetIndex = offsetIndex;

  bindAllArgsAsStrings(bindArgs);

SQLiteProgram(SQLiteDatabase db, String sql) {

    this(db,sql, null, true);//调用另外一个构造函数，注意传递的参数

SQLiteProgram(SQLiteDatabase db, String sql,Object[] bindArgs,

           boolean compileFlag) {

   //本例中bindArgs为null，compileFlag为true

   mSql =sql.trim();

   //返回该SQL语句的类型，query语句将返回STATEMENT_SELECT类型

   int n =DatabaseUtils.getSqlStatementType(mSql);

   switch(n) {

       caseDatabaseUtils.STATEMENT_UPDATE:

          mStatementType = n | STATEMENT_CACHEABLE;

          break;

       caseDatabaseUtils.STATEMENT_SELECT:

          mStatementType成员变量用于标示该SQL语句的类型，如果该SQL语句

           是STATEMENT_SELECT类型，则mStatementType将设置STATEMENT_CACHEABLE

           标志。该标志表示此对象将被缓存起来，以避免再次执行同样的SELECT命令时重新构造

          mStatementType = n | STATEMENT_CACHEABLE |

                        STATEMENT_USE_POOLED_CONN;

               break;

       ......//其他情况处理

       default:

           mStatementType = n;

  db.acquireReference();//增加引用计数

  db.addSQLiteClosable(this);

   mDatabase= db;

   nHandle =db.mNativeHandle;//此mNativeHandle对应一个SQLite3实例

    if(bindArgs != null) ......//绑定参数

   //complieAndBindAllArgs将为此对象绑定一个sqlite3_stmt实例，native层对象的指针

   //保存在nStatement成员变量中

    if(compileFlag)    compileAndbindAllArgs();

void compileAndbindAllArgs() {

   ......

      //如果该对象还未和native层的sqlite3_stmt实例绑定，则调用compileSql函数

        if(nStatement == 0)  compileSql();

       ......//绑定参数

        for(int index : mBindArgs.keySet()) {

           Object value = mBindArgs.get(index);

           if (value == null) {

               native_bind_null(index);

           }......//绑定其他类型的数据

private void compileSql() {

   //如果mStatementType未设置STATEMENT_CACHEABLE标志，则每次都创建一个

   // SQLiteCompiledSql对象。根据7.3.2节小标题3中的分析，该对象会真正和native层的

  //sqlite_stmt实例绑定

   if((mStatementType & STATEMENT_CACHEABLE) == 0) {

         mCompiledSql = new SQLiteCompiledSql(mDatabase, mSql);

         nStatement = mCompiledSql.nStatement;

         return;

   //从SQLiteDatabase对象中查询是否已经缓存过符合该SQL语句要求的SQLiteCompiledSql

  mCompiledSql = mDatabase.getCompiledStatementForSql(mSql);

   if(mCompiledSql == null) {

       //创建一个新的SQLiteCompiledSql对象，并把它保存到mDatabase中

      mCompiledSql = new SQLiteCompiledSql(mDatabase, mSql);

      mCompiledSql.acquire();

      mDatabase.addToCompiledQueries(mSql, mCompiledSql);

   } ......

   //保存Native层sqlite3_stmt实例指针到nStatement成员变量

   nStatement= mCompiledSql.nStatement;

思考与直接使用SQLite API相比，SQLiteDatabase框架明显考虑了更多问题。不知读者自己封装C++ SQLite库时是否想到了这些问题？

public SQLiteCursor(SQLiteCursorDriver driver,String editTable,

                      SQLiteQuery query) {

   ......

   mDriver =driver;

  mEditTable = editTable;

  mColumnNameMap = null;

   mQuery =query;//保存此SQLiteQuery对象

  query.mDatabase.lock(query.mSql);

       //得到此次执行query得到的结果集所包含的列数

       intcolumnCount = mQuery.columnCountLocked();

      mColumns = new String[columnCount];

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

            String columnName = mQuery.columnNameLocked(i);

           //保存列名

            mColumns[i] = columnName;

            if ("_id".equals(columnName)) {

                   mRowIdColumnIndex = i;//保存“_id”列在结果集中的索引位置

        }finally {

           query.mDatabase.unlock();

public CursorToBulkCursorAdaptor(Cursor cursor,IContentObserver observer,

           String providerName) {

   //传入的cursor变量其真实类型是SQLiteCursor，它是CrossProcessCursor

   if(cursor instanceof CrossProcessCursor) {

       mCursor = (CrossProcessCursor)cursor;

   } else {

       mCursor = new CrossProcessCursorWrapper(cursor);

  mProviderName = providerName;

 synchronized (mLock) {//和ContentObserver有关，我们以后再作分析

    createAndRegisterObserverProxyLocked(observer);

public int count() {

  synchronized (mLock) {

     throwIfCursorIsClosed();//如果mCursor已经关闭，则抛异常

    //CursorToBulkCursorAdaptor的mCursor变量的真实类型是SQLiteCursor

     returnmCursor.getCount();

public int getCount() {

  if (mCount== NO_COUNT) {//NO_COUNT为-1，首次调用时满足if条件

       fillWindow(0);//关键函数

  returnmCount;

private void fillWindow(int startPos) {

   //①如果CursorWinodow已经存在，则清空（clear）它，否则新创建一个

   //CursorWinodow对象

  clearOrCreateLocalWindow(getDatabase().getPath());

  mWindow.setStartPosition(startPos);

   //②getQuery返回一个SQLiteQuery对象，此处将调用它的fillWindow函数

   int count= getQuery().fillWindow(mWindow);

   if (startPos == 0) {

        mCount= count;

   } ......

protected void clearOrCreateLocalWindow(Stringname) {

   if(mWindow == null) {

      mWindow = new CursorWindow(name, true);//创建一个CursorWindow对象

    }else  mWindow.clear();//清空CursorWindow中的信息

public CursorWindow(String name, booleanlocalWindow) {

  mStartPos= 0;//本次查询的起始行位置，例如查询数据库表中第10到第100行的结果，

                //其起始行就是10

   调用nativeCreate函数，注意传递的参数，其中sCursorWindowSize为2MB，localWindow

   为true。sCursorWindowSize是一个静态变量，其值取自frameworks/base/core/res/res

  /values/config.xml中定义的config_cursorWindowSize变量，该值是2048KB，而

  sCursorWindow在此基础上扩大了1024倍，最终的结果就是2MB

  mWindowPtr= nativeCreate(name, sCursorWindowSize, localWindow);

 mCloseGuard.open("close");

 recordNewWindow(Binder.getCallingPid(), mWindowPtr);

static jint nativeCreate(JNIEnv* env, jclassclazz,

       jstring nameObj, jint cursorWindowSize, jboolean localOnly) {

   String8name;

   if(nameObj) {

       const char* nameStr = env->GetStringUTFChars(nameObj, NULL);

       name.setTo(nameStr);

       env->ReleaseStringUTFChars(nameObj, nameStr);

   ......

   CursorWindow* window;

    //创建一个Native层的CursorWindow对象

    status_tstatus = CursorWindow::create(name, cursorWindowSize,

                                          localOnly,&window);

   ......

    returnreinterpret_cast<jint>(window);//将指针转换成jint类型

status_t CursorWindow::create(const String8&name, size_t size, bool localOnly,

       CursorWindow** outCursorWindow) {

    String8ashmemName("CursorWindow: ");

   ashmemName.append(name);

   ashmemName.append(localOnly ? " (local)" : "(remote)");

    status_tresult;

    //创建共享内存，调用Android平台提供的ashmem_create_region函数

    intashmemFd = ashmem_create_region(ashmemName.string(), size);

    if(ashmemFd < 0) {

       result = -errno;

    } else {

       result = ashmem_set_prot_region(ashmemFd, PROT_READ | PROT_WRITE);

        if(result >= 0) {

           //映射共享内存以得到一块地址，data变量指向该地址的起始位置

           void* data = ::mmap(NULL, size, PROT_READ | PROT_WRITE,

                                       MAP_SHARED,ashmemFd, 0);

            ......

            result= ashmem_set_prot_region(ashmemFd, PROT_READ);

            if (result >= 0) {

                   //创建一个CursorWindow对象

                   CursorWindow* window = new CursorWindow(name, ashmemFd,

                                               data, size, false);

                   result = window->clear();

                    if (!result) {

                       *outCursorWindow = window;

                        return OK;//创建成功

           }......//出错处理

    returnresult;

CursorWindow创建中涉及共享内存方面的知识，读者可上网查询或阅读卷I的 7.2.2节。

int fillWindow(CursorWindow window) {

 mDatabase.lock(mSql);

  longtimeStart = SystemClock.uptimeMillis();

       acquireReference();//增加一次引用计数

             window.acquireReference();

                调用nativeFillWindow函数完成功能。其中，nHandle指向Native层的

                sqlite3实例，nStatement指向Native层的sqlite3_stmt实例，

                window.mWindowPtr指向Native层的CursorWindow实例，

                 该函数最终返回这次SQL语句执行后得到的结果集中的记录项个数。

                mOffsetIndex参数的解释见下文

              int numRows = nativeFillWindow(nHandle,

                             nStatement,window.mWindowPtr,

                             window.getStartPosition(), mOffsetIndex);

               mDatabase.logTimeStat(mSql, timeStart);

               return numRows;

           }...... finally {

               window.releaseReference();

        }finally {

           releaseReference();

           mDatabase.unlock();

SELECT * FROM IMAGES LIMIT 10 OFFSET 1

//上面这条SQL语句的意思是从IMAGES表中查询10条记录，10条记录的起始位置从第1条开始。

//也就是查询第1到第11条记录

static jint nativeFillWindow(JNIEnv* env, jclassclazz, jint databasePtr,

        jintstatementPtr, jint windowPtr, jint startPos, jint offsetParam) {

    //取出Native层的实例

    sqlite3*database = reinterpret_cast<sqlite3*>(databasePtr);

   sqlite3_stmt* statement =reinterpret_cast<sqlite3_stmt*>(statementPtr);

   CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);

    if(offsetParam > 0) {

       //如果设置了查询的OFFSET，则需要为其绑定起始行。，根据下面的设置，读者能

      //推测出未绑定具体值的SQL语句吗？答案是：

      //SELECT* FROM TABLE OFFSET ， 其中，offsetParam指明是第几个通配符，

     //startPos用于绑定到这个通配符

        interr = sqlite3_bind_int(statement, offsetParam, startPos);

    }  ......

   //计算本次query返回的结果集的列数

   int numColumns =sqlite3_column_count(statement);

    //将SQL执行的结果保存到CursorWindow对象中

   status_tstatus = window->setNumColumns(numColumns);

   ......

    intretryCount = 0;

    inttotalRows = 0;

    intaddedRows = 0;

    boolwindowFull = false;

    boolgotException = false;

   //是否遍历所有结果

    constbool countAllRows = (startPos == 0);

   //注意下面这个循环，它将遍历SQL的结果集，并将数据取出来保存到CursorWindow对象中

    while(!gotException && (!windowFull || countAllRows)) {

        interr = sqlite3_step(statement);

        if(err == SQLITE_ROW) {

          retryCount = 0;

           totalRows += 1;

          //windowFull变量用于标示CursorWindow是否还有足够内存。从前面的介绍可知，

          //一个CursorWindow只分配了2MB的共享内存空间

          if (startPos >= totalRows || windowFull) {

               continue;

           //在共享内存中分配一行空间用于存储这一行的数据

           status = window->allocRow();

           if (status) {

              windowFull = true;// CursorWindow已经没有空间了

               continue;

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

                //获取这一行记录项中各列的值

               int type = sqlite3_column_type(statement, i);

               if (type == SQLITE_TEXT) {

                     //如果这列中存储的是字符串，则将其取出来并通过CursorWindow的

                    //putString函数保存到共享内存中

                     const char* text =reinterpret_cast<const char*>(

                           sqlite3_column_text(statement, i));

                     size_t sizeIncludingNull =sqlite3_column_bytes(statement, i)

                   status = window->putString(addedRows, i, text,

                                                    sizeIncludingNull);

                   if (status) {

                        windowFull = true;

                        break;//CursorWindow没有足够的空间

               } ......处理其他数据类型

           if (windowFull || gotException) {

               window->freeLastRow();

           } else {

               addedRows += 1;

        }else if (err == SQLITE_DONE) {

            ......//结果集中所有行都遍历完

           break;

        }else if (err == SQLITE_LOCKED || err == SQLITE_BUSY) {

            //如果数据库正因为其他操作而被锁住，此处将尝试等待一段时间

           if (retryCount > 50) {//最多等50次，每次1秒钟

               throw_sqlite3_exception(env,database, "retrycount exceeded");

               gotException = true;

           } else {

               usleep(1000);

               retryCount++;

       }......

    //重置sqlite3_stmt实例，以供下次使用

   sqlite3_reset(statement);

    ......//返回结果集中的行数

    returncountAllRows ? totalRows : 0;

建议笔者在做网络开发时常做的一件事情就是将自定义的一些类实例对象序列化到一块内存中，然后将这块内存的内容通过socket发送给一个远端进程，而远端进程再将收到的数据反序列化以得到一个实例对象。通过这种方式，远端进程就得到了一个来自发送端的实例对象。读者不妨自学序列化/反序列化相关的知识。

public final class BulkCursorToCursorAdaptorextends AbstractWindowedCursor {

    privatestatic final String TAG = "BulkCursor";

    //mObserverBridge和ContentOberver有关，我们留到7.5节再分析

    privateSelfContentObserver mObserverBridge = new SelfContentObserver(this);

    privateIBulkCursor mBulkCursor;

    privateint mCount;

    privateString[] mColumns;

    privateboolean mWantsAllOnMoveCalls;

  //initialize函数

    publicvoid initialize(IBulkCursor bulkCursor, int count, int idIndex,

           boolean wantsAllOnMoveCalls) {

       mBulkCursor = bulkCursor;

       mColumns = null;

       mCount = count;

       mRowIdColumnIndex = idIndex;

       mWantsAllOnMoveCalls = wantsAllOnMoveCalls;//该值为false

   ......

private final class CursorWrapperInner extendsCursorWrapper {

       private final IContentProvider mContentProvider;

       public static final String TAG="CursorWrapperInner";

        CloseGuard类是Android dalvik虚拟机提供的一个辅助类，用于帮助开发者判断

         使用它的类的实例对象是否被显示关闭（close）。例如，假设有一个CursorWrapperInner

          对象，当没有地方再引用它时，其finalize函数将被调用。如果之前没有调用过

         CursorWrapperInner的close函数，那么finalize函数CloseGuard的warnIsOpen

         将打印警告信息："A resource was acquired atattached stack trace but never

         released.See java.io.Closeable for informationon avoiding resource

         leaks."。 感兴趣的读者可自行研究CloseGuard类

       private final CloseGuard mCloseGuard = CloseGuard.get();

       private boolean mProviderReleased;

       CursorWrapperInner(Cursor cursor, IContentProvider icp) {

           super(cursor);//调用基类的构造函数，其内部会将cursor变量保存到mCursor中

           mContentProvider = icp;

           mCloseGuard.open("close");

    ......

 publicboolean moveToFirst() {

   //mCursor指向BulkCursorToCursorAdaptor

   returnmCursor.moveToFirst();

 publicfinal boolean moveToFirst() {

    returnmoveToPosition(0);//调用moveToPosition，直接来看该函数

//moveToPosition分析，其参数position表示将移动游标到哪一行

public final boolean moveToPosition(int position){

   //getCount返回结果集中的行数，这个值在搭建Binder通信通道时，已经由服务端计算并返回

   //给客户端了

   final int count = getCount();

   //mPos变量记录了当前游标的位置，该变量初值为-1

   if(position >= count) {

         mPos = count;

         return false;

   if(position < 0) {

        mPos = -1;

         returnfalse;

    if(position == mPos)  return true;

    //onMove函数为抽象函数，由子类实现

    booleanresult = onMove(mPos, position);

    if(result == false) mPos = -1;

     else {

           mPos = position;

           if (mRowIdColumnIndex != -1) {

               mCurrentRowID = Long.valueOf(getLong(mRowIdColumnIndex));

    returnresult;

public boolean onMove(int oldPosition, intnewPosition) {

 throwIfCursorIsClosed();

     //mWindow的类型就是CursorWindow。第一次调用该函数，mWindow为null

      if(mWindow == null

            ||newPosition < mWindow.getStartPosition()

            || newPosition >= mWindow.getStartPosition()+

                                 mWindow.getNumRows()){

              mBulkCurosr用于和位于服务端的IBulkCursor Bn端通信,其getWindow函数

              将返回一个CursorWindow类型的对象。也就是说，调用完getWindow函数后，

              客户端进程就得到了一个CursorWindow，从此，客户端和服务端之间的数据通道就

            setWindow(mBulkCursor.getWindow(newPosition));

        }else if (mWantsAllOnMoveCalls) {

            mBulkCursor.onMove(newPosition);

        } ......

     if (mWindow== null)  return false;

     returntrue;

public CursorWindow getWindow(int startPos) throwsRemoteException

    Parceldata = Parcel.obtain();

    Parcelreply = Parcel.obtain();

         data.writeInterfaceToken(IBulkCursor.descriptor);

         data.writeInt(startPos);

         mRemote.transact(GET_CURSOR_WINDOW_TRANSACTION, data, reply, 0);

         DatabaseUtils.readExceptionFromParcel(reply);

         CursorWindow window = null;

          if(reply.readInt() == 1) {

              根据服务端reply包构造一个本地的CursorWindow对象，读者可自行研究

              newFromParcel函数，其内部会调用nativeCreateFromParcel函数以创建

              一个Native的CursorWindow对象。整个过程就是笔者在前面提到的反序列化过程

               window = CursorWindow.newFromParcel(reply);

           return window;

        } ......

public CursorWindow getWindow(int startPos) {

 synchronized (mLock) {

    throwIfCursorIsClosed();

     CursorWindow window;

      //mCursor是MediaProvider query返回的值，其真实类型是SQLiteCursor，满足

     //下面的if条件

     if(mCursor instanceof AbstractWindowedCursor) {

          AbstractWindowedCursor windowedCursor =

                                             (AbstractWindowedCursor)mCursor;

          //对于本例而言，SQLiteCursor已经和一个CursorWindow绑定了，所以window的值

         //不为空

          window = windowedCursor.getWindow();

           if (window == null) {

                 window = new CursorWindow(mProviderName, false);

                 windowedCursor.setWindow(window);

              //调用SQLiteCursor的moveToPosition函数，该函数前面已经分析过了，在其               //内部将触发onMove函数的调用，此处将是SQLiteCursor的onMove函数

               mCursor.moveToPosition(startPos);

           } else {

              ......

           if (window != null) {

               window.acquireReference();

           return window;

public boolean onMove(int oldPosition, intnewPosition) {

   if(mWindow == null || newPosition < mWindow.getStartPosition() ||

       newPosition >= (mWindow.getStartPosition() +

                                                       mWindow.getNumRows())) {

           fillWindow(newPosition);

     returntrue;

public boolean onMove(int oldPosition, intnewPosition) {

 throwIfCursorIsClosed();

      //同样，客户端也做了对应的优化处理，如果不满足if条件，客户端根本无需调用

    //mBulkCurosr的getWindow函数，这样服务端也就不会收到对应的Binder请求了

      if(mWindow == null

            ||newPosition < mWindow.getStartPosition()

            || newPosition >=mWindow.getStartPosition() +

                                 mWindow.getNumRows()){

            setWindow(mBulkCursor.getWindow(newPosition));

 ......

建议 如果写代码时不重视资源回收，等最后出问题时再来查找泄露点的做法，会极大地增加了软件开发的成本。虽然Java提供了垃圾回收机制，但希望读者不要把资源回收的意识丢失。

public void close() {

  super.close();//调用基类的close函数

   //撤销客户端进程和目标CP进程的亲密关系

  ContentResolver.this.releaseProvider(mContentProvider);

  mProviderReleased = true;

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

public void close() {

  mCursor.close();  //mCursor指向BulkCursorToCursorAdaptor

public void close() {

 super.close();//①再次调用基类close函数，该函数会释放本地创建的CursorWindow资源

  if(mBulkCursor != null) {

            mBulkCursor.close();//②调用远端对象的close函数

       }......

      finally {

               mBulkCursor = null;

public void close() {

   mClosed =true;

  mContentObservable.unregisterAll();

  onDeactivateOrClose();//调用子类实现的onDeactivateOrClose函数

protected void onDeactivateOrClose() {

    //又调用基类即AbstractCursor的onDeactivateOrClose函数

   super.onDeactivateOrClose();

   closeWindow();//释放CursorWindow资源

protected void closeWindow() {

  if(mWindow != null) {

      mWindow.close();//调用CurosrWindow的close函数

      mWindow = null;

public void close() {

   releaseReference();//减少一次引用计数

public void releaseReference() {

   booleanrefCountIsZero = false;

   synchronized(this) {

       refCountIsZero = --mReferenceCount == 0;

   if(refCountIsZero) {//当引用计数减为0时，就可以真正释放资源了

       onAllReferencesReleased();//调用子类实现的onAllReferencesReleased函数

protected void onAllReferencesReleased() {

  dispose();//调用dispose

private void dispose() {

  if(mCloseGuard != null) {

      mCloseGuard.close();

  if(mWindowPtr != 0) {

      recordClosingOfWindow(mWindowPtr);

       //调用nativeDispose函数，该函数内部会释放Native层的CursorWindow对象

       //至此，客户端获取的那块共享内存就彻底释放干净了

      nativeDispose(mWindowPtr);

      mWindowPtr = 0;

public void close() {

  synchronized (mLock) {

        disposeLocked();

private void disposeLocked() {

   if (mCursor != null) {

        //注销ContentObserver有关，相关知识留到第8章再分析

        unregisterObserverProxyLocked();

       mCursor.close();//调用SQLiteCursor的close函数

       mCursor = null;

   closeWindowForNonWindowedCursorLocked();

public void close() {

  //和客户端一样，先调用AbstractCursor的close，最后会触发AbstractWindowedCursor

  //onDeactivateOrClose函数，在那里，服务端的CursorWindow走向终结

 super.close();

 synchronized (this) {

      mQuery.close();//调用SQLiteQuery的close，内部将释放sqlite3_stmt实例

      //调用SQLiteDirectCursorDriver的cursorClose函数

      mDriver.cursorClosed();

protected void finalize() throws Throwable {

       if(mCloseGuard != null) {

           mCloseGuard.warnIfOpen();//打印一句警告

        if(!mProviderReleased && mContentProvider != null) {

            ContentResolver.this.releaseProvider(mContentProvider);

       //上边这段代码除了打印一句警告外，并没有调用close函数

     }finally {

          super.finalize();//调用基类的finalize，它会有什么特殊处理吗？

提示笔者在分析Monkey测试失败案例时发现，导致进程问题的原因都在android.process.media中。根据对finalize的分析可知，问题的根源在客户端。由于使用MediaProvider的客户端较多（包括Music、Gallery3D、Video等），所以每次出现这种问题时，都需要所有MediaProvider的客户端开发者协助调查。

提示另外，通过对close函数的分析，读者也见识了过度封装的坏处，即在派生树中反复寻找对应函数的实现。虽然并非代码设计者故意如此，但是继承关系过多就很容易产生这种情况。目前笔者也没有找到完美的解决办法，欢迎广大读者参与讨论。

public final AssetFileDescriptoropenAssetFileDescriptor(Uri uri,

           String mode) throws FileNotFoundException {

    //openAssetFileDescriptor是一个通用函数，它支持三种scheme类型的URI。见

    //下文的解释

   Stringscheme = uri.getScheme();

   if(SCHEME_ANDROID_RESOURCE.equals(scheme)) {

        if(!"r".equals(mode)) {

              throw new FileNotFoundException("Can't write resources: " +uri);

       //创建资源文件输入流

      OpenResourceIdResult r = getResourceId(uri);

             return r.r.openRawResourceFd(r.id);

         } ......

        }else if (SCHEME_FILE.equals(scheme)) {

           //创建普通文件输入流

           ParcelFileDescriptor pfd = ParcelFileDescriptor.open(

                   new File(uri.getPath()), modeToMode(uri, mode));

           return new AssetFileDescriptor(pfd, 0, -1);

        }else {

           if ("r".equals(mode)) {

                //我们重点分析这个函数，用于读取目标ContentProvider的数据

               return openTypedAssetFileDescriptor(uri, "*/*", null);

           } ......//其他模式的支持，请读者学完本章后自行研究这部分内容

public final AssetFileDescriptoropenTypedAssetFileDescriptor(Uri uri,

           String mimeType, Bundle opts) throws FileNotFoundException {

    //建立和目标CP进程交互的通道。读者还记得此处provider的真实类型吗？

    //其真实类型是ContentProviderProxy

   IContentProvider provider = acquireProvider(uri);

           //①调用远端CP的openTypedAssetFile函数，返回值的

          //类型是AssetFileDescriptor。此处传递参数的值为：mimeType="*/*"

          //opts=null

           AssetFileDescriptor fd = provider.openTypedAssetFile(uri,

                                          mimeType, opts);

           ......

           //②创建一个ParcelFileDescriptor类型的变量

           ParcelFileDescriptor pfd = new ParcelFileDescriptorInner(

                   fd.getParcelFileDescriptor(), provider);

           provider = null;

           //③又创建一个AssetFileDescriptor类型的变量作为返回值

           return new AssetFileDescriptor(pfd, fd.getStartOffset(),

                   fd.getDeclaredLength());

        }......

         finally {

           if (provider != null) {

               releaseProvider(provider);

提示简单向读者介绍一下与AssetFileDescriptor相关的知识。它用于读取APK包中指定的资源数据。以前面提到的test.ogg为例，如果通过AssetFileDescriptor读取它，那么其mFd成员则指向一个ParcelFileDescriptor对象。且不管这个对象是否跨越了进程边界，它毕竟代表一个文件。假设这个文件是一个APK包，AssetFileDescriptor的mStartOffset变量用于指明test.ogg在这个APK包中的起始位置，比如100字节。而mLength用于指明test.ogg的长度，假设是1000字节。通过上面的介绍可知，该APK文件从100字节到1100字节这一段空间中存储的就是test.ogg的数据。这样，AssetFileDescriptor就能将test.ogg数据从APK包中读取出来了。

public AssetFileDescriptor openTypedAssetFile(Uriuri, String mimeTypeFilter,

                      Bundle opts) throws FileNotFoundException {

    //本例满足下面的if条件

    if("*/*".equals(mimeTypeFilter))

         return openAssetFile(uri, "r");//此函数的代码见下文

    StringbaseType = getType(uri);

    if(baseType != null &&

               ClipDescription.compareMimeTypes(baseType, mimeTypeFilter)) {

          return openAssetFile(uri, "r");

   throw newFileNotFoundException("Can't open " +

                uri + " as type " + mimeTypeFilter);

public AssetFileDescriptor openAssetFile(Uri uri,String mode)

           throws FileNotFoundException {

   //openFile由子类实现。这里还以MediaProvider为例

    ParcelFileDescriptor fd = openFile(uri, mode);

   //根据openFile返回的fd得到一个AssetFileDescriptor对象

    returnfd != null ? new AssetFileDescriptor(fd, 0, -1) : null;

public ParcelFileDescriptor openFile(Uri uri,String mode)

           throws FileNotFoundException {

  ParcelFileDescriptor pfd = null;

   //假设URI符合下面的if条件，即客户端想读取的是某音乐文件所属专辑（Album）的信息

   if(URI_MATCHER.match(uri) == AUDIO_ALBUMART_FILE_ID) {

       DatabaseHelper database = getDatabaseForUri(uri);

        ......

       SQLiteDatabase db = database.getReadableDatabase();

       ......

       SQLiteQueryBuilder qb = new SQLiteQueryBuilder();

        //得到客户端指定的代表该音乐文件的_id值

        intsongid = Integer.parseInt(uri.getPathSegments().get(3));

       qb.setTables("audio_meta");

       qb.appendWhere("_id=" + songid);

       Cursor c = qb.query(db,

                   new String [] {

                       MediaStore.Audio.Media.DATA,

                       MediaStore.Audio.Media.ALBUM_ID },

                   null, null, null, null, null);

        if(c.moveToFirst()) {

             String audiopath = c.getString(0);

             //获取该音乐所属的album_id值

             int albumid = c.getInt(1);

             //注意，下面函数中调用的ALBUMART_URI将指向album_art表

             Uri newUri = ContentUris.withAppendedId(ALBUMART_URI, albumid);

                   //调用ContentProvider实现的openFileHelper函数。注意，pfd的

                   //类型是ParcelFileDescriptor

                   pfd = openFileHelper(newUri, mode);

               } ......

           c.close();

           return pfd;

    ......

protected final ParcelFileDescriptoropenFileHelper(Uri uri,

           String mode) throws FileNotFoundException {

  //获取缩略图的文件路径

  Cursor c =query(uri, new String[]{"_data"}, null, null, null);

  int count= (c != null) ? c.getCount() : 0;

  if (count!= 1) {

     ......//一个album_id只能对应一个缩略图文件

  c.moveToFirst();

   int i =c.getColumnIndex("_data");

   Stringpath = (i >= 0 ? c.getString(i) : null);

   c.close();

    if (path == null)

           throw new FileNotFoundException("Column _data not found.");

    intmodeBits = ContentResolver.modeToMode(uri, mode);

    //创建ParcelFileDescriptor对象，内部会首先打开一个文件以得到

   //一个FileDescriptor对象，然后再创建一个ParcelFileDescriptor对象，其实

   //就是设置ParcelFileDescriptor中成员变量mFileDescriptor的值

    returnParcelFileDescriptor.open(new File(path), modeBits);

提示实际上还有更多的原因，读者不妨尝试在以上两点原因的基础上拓展思考。

public void writeToParcel(Parcel out, int flags) {

   //往Parcel包中直接写入mFileDescriptor指向的FileDescriptor对象

  out.writeFileDescriptor(mFileDescriptor);

   if((flags&PARCELABLE_WRITE_RETURN_VALUE) != 0 && !mClosed) {

               close();

           }......

static voidandroid_os_Parcel_writeFileDescriptor(JNIEnv* env,

                           jobject clazz,jobject object)

    Parcel*parcel = parcelForJavaObject(env, clazz);

    if(parcel != NULL) {

        //先调用jniGetFDFromFileDescriptor从Java层FileDescriptor对象中

       //取出对应的文件描述符。在Native层，文件描述符是一个int整型

       //然后调用Native parcel对象的writeDupFileDescriptor函数

       const status_t err =

               parcel->writeDupFileDescriptor(

                                   jniGetFDFromFileDescriptor(env, object));

        if(err != NO_ERROR) {

           signalExceptionForError(env, clazz, err);

status_t Parcel::writeDupFileDescriptor(int fd)

    returnwriteFileDescriptor(dup(fd), true);

//直接来看writeFileDescriptor函数

status_t Parcel::writeFileDescriptor(int fd, booltakeOwnership)

   flat_binder_object obj;

    obj.type= BINDER_TYPE_FD;

   obj.flags = 0x7f | FLAT_BINDER_FLAG_ACCEPTS_FDS;

   obj.handle = fd; //将MediaProvider打开的文件描述符传递给Binder协议

   obj.cookie = (void*) (takeOwnership ? 1 : 0);

    returnwriteObject(obj, true);

public final ParcelFileDescriptorreadFileDescriptor() {

  //从internalReadFileDescriptor中返回一个FileDescriptor对象

 FileDescriptor fd = internalReadFileDescriptor();

  //构造一个ParcelFileDescriptor对象，该对象对应的文件就是服务端打开的那个缩略图文件

  return fd!= null ? new ParcelFileDescriptor(fd) : null;

static jobjectandroid_os_Parcel_readFileDescriptor(JNIEnv* env, jobject clazz)

    Parcel*parcel = parcelForJavaObject(env, clazz);

    if(parcel != NULL) {

        //调用Parcel的readFileDescriptor得到一个文件描述符

        intfd = parcel->readFileDescriptor();

        if(fd < 0) return NULL;

        fd =dup(fd);//调用dup复制该文件描述符

        if(fd < 0) return NULL;

        //调用jniCreateFileDescriptor以返回一个Java层的FileDescriptor对象

       return jniCreateFileDescriptor(env, fd);

    returnNULL;

int Parcel::readFileDescriptor() const

    constflat_binder_object* flat = readObject(true);

    if(flat) {

       switch (flat->type) {

           case BINDER_TYPE_FD:

               //当服务端发送回复包的时候，handle变量指向fd。当客户端接收回复包的时候，

              //又从handle中得到fd。此fd是彼fd吗？

               return flat->handle;

    returnBAD_TYPE;

static void binder_transaction(struct binder_proc*proc,

                      structbinder_thread *thread,

                      structbinder_transaction_data *tr, int reply)

   ......

   switch(fp->type) {

    caseBINDER_TYPE_FD: {

            int target_fd;

            struct file *file;

            if (reply) {

             ......

            //Binder驱动根据服务端返回的fd找到内核中文件的代表file，其数据类型是

            //struct file

            file = fget(fp->handle);

            ......

            //target_proc为客户端进程，task_get_unused_fd_flags函数用于从客户端

           //进程中找一个空闲的整型值，用做客户端进程的文件描述符

            target_fd = task_get_unused_fd_flags(target_proc,

                                           O_CLOEXEC);

            ......

            //将客户端进程的文件描述符和代表文件的file对象绑定

            task_fd_install(target_proc, target_fd, file);

            fp->handle = target_fd;

     }break;

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

public <T> ParcelFileDescriptoropenPipeHelper(final Uri uri,

            finalString mimeType, final Bundle opts,

           final T args, final PipeDataWriter<T> func)

           throws FileNotFoundException {

           //创建管道

           final ParcelFileDescriptor[] fds = ParcelFileDescriptor.

                                              createPipe();

          //构造一个AsyncTask对象

           AsyncTask<Object, Object, Object> task = new

                                    AsyncTask<Object,Object, Object>() {

               @Override

               protected Object doInBackground(Object... params) {

                  //往管道写端写数据，如果没有这个后台线程的写操作，客户端无论如何

                  //也读不到数据的

                   func.writeDataToPipe(fds[1],uri, mimeType, opts, args);

                        fds[1].close();

                   } ......

                   return null;

          //AsyncTask.THREAD_POOL_EXECUTOR是一个线程池，task的doInBackground

          //函数将在线程池中的一个线程中运行

           task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,

                                      (Object[])null);

           return fds[0];//返回读端给客户端

        } ......