public static void main(String[] args) {

     if(System.currentTimeMillis() < EARLIEST_SUPPORTED_TIME) {

            //如果系統時鐘早於1970，則設定系統時鐘從1970開始

           Slog.w(TAG, "System clock is before 1970; setting to 1970.");

           SystemClock.setCurrentTimeMillis(EARLIEST_SUPPORTED_TIME);

        }

        //判斷效能統計功能是否開啟

        if(SamplingProfilerIntegration.isEnabled()) {

           SamplingProfilerIntegration.start();

           timer = new Timer();

           timer.schedule(new TimerTask() {

               @Override

               public void run() {

                   //SystemServer效能統計，每小時統計一次，統計結果輸出為檔案

                   SamplingProfilerIntegration.writeSnapshot("system_server",

                                                      null);

               }// SNAPSHOT_INTERVAL定義為1小時

           }, SNAPSHOT_INTERVAL, SNAPSHOT_INTERVAL);

        }

        //和Dalvik虛擬機器相關的設定，主要是記憶體使用方面的控制

       dalvik.system.VMRuntime.getRuntime().clearGrowthLimit();

       VMRuntime.getRuntime().setTargetHeapUtilization(0.8f);

        //載入動態庫libandroid_servers.so

       System.loadLibrary("android_servers");

       init1(args);//呼叫native的init1函式

  }

extern "C" int system_init();

static voidandroid_server_SystemServer_init1(JNIEnv* env, jobject clazz)

{

   system_init(); //呼叫上面那個用extern 宣告的system_init函式

}

extern "C" status_t system_init()

{

     LOGI("Enteredsystem_init()");

     //初始化Binder系統

   sp<ProcessState> proc(ProcessState::self());

     //獲取ServiceManager的客戶端物件BpServiceManager

   sp<IServiceManager> sm = defaultServiceManager();

   //GrimReaper是一個很“血腥“的名字，俗稱死神

    sp<GrimReaper>grim = new GrimReaper();

    /*

    下面這行程式碼的作用就是註冊grim物件為ServiceManager死亡資訊的接收者。一旦SM死亡，

    Binder系統就會傳送訃告資訊，這樣grim物件的binderDied函式就會被呼叫。該函式內部

    將kill自己（即SystemServer）。

    筆者覺得，對於這種因摯愛離世而自殺的物體，叫死神好像不太合適

    */

   sm->asBinder()->linkToDeath(grim, grim.get(), 0);

    charpropBuf[PROPERTY_VALUE_MAX];

    //判斷SystemServer是否啟動SurfaceFlinger服務，該值由init.rc

    //指令碼設定，預設為零，即不啟動SF服務

    property_get("system_init.startsurfaceflinger",propBuf, "1");

    /*

    從4.0開始，和顯示相關的核心服務surfaceflinger可獨立到另外一個程式中。

    筆者認為，這可能和目前SystemServer的負擔過重有關。另外，隨著智慧終端上HDMI的普及，

    未來和顯示相關的工作將會越來越繁重。將SF放在單獨程式中，不僅可加強集中管理，也可充分

    利用未來智慧終端上多核CPU的資源

    */

    if(strcmp(propBuf, "1") == 0) {

       SurfaceFlinger::instantiate();

    }

    //判斷SystemServer是否啟動感測器服務，預設將啟動感測器服務

   property_get("system_init.startsensorservice", propBuf,"1");

    if(strcmp(propBuf, "1") == 0) {

        //和SF相同，感測器服務也支援在獨立程式中實現

       SensorService::instantiate();

    }

    //獲得AndroidRuntime物件

   AndroidRuntime* runtime = AndroidRuntime::getRuntime();

    JNIEnv*env = runtime->getJNIEnv();

    ......//查詢Java層的SystemServer類，獲取init2函式的methodID

    jclassclazz = env->FindClass("com/android/server/SystemServer");

    ......

   jmethodID methodId = env->GetStaticMethodID(clazz, "init2","()V");

    ......//通過JNI呼叫Java層的init2函式

    env->CallStaticVoidMethod(clazz,methodId);

    //主執行緒加入Binder執行緒池

   ProcessState::self()->startThreadPool();

   IPCThreadState::self()->joinThreadPool();

    returnNO_ERROR;

}

通過註釋可看出，這段程式碼的作者也擔心被人指責，但至少可以把函式名取得更形象一點吧？

public static final void init2() {

        Thread thr = new ServerThread();

       thr.setName("android.server.ServerThread");

       thr.start();//啟動一個執行緒，這個執行緒就像英雄大會一樣，聚集了各路英雄

}

以上服務的分類並非官方標準，僅是筆者個人之見。

ServiceManager.addService("entropy", newEntropyService());

public EntropyService() {

        //呼叫另外一個建構函式，getSystemDir函式返回的是/data/system目錄

       this(getSystemDir() + "/entropy.dat","/dev/urandom");

}

public EntropyService(String entropyFile, StringrandomDevice) {

   this.randomDevice= randomDevice;//urandom是Linux系統中產生隨機數的裝置

   // /data/system/entropy.dat檔案儲存了系統此前的熵資訊

  this.entropyFile = entropyFile;

  //下面有4個關鍵函式

  loadInitialEntropy();//①

  addDeviceSpecificEntropy();//②

  writeEntropy();//③

  scheduleEntropyWriter();//④

}

out.println("Copyright (C) 2009 The AndroidOpen Source Project");

out.println("All Your Randomness Are BelongTo Us");

out.println(START_TIME);

out.println(START_NANOTIME);

out.println(SystemProperties.get("ro.serialno"));

out.println(SystemProperties.get("ro.bootmode"));

out.println(SystemProperties.get("ro.baseband"));

out.println(SystemProperties.get("ro.carrier"));

out.println(SystemProperties.get("ro.bootloader"));

out.println(SystemProperties.get("ro.hardware"));

out.println(SystemProperties.get("ro.revision"));

out.println(new Object().hashCode());

out.println(System.currentTimeMillis());

out.println(System.nanoTime());

EntropyService本身的程式碼很簡單，但是為了儘量保證隨機數的隨機性，Android還是下了一番苦功的。

ServiceManager.addService(Context.DROPBOX_SERVICE,//服務名為”dropbox”

                           new DropBoxManagerService(context,

                           newFile("/data/system/dropbox")));

public DropBoxManagerService(final Contextcontext, File path) {

       mDropBoxDir = path;//path指定dropbox目錄為/data/system/dropbox

       mContext = context;

       mContentResolver = context.getContentResolver();

       IntentFilter filter = new IntentFilter();

       filter.addAction(Intent.ACTION_DEVICE_STORAGE_LOW);

       filter.addAction(Intent.ACTION_BOOT_COMPLETED);

        //註冊一個Broadcast監聽物件，當系統啟動完畢或者裝置儲存空間不足時，會收到廣播

       context.registerReceiver(mReceiver, filter);

       //當Settings資料庫相應項發生變化時候，也需要告知DBMS進行相應處理

       mContentResolver.registerContentObserver(

           Settings.Secure.CONTENT_URI, true,

           new ContentObserver(new Handler()) {

               public void onChange(boolean selfChange) {

             //當Settings資料庫發生變化時候， BroadcastReceiver的onReceive函式

             //將被呼叫。注意第二個引數為null

                   mReceiver.onReceive(context,(Intent) null);

               }

        });

}

public void handleApplicationCrash(IBinder app,

                     ApplicationErrorReport.CrashInfocrashInfo) {

   ProcessRecordr = findAppProcess(app, "Crash");

   ......

   //呼叫addErrorToDropBox函式，第一個引數是一個字串，為“crash”

   addErrorToDropBox("crash",r, null, null, null, null, null, crashInfo);

   ......

}

public void addErrorToDropBox(String eventType,

           ProcessRecord process, ActivityRecord activity,

            ActivityRecordparent, String subject,

           final String report, final File logFile,

           final ApplicationErrorReport.CrashInfo crashInfo) {

    /*

    dropbox日誌檔案的命名有一定的規則，其字首都是一個特定的tag（標籤），

    tag由兩部分組成，合起來是”程式型別”_”事件型別”。

    下邊程式碼中的processClass函式返回該程式的型別，包括“system_server”、“system_app”

    和“data_app”三種。eventType用於指定事件型別，目前也有三種型別：“crash“、”wtf“

    （what aterrible failure）和“anr”

    */

    finalString dropboxTag = processClass(process) + "_" + eventType;

    //獲取DBMS Bn端的物件DropBoxManager

       final DropBoxManager dbox = (DropBoxManager)

               mContext.getSystemService(Context.DROPBOX_SERVICE);

     /*

      對於DBMS，不僅通過tag於標示檔名，還可以根據配置的情況，允許或禁止特定tag日誌

      檔案的記錄。isTagEnable將判斷DBMS是否禁止該標籤，如果該tag已被禁止，則不允許記

      錄日誌檔案

      */

        if(dbox == null || !dbox.isTagEnabled(dropboxTag)) return;

        //建立一個StringBuilder，用於儲存日誌資訊

       final StringBuilder sb = new StringBuilder(1024);

       appendDropBoxProcessHeaders(process, sb);

        ......//將資訊儲存到字串sb中

         //單獨啟動一個執行緒用於向DBMS新增資訊

       Thread worker = new Thread("Error dump: " + dropboxTag) {

           @Override

           public void run() {

               if (report != null) {

                   sb.append(report);

               }

               if (logFile != null) {

                   try {//如果有log檔案，那麼就把log檔案內容讀到sb中

                       sb.append(FileUtils.readTextFile(logFile,

                                128 * 1024,"\n\n[[TRUNCATED]]"));

                   } ......

               }

               //讀取crashInfo資訊，一般記錄的是呼叫堆疊資訊

               if (crashInfo != null && crashInfo.stackTrace != null) {

                   sb.append(crashInfo.stackTrace);

               }

               String setting = Settings.Secure.ERROR_LOGCAT_PREFIX + dropboxTag;

              //查詢Settings資料庫，判斷該tag型別的日誌是否對所記錄的資訊有行數限制，

             //例如某些tag的日誌檔案只准記錄1000行的資訊

              int lines =Settings.Secure.getInt(mContext.getContentResolver(),

                                                       setting, 0);

               if (lines > 0) {

                   sb.append("\n");

                     InputStreamReader input =null;

                   try {

                        //建立一個新程式以執行logcat，後面的引數都是logcat常用的引數

                        java.lang.Processlogcat = new

                          ProcessBuilder("/system/bin/logcat",

                        "-v","time", "-b", "events", "-b","system", "-b",

                             "main", "-t", String.valueOf(lines))

                                .redirectErrorStream(true).start();

                     //由於新程式的輸出已經重定向，因此這裡可以獲取最後lines行的資訊，

                   //不熟悉ProcessBuidler的讀者可以檢視SDK中關於它的用法說明

                     ......

                  }

               }

              //呼叫DBMS的addText

               dbox.addText(dropboxTag, sb.toString());

           }

        };

        if(process == null || process.pid == MY_PID) {

           worker.run(); //如果是SystemServer程式crash了，則不能在別的執行緒執行

        }else {

           worker.start();

     }

}

public void addText(String tag, String data) {

  /*

   mService和DBMS互動。DBMS對外只提供一個add函式用於日誌新增，而DBM提供了3個函式，

   分別是addText、addData、addFile，以方便我們的使用

  */

   try {mService.add(new Entry(tag, 0, data)); } ......

}

public void add(DropBoxManager.Entry entry) {

        Filetemp = null;

       OutputStream output = null;

        finalString tag = entry.getTag();//先取出這個Entry的tag

        try{

           int flags = entry.getFlags();

            ......

            //做一些初始化工作，包括生成dropbox目錄、統計當前已有的dropbox檔案資訊等

           init();

           if (!isTagEnabled(tag)) return;//如果該tag被禁止，則不能生成日誌檔案

           long max = trimToFit();

           long lastTrim = System.currentTimeMillis();

           //BlockSize一般是4KB

           byte[] buffer = new byte[mBlockSize];

           //從Entry中得到一個輸入流。與Java I/O相關的類比較多，且用法非常靈活

           //建議讀者閱讀《Java程式設計思想》中“Java I/O系統”一章

            InputStreaminput = entry.getInputStream();

            ......

           int read = 0;

           while (read < buffer.length) {

               int n = input.read(buffer, read, buffer.length - read);

                if (n <= 0) break;

               read += n;

           }

           //先生成一個臨時檔案，命名方式為”drop執行緒id.tmp”

           temp = new File(mDropBoxDir, "drop" +

                         Thread.currentThread().getId()+ ".tmp");

           int bufferSize = mBlockSize;

           if (bufferSize > 4096) bufferSize = 4096;

           if (bufferSize < 512) bufferSize = 512;

           FileOutputStream foutput = new FileOutputStream(temp);

           output = new BufferedOutputStream(foutput, bufferSize);

            //生成GZIP壓縮檔案

           if (read == buffer.length &&

                 ((flags &DropBoxManager.IS_GZIPPED) == 0)) {

               output = new GZIPOutputStream(output);

               flags = flags | DropBoxManager.IS_GZIPPED;

            }

            /*

                DBMS很珍惜/data分割槽，若所生成檔案的size大於一個BlockSize，

                則一定要先壓縮。

            */

            ......//寫檔案,這段程式碼非常繁瑣，其主要目的是儘量節省儲存空間

            /*

            生成一個EntryFile物件，並儲存到DBMS內部的一個資料容器中。

            DBMS除了負責生成檔案外，還提供查詢的功能，這個功能由getNextEntry完成。

             另外，剛才生成的臨時檔案在createEntry函式中會重命為帶標籤的名字，

            讀者可自行分析createEntry函式

            */

           long time = createEntry(temp, tag, flags);

           temp = null;

           Intent dropboxIntent = new

                         Intent(DropBoxManager.ACTION_DROPBOX_ENTRY_ADDED);

           dropboxIntent.putExtra(DropBoxManager.EXTRA_TAG, tag);

           dropboxIntent.putExtra(DropBoxManager.EXTRA_TIME, time);

           if (!mBooted) {

               dropboxIntent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);

           }

           //傳送DROPBOX_ENTRY_ADDED廣播。系統中目前還沒有程式接收該廣播

           mContext.sendBroadcast(dropboxIntent,

                            android.Manifest.permission.READ_LOGS);

        }......

}

//用來判斷是否允許記錄該tag型別的日誌檔案。預設是允許生成任何tag型別的檔案

Secure.DROPBOX_TAG_PREFIX+tag: “dropbox:”+tag

//用於控制每個日誌檔案的存活時間，預設是三天。大於三天的日誌檔案就會被刪除以節省空間

Secure.DROPBOX_AGE_SECONDS: ”dropbox_age_seconds”

//用於控制系統儲存的日誌檔案個數，預設是1000個檔案

Secure.DROPBOX_MAX_FILES：”dropbox_max_files”

//用於控制dropbox目錄最多佔儲存空間容量的比例，預設是10%

Secure.DROPBOX_QUOTA_PERCENT:”dropbox_quota_percent”

//不允許dropbox使用的儲存空間的比例，預設是10%，也就是dropbox最多隻能使用90%的空間

Secure.DROPBOX_RESERVE_PERCENT:”dropbox_reserve_percent”

//dropbox最大能使用的空間大小，預設是5MB

Secure.DROPBOX_QUOTA_KB：”dropbox_quota_kb”

public class DiskStatsService extends Binder

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

{

    //先獲取與ServiceManager程式通訊的BpServiceManager物件

   sp<IServiceManager> sm = defaultServiceManager();

   fflush(stdout);

    Vector<String16> services;

   Vector<String16> args;

    if (argc== 1) {//如果輸入引數個數為1，則先查詢在SM中註冊的所有Service

       services = sm->listServices();

        //將service排序

       services.sort(sort_func);

        args.add(String16("-a"));

    } else {

        //指定查詢某個service

       services.add(String16(argv[1]));

        //儲存剩餘引數，以後可以傳給service的dump函式

        for(int i=2; i<argc; i++) {

           args.add(String16(argv[i]));

        }

    }

    constsize_t N = services.size();

    ......

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

       sp<IBinder> service = sm->checkService(services[i]);

        ......

         //通過Binder呼叫該service的dump函式，將args也傳給dump函式

         int err = service->dump(STDOUT_FILENO,args);

         ......

    }

    return0;

}

protected void dump(FileDescriptor fd, PrintWriterpw, String[] args) {

       byte[] junk = new byte[512];

        for(int i = 0; i < junk.length; i++) junk[i] = (byte) i; 

        //輸出/data/system/perftest.tmp檔案資訊，輸出後即刪除該檔案

        //目前還不清楚這個檔案由誰生成。從名字上看應該和效能測試有關

        Filetmp = new File(Environment.getDataDirectory(),

                                "system/perftest.tmp");

       FileOutputStream fos = null;

       IOException error = null;

        longbefore = SystemClock.uptimeMillis();

        try{

           fos = new FileOutputStream(tmp);

           fos.write(junk);

        } ......

        longafter = SystemClock.uptimeMillis();

        if(tmp.exists()) tmp.delete();

        if(error != null) {

            ......

        }else {

           pw.print("Latency: ");

           pw.print(after - before);

           pw.println("ms [512B Data Write]");

        }

        //列印內部儲存裝置各個分割槽的資訊

       reportFreeSpace(Environment.getDataDirectory(), "Data", pw);

       reportFreeSpace(Environment.getDownloadCacheDirectory(),"Cache", pw);

       reportFreeSpace(new File("/system"), "System", pw);

        //有些廠商還會將/proc/yaffs資訊列印出來

}

//DSMS的服務名為“devicestoragemonitor “

ServiceManager.addService(DeviceStorageMonitorService.SERVICE,

                        newDeviceStorageMonitorService(context));

public DeviceStorageMonitorService(Contextcontext) {

       mLastReportedFreeMemTime = 0;

       mContext = context;

       mContentResolver = mContext.getContentResolver();

       mDataFileStats = new StatFs(DATA_PATH);//獲取data分割槽的資訊

       mSystemFileStats = new StatFs(SYSTEM_PATH);// 獲取system分割槽的資訊

       mCacheFileStats = new StatFs(CACHE_PATH);// 獲取cache分割槽的資訊

        //獲得data分割槽的總大小

       mTotalMemory = ((long)mDataFileStats.getBlockCount() *

                       mDataFileStats.getBlockSize())/100L;

        /*

        建立三個Intent，分別用於通知儲存空間不足、儲存空間恢復正常和儲存空間滿。

        由於設定了REGISTERED_ONLY_BEFORE_BOOT標誌，這3個Intent廣播只能由

        系統服務接收

        */

       mStorageLowIntent = newIntent(Intent.ACTION_DEVICE_STORAGE_LOW);

       mStorageLowIntent.addFlags(

                        Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);

       mStorageOkIntent = new Intent(Intent.ACTION_DEVICE_STORAGE_OK);

       mStorageOkIntent.addFlags(

                   Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);

       mStorageFullIntent = new Intent(Intent.ACTION_DEVICE_STORAGE_FULL);

       mStorageFullIntent.addFlags(

                   Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);

       mStorageNotFullIntent = new

                    Intent(Intent.ACTION_DEVICE_STORAGE_NOT_FULL);

       mStorageNotFullIntent.addFlags(

                   Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);

        //查詢Settings資料庫中sys_storage_threshold_percentage的值，預設是10，

        //即當/data空間只剩下10%的時候，,認為空間不足

       mMemLowThreshold = getMemThreshold();

       //查詢Settings資料庫中的sys_storage_full_threshold_bytes的值，預設是1MB，

       //即當data分割槽只剩1MB時，就認為空間已滿，剩下的這1MB空間保留給系統自用

       mMemFullThreshold = getMemFullThreshold();

        //檢查記憶體

       checkMemory(true);

}

private final void checkMemory(boolean checkCache){

  if(mClearingCache) {

      ......//如果正在清理空間，則不作處理

     } else{

           restatDataDir();//重新計算三個分割槽的剩餘空間大小

            //如果剩餘空間低於mMemLowThreshold，那麼先清理一次空間

            clearCache();

            //如果空間仍不足，則傳送廣播，並在狀態列上設定一個警告通知

             sendNotification();

             ......

            //如果空間已滿，則呼叫下面這個函式，以傳送一次儲存已滿的廣播

             sendFullNotification();

        } ......

      //DEFAULT_CHECK_INTERVAL為1分鐘，即每一分鐘會觸發一次檢查，似乎有點短

       postCheckMemoryMsg(true, DEFAULT_CHECK_INTERVAL);

}

private final void clearCache() {

 if(mClearCacheObserver == null) {

      //建立一個CachePackageDataObserver物件,當PKM清理完空間時會回撥該物件的

      //onRemoveCompleted函式

      mClearCacheObserver = new CachePackageDataObserver();

   }

 mClearingCache= true;//設定mClearingCache的值為true，表示我們正在清理空間

 try {

     //呼叫PKM的freeStorageAndNotify函式以清理空間，這個函式在分析PKM時再介紹

    IPackageManager.Stub.asInterface(

            ServiceManager.getService("package")).

            freeStorageAndNotify(mMemLowThreshold,mClearCacheObserver);

   } ......

}

ServiceManager.addService("samplingprofiler",//服務名

                            newSamplingProfilerService(context));

public SamplingProfilerService(Context context) {

       //註冊一個CotentObserver，用於監測Settings資料庫的變化

       registerSettingObserver(context);

       startWorking(context);//① startWorking函式，見下文的分析

}

private void startWorking(Context context) {

      finalDropBoxManager dropbox = //得到DropBoxManager物件

               (DropBoxManager)

                   context.getSystemService(Context.DROPBOX_SERVICE);

        //列舉/data/snapshots目錄下的檔案

       File[] snapshotFiles = new File(SNAPSHOT_DIR).listFiles();

        for(int i = 0; snapshotFiles != null && i < snapshotFiles.length;

             i++) {

            //將這些檔案的內容轉移到dropbox中，然後刪除這個檔案

           handleSnapshotFile(snapshotFiles[i], dropbox);

        }

        //建立一個FileObserver物件監控shots目錄，如果目錄中來了新的檔案，那麼把它們

        //轉移到dropbox中

       snapshotObserver = new FileObserver(SNAPSHOT_DIR, FileObserver.ATTRIB) {

           @Override

           public void onEvent(int event, String path) {

               handleSnapshotFile(new File(SNAPSHOT_DIR, path), dropbox);

           }

        };

        //啟動資料夾監控，採用了Linux平臺的inotify機制，感興趣的讀者可以研究下inotify

       snapshotObserver.startWatching();

}

public static void main(String argv[]) {

try {

            //啟動效能統計

           SamplingProfilerIntegration.start();

           ......//Zygote做自己的工作

            //結束統計並生成結果檔案

           SamplingProfilerIntegration.writeZygoteSnapshot();

           ......

}

public static void start() {

        if(!enabled) {//判斷是否開啟效能統計。enable由誰控制？

           return;

        }

        ......

       ThreadGroup group = Thread.currentThread().getThreadGroup();

       SamplingProfiler.ThreadSet threadSet =

                             SamplingProfiler.newThreadGroupTheadSet(group);

        //建立一個dalvik的SamplingProfiler，我們暫時不會對它進行分析

        samplingProfiler= new SamplingProfiler(samplingProfilerDepth,

                                                        threadSet);

        //啟動統計

       samplingProfiler.start(samplingProfilerMilliseconds);

       startMillis = System.currentTimeMillis();

    }

static {

       samplingProfilerMilliseconds = //取系統屬性，預設值為0，即禁止效能統計

                   SystemProperties.getInt("persist.sys.profiler_ms", 0);

       samplingProfilerDepth =

                   SystemProperties.getInt("persist.sys.profiler_depth", 4);

         //如果samplingProfilerMilliseconds的值大於零，則允許效能統計

        if(samplingProfilerMilliseconds > 0) {

           File dir = new File(SNAPSHOT_DIR);

            ......//建立/data/snapshots目錄，並使其可寫

           if (dir.isDirectory()) {

               snapshotWriter = Executors.newSingleThreadExecutor(

                                                   new ThreadFactory() {

                        public ThreadnewThread(Runnable r) {

                            return newThread(r, TAG);//建立用於輸出統計檔案的工作執行緒

                        }

                   });

               enabled = true;

            } ......

        }else {

           snapshotWriter = null;

           enabled = false;

           Log.i(TAG, "Profiling disabled.");

        }

 }

public static void writeZygoteSnapshot() {

        ......

        //呼叫writeSnapshotFile函式，注意第一個引數為“zygote”，用於表示程式名

       writeSnapshotFile("zygote", null);

       samplingProfiler.shutdown();//關閉統計

       samplingProfiler = null;

       startMillis = 0;

}

SamplingProfilerIntegration的核心是SamplingProfiler，這個類定義在libcore/dalvik/src/main/java/dalvik/system/profiler/SamplingProfiler.java檔案中。感興趣的讀者可以研究一下該類的用法。在實際開發中，我一般使用Debug類提供的方法進行效能統計。

//首先獲取能與CBS互動的ClipboardManager物件

ClipboardManager clipboard = (ClipboardManager)

                          getSystemService(Context.CLIPBOARD_SERVICE);

//呼叫setPrimaryClip函式，引數是ClipData.newUri函式的返回值

clipboard.setPrimaryClip(ClipData.newUri( 

                                   getContentResolver(),"Note",noteUri));

static public ClipData newUri(ContentResolverresolver, CharSequence label,

                                      Uri uri) {

     Itemitem = new Item(uri); //建立一個Item，將Uri直接傳給它的建構函式

    String[] mimeTypes = null;

      /*

        下邊程式碼的功能是獲取這個Uri代表的資料的MIME型別。先嚐試利用ContentResolver

        從ContentProvider那查詢，如果查詢不到，則設定mimeTypes為

        MIMETYPES_TEXT_URILIST，它的定義是new String[“text/uri-list”]

      */

      if("content".equals(uri.getScheme())) {

           String realType = resolver.getType(uri);

           //查詢該uri所指向的資料的mimeTypes

           mimeTypes = resolver.getStreamTypes(uri, "*/*");

           if (mimeTypes == null) {

               if (realType != null) {

                   mimeTypes = new String[] {

                            realType,ClipDescription.MIMETYPE_TEXT_URILIST };

               }

           } else {

               ......

        }

        if(mimeTypes == null) {

           mimeTypes = MIMETYPES_TEXT_URILIST;

        }

        //建立一個ClipData物件

       return new ClipData(label, mimeTypes, item);

}

//ClipData的建構函式

public ClipData(CharSequence label, String[]mimeTypes, Item item) {

       mClipDescription = new ClipDescription(label, mimeTypes);

        ......

       mIcon = null;

       mItems.add(item);//將item物件新增到mItems陣列中

    }

URI和MIME的關係： URI指向資料的位置，這和PC機上檔案的儲存位置類似，例如c:/dfp。MIME則表示該資料的資料型別。在Windows平臺上是採用字尾名來表示檔案型別的，前面提到的c盤下的dfp檔案，字尾是wav，表示該檔案是一個wav音訊。

對於剪下板來說，資料來源由URI指定，資料型別由MIME表示，兩者缺一不可。

public void setPrimaryClip(ClipData clip) {

   try {

             //跨Binder呼叫，先要把引數打包。有興趣的讀者可以看看writToParcel函式

            getService().setPrimaryClip(clip);

        }catch (RemoteException e) {

   }

}

public void setPrimaryClip(ClipData clip) {

       synchronized (this) {

        ......

         //許可權檢查，後面會在3.7.3中單獨分析

          checkDataOwnerLocked(clip,Binder.getCallingUid());

         */

        //和許可權相關，後續會分析

       clearActiveOwnersLocked();

        //儲存新的clipData到mPrimaryClip中

       mPrimaryClip = clip;

        / *

           mPrimaryClipListeners是一個RemoteCallbackList陣列，

           當CBS中的ClipData發生變化時，CBS需要向那些監控剪下板的

           客戶端傳送通知。客戶端通過addPrimaryClipChangedListener函式

           註冊回撥

        */

       final int n = mPrimaryClipListeners.beginBroadcast();

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

        try{

               //通知客戶端，剪下板的內容發生變化

                mPrimaryClipListeners.getBroadcastItem(i).

                                        dispatchPrimaryClipChanged();

               }......

           }

           mPrimaryClipListeners.finishBroadcast();

        }

    }

RemoteCallbackList是一個比較重要的常用類，很有必要掌握它的用法。

final void performPaste() {

    //獲取ClipboardManager物件

   ClipboardManager clipboard = (ClipboardManager)

           getSystemService(Context.CLIPBOARD_SERVICE);

    //獲取ContentResolver物件

   ContentResolver cr = getContentResolver();

    //從剪貼簿中取出ClipData   

    ClipDataclip = clipboard.getPrimaryClip();

    if (clip!= null) {

       String text=null;

       String title=null;

        //取剪下板ClipData中的第一項Item

       ClipData.Item item = clip.getItemAt(0);

        /*

            下面這行程式碼取出Item中所包含的Uri。看起來順理成章，其實不然。

            應思考這樣一個問題，為什麼這裡一定是取Uri呢？原因是在本例中，

            copy方和paste方都事先了解ClipData中的資料型別。

            如果paste方不瞭解ClipData中的資料型別，該如何處理？

            一種簡單的方法就是採用if/else的判斷語句。另外還有別的方法，

            下文將做分析。

         */

        Uriuri = item.getUri();

       Cursor orig = cr.query(uri,PROJECTION, null, null,null);

           ......//查詢資料庫並獲取資訊

          orig.close();

           }

        }

        if(text == null) {

           //如果paste方不瞭解ClipData中的資料型別，可呼叫coerceToText

          //函式，強制得到文字型別的資料

           text = item.coerceToText(this).toString();//強制為文字

        }

      ......

}

public ClipData getPrimaryClip() {

   try {

           //呼叫CBS的getPrimaryClip，並傳遞自己的package名

           return getService().getPrimaryClip(mContext.getPackageName());

        }......

}

public ClipData getPrimaryClip(String pkg) {

       synchronized (this) {

           //賦予該pkg相應的許可權，後文再作分析

           addActiveOwnerLocked(Binder.getCallingUid(), pkg);

           return mPrimaryClip;//返回ClipData給客戶端

        }

}

public CharSequence coerceToText(Context context){

   //如果該Item已經有mText，則直接返回文字

   if (mText!= null) {

       return mText;

   }

   //如果該Item中的資料是URI型別

   if (mUri!= null) {

       FileInputStream stream = null;

        try{

              /*

                ContentProvider需要實現openTypedAssetFileDescriptor函式，

                以返回指定MIME（這裡是text/*）型別的資料來源（AssetFileDescriptor）

              */

              AssetFileDescriptor descr = context.getContentResolver()

                           .openTypedAssetFileDescriptor(mUri, "text/*", null);

              //建立一個輸入流

              stream = descr.createInputStream();

              //建立一個InputStreamReader，讀出來的資料將轉換成UTF-8的文字

              InputStreamReader reader = new InputStreamReader(stream,

                                                      "UTF-8");

              StringBuilder builder = new StringBuilder(128);

              char[] buffer = new char[8192];

              int len;

              //從ContentProvider那讀取資料，然後轉換成UTF-8的字串

              while ((len=reader.read(buffer)) > 0) {

                   builder.append(buffer, 0, len);

              }

              //返回String

              return builder.toString();

         } ......

   }

    //如果是Intent，則呼叫toUri返回一個字串

   if (mIntent != null) {

      returnmIntent.toUri(Intent.URI_INTENT_SCHEME);

     }

   return"";

  }

}

//copy方設定ClipData在CBS的setPrimaryClip函式中進行：

checkDataOwnerLocked(clip,Binder.getCallingUid());

clearActiveOwnersLocked();

//paste方獲取ClipData在CBS的getPrimaryClip函式中進行：

addActiveOwnerLocked(Binder.getCallingUid(), pkg);

<providerandroid:name="ContactsProvider2"

           ......

           android:readPermission="android.permission.READ_CONTACTS"

           android:writePermission="android.permission.WRITE_CONTACTS">

            ......

           <grant-uri-permission android:pathPattern=".*" />

</provider>

感興趣的讀者可閱讀SDK安裝目錄下/docs/guide/topics/security/security.html中關於URI Permission的說明部分。

private final void checkDataOwnerLocked(ClipDatadata, int uid) {

        //第二個引數uid為copy方程式的uid

       final int N = data.getItemCount();

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

           //為每一個item呼叫checkItemOwnerLocked

           checkItemOwnerLocked(data.getItemAt(i), uid);

        }

}

// checkItemOwnerLocked函式分析

private final voidcheckItemOwnerLocked(ClipData.Item item, int uid) {

        if(item.getUri() != null) {//檢查Uri

           checkUriOwnerLocked(item.getUri(), uid);

        }

       Intent intent = item.getIntent();

       //getData函式返回的也是一個URI，因此這裡實際上檢查的也是URI

        if(intent != null && intent.getData() != null) {

           checkUriOwnerLocked(intent.getData(), uid);

        }

}

private final void checkUriOwnerLocked(Uri uri,int uid) {

        ......

        longident = Binder.clearCallingIdentity();

       boolean allowed = false;

        try{

           /*

             呼叫ActivityManagerService的checkGrantUriPermission函式，

              該函式內部將檢查copy方是否能被賦予URI_READ許可權。如果不允許，

              該函式會拋SecurityException異常

           */

           mAm.checkGrantUriPermission(uid, null, uri,

                                           Intent.FLAG_GRANT_READ_URI_PERMISSION);

        }catch (RemoteException e) {

        }finally {

           Binder.restoreCallingIdentity(ident);

        }

    }

private final void addActiveOwnerLocked(int uid,String pkg) {

       PackageInfo pi;

        try{

          /*

           呼叫PackageManagerService的getPackageInfo函式得到相關資訊

            然後做一次安全檢查，如果PacakgeInfo的uid資訊和當前呼叫的uid不一致，

            則拋SecurityException。這個很好理解，因為paste方可以傳遞虛假的

           packagename，但uid是沒法造假的

           */

           pi = mPm.getPackageInfo(pkg, 0);

           if (pi.applicationInfo.uid != uid) {

               throw new SecurityException("Calling uid " + uid

                        + " does not ownpackage " + pkg);

           }

         } ......

        }

        //mActivePermissionOwners用來儲存已經通過安全檢查的package

        if(mPrimaryClip != null && !mActivePermissionOwners.contains(pkg)) {

           //針對ClipData中的每一個Item，都需要呼叫grantItemLocked來檢查許可權

           final int N = mPrimaryClip.getItemCount();

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

               grantItemLocked(mPrimaryClip.getItemAt(i), pkg);

           }//儲存package資訊到mActivePermissionOwners

           mActivePermissionOwners.add(pkg);

        }

}

//grantItemLocked分析

private final void grantItemLocked(ClipData.Itemitem, String pkg) {

        if(item.getUri() != null) {

           grantUriLocked(item.getUri(), pkg);

        } //和copy方一樣，這裡僅檢查URI的情況

       Intent intent = item.getIntent();

        if(intent != null && intent.getData() != null) {

           grantUriLocked(intent.getData(), pkg);

        }

}

private final void grantUriLocked(Uri uri, Stringpkg) {

        longident = Binder.clearCallingIdentity();

        try{

          /*

              呼叫ActivityManagerService的grantUriPermissionFromOwner函式，

              注意第二個引數傳遞的是CBS所在程式的uid。該函式內部也會檢查許可權。

               該函式呼叫成功後，paste方就被授予了對應URI的讀許可權

            */

           mAm.grantUriPermissionFromOwner(mPermissionOwner,

                                    Process.myUid(),pkg, uri,

                                   Intent.FLAG_GRANT_READ_URI_PERMISSION);

        }catch (RemoteException e) {

        } finally {

           Binder.restoreCallingIdentity(ident);

        }

}