Android之 MTP框架和流程分析

時間 2019-11-11

原文原文鏈接

概要

本文的目的是介紹Android系統中MTP的一些相關知識。主要的內容包括：
第1部分 MTP簡介
對Mtp協議進行簡單的介紹。
第2部分 MTP框架
介紹Android系統下MTP的框架。
第3部分 MTP啓動流程
詳細分析MTP服務的啓動流程，包括Java層, JNI層, kernel相關知識的介紹。
第4部分 MTP協議之I->R流程
以"PC中打開一個MTP上的文件(讀取文件內容)"爲例，來對"MTP協議中Initiator到Reponser的流程"進行說明。
第5部分 MTP協議之R->I流程
以"Android設備中將一個文件拷貝到其餘目錄"來對"MTP協議中Reponser到Initiator的流程"進行說明。
注意：本文的MTP分析的軟件環境Android 4.3 + Kernel 3.0！html

轉載請註明出處：http://www.cnblogs.com/skywang12345/p/3474206.htmljava

第1部分 MTP簡介

MTP，全稱是Media Transfer Protocol（媒體傳輸協議）。它是微軟的一個爲計算機和便攜式設備之間傳輸圖像、音樂等所定製的協議。android

Android從3.0開始支持MTP。MTP的應用分兩種角色，一個是做爲Initiator，另外一個做爲Responder。以"Android平板電腦"鏈接"PC"爲例，他們的關係如圖1-01所示。數據庫

Initiator —— 在MTP中全部的請求都有Initiator發起。例如，PC請求獲取Android平板電腦上的文件數據。數組

Responder —— 它會處理Initiator的請求；除此以外，Responder也會發送Event事件。瀏覽器

圖1-01服務器

注意：關於MTP的詳細規格請參考《MTP_Specification_V1.0》！架構

第2部分 MTP框架

Android中MTP的框架如圖2-01所示：併發

圖2-01框架

說明：

在Kernel層，USB驅動負責數據交換，而MTP驅動負責和上層進行通訊，同時也和USB驅動進行通訊。

(01)USB驅動負責數據交換，是指Android設備和PC經過USB數據線鏈接以後，實際的數據交換是通過USB數據線發送給USB驅動的。

(02)對於"MTP請求"而言，MTP驅動會從USB驅動中解析出的MTP請求數據，而後傳遞給上層。而對於上層傳來的"MTP反饋"，MTP驅動也會將反饋內容打包好以後，經過傳遞給USB驅動。

在JNI層，MtpServer會不斷地監聽Kernel的消息"MTP請求"，並對相應的消息進行相關處理。同時，MTP的Event事件也是經過MtpServer發送給MTP驅動的。 MtpStorage對應一個"存儲單元"；例如，SD卡就對應一個MtpStorage。 MtpPacket和MtpEventPacket負責對MTP消息進行打包。android_mtp_MtpServer是一個JNI類，它是"JNI層的MtpServer 和 Java層的MtpServer"溝通的橋樑。android_mtp_MtpDatabase也是一個JNI類，JNI層經過它實現了對MtpDatabase(Framework層)的操做。

在Framework層，MtpServer至關於一個服務器，它經過和底層進行通訊從而提供了MTP的相關服務。MtpDatabase充當着數據庫的功能，但它自己並無數據庫對數據進行保存，本質上是經過MediaProvider數據庫獲取所須要的數據。MtpStorage對應一個"存儲單元"，它和"JNI層的MtpStorage"相對應。

在Application層，MtpReceiver負責接收廣播，接收到廣播後會啓動/關閉MtpService；例如，MtpReceiver收到"Android設備和 PC連上"的消息時，會啓動MtpService。 MtpService的做用是提供管理MTP的服務，它會啓動MtpServer，以及將本地存儲內容和MTP的內容同步。 MediaProvider在MTP中的角色，是本地存儲內容查找和本地內容同步；例如，本地新增一個文件時，MediaProvider會通知MtpServer從而進行MTP數據同步。

第3部分 MTP啓動流程

該部分對MTP服務的啓動流程進行詳細介紹。咱們先經過時序圖對MTP啓動流程有個總體印象，而後再經過代碼進行詳細分析。其中，涉及的內容，包括Java層、JNI層和Kernel。

MTP服務啓動時，Java層的程序流程以下圖3-01所示。

圖3-01

說明：MTP服務啓動的觸發事件是"PC和Android設備創建MTP鏈接"。當她們創建MTP鏈接時，USB驅動將產生USB鏈接消息，並最終通知UsbManager。UsbManager發出廣播，而且廣播被MtpReceiver收到；MtpReceiver收到廣播後會啓動MtpService，同時通知MediaProvider。MediaProvider會與MtpService綁定，若Android設備中的文件結構有變化(如"新鍵文件")，MediaProvider則會通知MtpService。MtpService啓動後會建立MtpDatabase；以後，還會建立MtpServer，MtpServer會和MtpDatabase關聯。而後，MtpService會遍歷本地的存儲設備，並創建相應的MtpStorage，並將該MtpStorage添加到MtpDatabase和MtpServer中。最後，MtpService會啓動MtpServer。

MTP服務啓動時，JNI層的程序流程以下圖3-02所示。

圖3-02

說明：前面說過MtpService啓動後會前後建立MtpDatabase對象和MtpServer對象(Java層)，而後啓動MtpServer(Java層)。

在建立MtpDatabase對象時，會經過native_setup()調用JNI本地方法。目的是進行初始化，爲後面的MtpServer調用作準備。

在建立MtpServer對象(Java層)時，會經過native_setup()調用JNI本地方法。在本地方法中，打開MTP驅動建立的文件節點"/dev/mtp_usb"，並會獲取MyMtpDatabase對象，而後建立"MtpServer對象(JNI層)"。

在啓動MtpServer線程時，會對應的執行MtpServer(JNI層)的run()方法。MtpServer(JNI層)的run()中會不斷的從"/dev/mtp_usb"中讀取數據，並進行相應的處理。

涉及到的主要文件的路徑：

packages/providers/MediaProvider/src/com/android/providers/media/MtpReceiver.java
packages/providers/MediaProvider/src/com/android/providers/media/MtpService.java
packages/providers/MediaProvider/src/com/android/providers/media/MediaProvider.java
frameworks/base/media/java/android/mtp/MtpServer.java
frameworks/base/media/java/android/mtp/MtpDatabase.java
frameworks/base/media/java/android/mtp/MtpStorage.java
frameworks/base/media/jni/android_mtp_MtpServer.cpp
frameworks/base/media/jni/android_mtp_MtpDatabase.cpp
frameworks/av/media/mtp/MtpServer.h
frameworks/av/media/mtp/MtpServer.cpp
frameworks/av/media/mtp/MtpDatabase.h

接下來，經過代碼對MTP的服務啓動的各個流程進行分析

1 USB_STATE廣播

USB_STATE廣播，即"android.hardware.usb.action.USB_STATE"廣播。它是在USB連上/斷開時，由UsbManager發出的廣播；MtpReceive會接收該廣播並進行處理。

例如，當"Android設備"和"PC"經過USB鏈接時，MtpReceiver會接收到USB_STATE廣播，並判斷"USB是否是連上，MTP是否是Enable狀態"從而決定是否啓動MtpService。

1.1 MtpReceiver監聽廣播的註冊

MtpReceiver.java在它對應的manifest中註冊監聽"android.intent.action.BOOT_COMPLETED" 和 "android.hardware.usb.action.USB_STATE" 監聽。

packages/providers/MediaProvider/AndroidManifest.xml中的源碼以下：

1 <receiver android:name=".MtpReceiver">
2     <intent-filter>
3         <action android:name="android.intent.action.BOOT_COMPLETED" />
4     </intent-filter>
5     <intent-filter>
6         <action android:name="android.hardware.usb.action.USB_STATE" />
7     </intent-filter>
8 </receiver>

說明：

這是採用靜態方式註冊的廣播，通過上面的註冊以後，MtpReceiver就能夠接收"android.intent.action.BOOT_COMPLETED" 和 "android.hardware.usb.action.USB_STATE" 這兩個廣播了。

(01) "android.intent.action.BOOT_COMPLETED" -- 是Android設備開機完成後發出的廣播。

MtpReceiver經過該廣播，來處理開機時Android設備和PC就已是鏈接狀態的狀況。

該字符串對應是frameworks/base/core/java/android/content/Intent.java中的ACTION_BOOT_COMPLETED變量，源碼以下：

public static final String ACTION_BOOT_COMPLETED = "android.intent.action.BOOT_COMPLETED";

(02) "android.hardware.usb.action.USB_STATE" -- 是USB鏈接狀態發生變化時產生的廣播。

MtpReceiver經過該廣播，來處理Android設備和PC之間經過USB線熱插拔的狀況。

該字符串對應是frameworks/base/core/java/android/hardware/usb/UsbManager.java中的ACTION_USB_STATE變量，源碼以下：

public static final String ACTION_USB_STATE = "android.hardware.usb.action.USB_STATE";

1.2 MtpReceiver對廣播的處理

MtpReceiver對廣播的處理在MtpReceiver.java中實現，源碼以下：

 1 public void onReceive(Context context, Intent intent) {
 2     final String action = intent.getAction();
 3     if (Intent.ACTION_BOOT_COMPLETED.equals(action)) {
 4         final Intent usbState = context.registerReceiver(
 5                 null, new IntentFilter(UsbManager.ACTION_USB_STATE));
 6         if (usbState != null) {
 7             handleUsbState(context, usbState);
 8         }
 9     } else if (UsbManager.ACTION_USB_STATE.equals(action)) {
10         handleUsbState(context, intent);
11     }
12 }

說明：

MtpReceiver的onReceive()中會處理Intent.ACTION_BOOT_COMPLETED 和 UsbManager.ACTION_USB_STATE 這兩個廣播。

Intent.ACTION_BOOT_COMPLETED 和 UsbManager.ACTION_USB_STATE 的處理流程同樣，最終都是經過handleUsbState()來處理的。下面的是基於UsbManager.ACTION_USB_STATE廣播。

當"Android設備"和"PC"鏈接時，Android系統會檢測USB鏈接事件併發出UsbManager.ACTION_USB_STATE廣播。MtpReceiver最終會調用handleUsbState()對該廣播進行處理。

1.3 MtpReceiver的handleUsbState()

handleUsbState()也在MtpReceiver.java中實現，源碼以下：

 1 private void handleUsbState(Context context, Intent intent) {
 2     Bundle extras = intent.getExtras();
 3     boolean connected = extras.getBoolean(UsbManager.USB_CONFIGURED);    // 獲取USB的鏈接狀態
 4     boolean mtpEnabled = extras.getBoolean(UsbManager.USB_FUNCTION_MTP); // 獲取MTP的Enable狀態
 5     boolean ptpEnabled = extras.getBoolean(UsbManager.USB_FUNCTION_PTP); // 獲取PTP的Enable狀態
 6 
 7     if (connected && (mtpEnabled || ptpEnabled)) {
 8         // 若是USB是鏈接狀態，而且「MTP或者PTP是Enable狀態」就執行下面的代碼
 9 
10         intent = new Intent(context, MtpService.class);
11         if (ptpEnabled) {
12             intent.putExtra(UsbManager.USB_FUNCTION_PTP, true);
13         }
14         // 啓動MtpService服務
15         context.startService(intent);
16         // 通知MediaProvider，MTP已經連上。
17         context.getContentResolver().insert(Uri.parse(
18                 "content://media/none/mtp_connected"), null);
19     } else {
20         // 結束MtpService服務
21         context.stopService(new Intent(context, MtpService.class));
22         // 通知MediaProvider，MTP已經斷開。
23         context.getContentResolver().delete(Uri.parse(
24                 "content://media/none/mtp_connected"), null, null);
25     }
26 }

說明：

handleUsbState()會先獲取"USB鏈接狀態"，"MTP和PTP的Enable"狀態。

若是USB是連上的，而且MTP或PTP是Enable，則啓動MtpService，並通知MediaProvider。

不然的話，則終止MtpService，並通知MediaProvider。

小結：MtpReceiver會監聽"Android設備開機完成廣播" 和 "USB鏈接/斷開廣播"的處理。到收到廣播時，會根據"USB的鏈接狀態，MTP/PTP的Enable狀態"決定對MTP的處理。若是是連上狀態，並且MTP服務是Enable的，則啓動MtpService服務；而且通知MediaProvider。

2 startService()

在"Android設備與PC連上，而且MTP是Enable"的狀況下，MtpService會被啓動。在"Android設備與PC斷開"時，MtpService會被終止。

MtpService的做用是提供管理MTP的服務。例如，MtpService啓動時，它會遍歷Android設備上全部的存儲設備，若是該存儲設備是掛載的，則建立該存儲設備對應的MtpStorage對象，並將該MtpStorage對象添加到MtpDatabase和MtpServer中。在Android設備中存儲結構發生變化時，會收到MediaProvider發來的消息，進而將消息轉發給MtpServer，進行MTP同步。

下面，經過代碼對MtpService進行介紹。

2.1 建立MtpService

MtpService繼承於Service，這意味着它是一個服務。根據服務的執行流程，MtpService在建立後會執行onCreate()函數。

MtpService中onCreate()的源碼以下：

 1 public class MtpService extends Service {
 2 
 3     @Override
 4     public void onCreate() {
 5         // 監聽「屏幕解鎖」廣播
 6         registerReceiver(mReceiver, new IntentFilter(Intent.ACTION_USER_PRESENT));
 7 
 8         // 獲取StorageManager對象。根據靜態工廠方法獲取的。
 9         mStorageManager = StorageManager.from(this);
10         synchronized (mBinder) {
11             // 根據「屏幕鎖定與否」來啓動/禁用Mtp功能。
12             // 若是是當前用戶在設定了屏幕解鎖密碼的狀況下鎖屏，則禁用Mtp功能。
13             updateDisabledStateLocked();
14             // 監聽「存儲設備的掛載/卸載等廣播事件」。
15             mStorageManager.registerListener(mStorageEventListener);
16             // 遍歷「Android設備」上全部存儲設備。
17             // 若是該存儲設備是「掛載狀態(MEDIA_MOUNTED)」，則經過Mtp鎖定該存儲設備；
18             // 這裏的Mtp鎖定，是指Mtp能識別到該存儲設備，並將該存儲設備映射到PC上。
19             StorageVolume[] volumes = mStorageManager.getVolumeList();
20             mVolumes = volumes;
21             for (int i = 0; i < volumes.length; i++) {
22                 String path = volumes[i].getPath();
23                 String state = mStorageManager.getVolumeState(path);
24                 if (Environment.MEDIA_MOUNTED.equals(state)) {
25                     volumeMountedLocked(path);
26                 }
27             }
28         }
29     }
30 
31     ...
32 }

說明：

(01) 若是當前用戶在設定了"屏幕鎖定密碼"的狀況下將Android設備鎖屏，此時MTP功能是被禁用掉的。

updateDisabledStateLocked()的做用，就是處理這種狀況的。若是"用戶不是當前用戶" 或者 "用戶在設定了'屏幕鎖定密碼'的狀況下將Android設備鎖屏"；此時MTP功能都是被禁用了的。

mReceiver是處理解鎖的廣播。當屏幕鎖解除以後，MTP又能恢復正常工做！

(02) MTP是將Android設備的存儲設備映射到PC上。所以，Android設備上的存儲設備若是被用戶卸載掉的話，要通知PC；而mStorageEventListener就是來監聽"Android設備上的存儲設備的掛載/卸載狀態"的。

2.2 volumeMountedLocked()

volumeMountedLocked()在MtpService.java中實現，源碼以下：

 1 private void volumeMountedLocked(String path) {
 2     // 忽略「U盤」
 3     if(MediaProvider.UDISK_MOUNT_POINT.equals(path))
 4         return;
 5     // 在全部的存儲設備中遍歷，找出該「path對應的存儲設備」，並將它添加到mVolumeMap中。
 6     for (int i = 0; i < mVolumes.length; i++) {
 7         StorageVolume volume = mVolumes[i];
 8         if (volume.getPath().equals(path)) {
 9             long reserveSpace = volume.getMtpReserveSpace() * 1024 * 1024;
10             if(path.equals(MediaProvider.LOCAL_MOUNT_POINT))
11                 volume.setStorageId(0);
12             else if(path.equals(MediaProvider.UDISK_MOUNT_POINT)){
13                 volume.setStorageId(2);
14             }else{
15                 volume.setStorageId(1);
16             }
17             mVolumeMap.put(path, volume);
18             if (!mMtpDisabled) {
19                 if (volume.isPrimary() || !mPtpMode) {
20                     addStorageLocked(volume);
21                 }
22             }
23             break;
24         }
25     }
26 }

說明：

雖然 volumeMountedLocked()調用addStorageLocked()。但此時沒有進行實質性的動做，真正映射的工做是在onStartCommand()中完成的，即在服務啓動以後完成的。

2.3 onStartCommand()

因爲MtpService是"Started Service"類型的服務，而不是"Bound Service"。因此，MtpService啓動以後會執行onStartCommand()。

MtpService.java中onStartCommand()的源碼以下：

 1 public int onStartCommand(Intent intent, int flags, int startId) {
 2     synchronized (mBinder) {
 3         // 根據「屏幕鎖定與否」來啓動/禁用Mtp功能。
 4         // 若是是當前用戶在設定了屏幕解鎖密碼的狀況下鎖屏，則禁用Mtp功能。
 5         updateDisabledStateLocked();
 6         mPtpMode = (intent == null ? false
 7                 : intent.getBooleanExtra(UsbManager.USB_FUNCTION_PTP, false));
 8         String[] subdirs = null;
 9         if (mPtpMode) {
10             // PTP模型才執行到這裏。
11             int count = PTP_DIRECTORIES.length;
12             subdirs = new String[count];
13             for (int i = 0; i < count; i++) {
14                 File file =
15                         Environment.getExternalStoragePublicDirectory(PTP_DIRECTORIES[i]);
16                 // make sure this directory exists
17                 file.mkdirs();
18                 subdirs[i] = file.getPath();
19             }
20         }
21         // 獲取「主存儲分區」。
22         final StorageVolume primary = StorageManager.getPrimaryVolume(mVolumes);
23         // 新建MtpDatabase對象
24         mDatabase = new MtpDatabase(this, MediaProvider.LOCAL_VOLUME,
25             primary.getPath(), subdirs);
26         manageServiceLocked();
27     }
28 
29     return START_STICKY;
30 }

說明：onStartCommand()中建立了mDatabase對象，而後調用manageServiceLocked()。

2.4 manageServiceLocked()

該函數在MtpService.java中實現，源碼以下：

 1 private void manageServiceLocked() {
 2     // 是否是當前用戶
 3     final boolean isCurrentUser = UserHandle.myUserId() == ActivityManager.getCurrentUser();
 4     if (mServer == null && isCurrentUser) {
 5         // 新建mServer對象
 6         mServer = new MtpServer(mDatabase, mPtpMode);
 7         // 若是MTP沒被禁用調，則調用addStorageDevicesLocked()
 8         if (!mMtpDisabled) {
 9             addStorageDevicesLocked();
10         }
11         // 啓動MtpServer
12         mServer.start();
13     } else if (mServer != null && !isCurrentUser) {
14         mServer = null;
15     }
16 }

說明：manageServiceLocked()會新建MtpServer對象，在經過addStorageDevicesLocked()將存儲設備添加到Mtp上以後，再啓動MtpServer。MtpService會啓動一個線程用於管理Android設備和PC之間的通訊，它也會"將經過addStorageDevicesLocked()添加的存儲設備"映射到PC上。

2.5 addStorageDevicesLocked()

該函數在MtpService.java中實現，源碼以下：

 1 private void addStorageDevicesLocked() {
 2     if (mPtpMode) {
 3         final StorageVolume primary = StorageManager.getPrimaryVolume(mVolumes);
 4         final String path = primary.getPath();
 5         if (path != null) {
 6             String state = mStorageManager.getVolumeState(path);
 7             if (Environment.MEDIA_MOUNTED.equals(state)) {
 8                 addStorageLocked(mVolumeMap.get(path));
 9             }
10         }
11     } else {
12         // 若是是MTP模式，則調用addStorageLocked()，mVolumeMap中的存儲設備添加到Mtp中。
13         for (StorageVolume volume : mVolumeMap.values()) {
14             addStorageLocked(volume);
15         }
16     }
17 }

說明：若是是MTP模式，則調用addStorageLocked()，mVolumeMap中的存儲設備添加到Mtp中。mVolumeMap在volumeMountedLocked()中已經被初始化，它保存的是掛載狀態的存儲設備。

2.6 addStorageLocked()

該函數在MtpService.java中實現，源碼以下：

 1 該函數在MtpService.java中實現，源碼以下：
 2 private void addStorageLocked(StorageVolume volume) {
 3     // 忽略 「volume爲空」 或者 「volume是u盤」的狀況
 4     if(volume != null && MediaProvider.UDISK_MOUNT_POINT.equals(volume.getPath()))
 5         return;
 6     // 新建該「存儲設備」對應的MtpStorage，並將該「存儲設備」添加到哈希表mStorageMap中。
 7     MtpStorage storage = new MtpStorage(volume, getApplicationContext());
 8     String path = storage.getPath();
 9     mStorageMap.put(path, storage);
10 
11     // 將storage添加到mDatabase中
12     if (mDatabase != null) {
13         mDatabase.addStorage(storage);
14     }
15     // 將storage添加到mServer中
16     if (mServer != null) {
17         mServer.addStorage(storage);
18     }
19 }

小結：

MtpService服務的主要工做是搜索出Android設備上全部"掛載"的存儲設備，而後根據這些掛載的存儲設備分別建立MtpStorage對象；隨後，將MtpStorage對象添加到MtpDatabase中進行數據轉換和同步，同時也將MtpStorage添加MtpServer，隨後的"Android設備和PC之間的通訊和數據同步等工做"就交由MtpServer主導進行。

3 insert("mtp_connected")

MtpReceiver在handleUsbState()經過insert()將消息上報給MediaProvider。

3.1 MediaProvider靜態註冊塊

MediaProvider在靜態塊中添加了對"mtp_connected"事件的監聽。源碼以下：

1 static
2 {
3     ...
4 
5     URI_MATCHER.addURI("media", "*/mtp_connected", MTP_CONNECTED);
6 
7     ...
8 }

3.2 MediaProvider中的insert()

當MtpReceiver給MediaProvider發出"插入的mtp_connected"消息時，MediaProvider會執行insert()函數。源碼以下：

 1 @Override
 2 public Uri insert(Uri uri, ContentValues initialValues) {
 3     int match = URI_MATCHER.match(uri);
 4 
 5     ArrayList<Long> notifyRowIds = new ArrayList<Long>();
 6     Uri newUri = insertInternal(uri, match, initialValues, notifyRowIds);
 7     notifyMtp(notifyRowIds);
 8 
 9     // we will signal instead after file transfer is successful.
10     if (newUri != null && match != MTP_OBJECTS) {
11         getContext().getContentResolver().notifyChange(uri, null);
12     }
13     return newUri;
14 }

說明：insert()會調用insertInternal()對消息進行處理。

3.3 MediaProvider中的insertInternal()

MediaProvider對插入消息的處理在insertInternal()中執行，它的源碼以下：

 1 private Uri insertInternal(Uri uri, int match, ContentValues initialValues,
 2                            ArrayList<Long> notifyRowIds) {
 3     ...
 4 
 5     switch (match) {
 6         case MTP_CONNECTED:
 7             synchronized (mMtpServiceConnection) {
 8                 if (mMtpService == null) {
 9                     Context context = getContext();
10                     // 將MediaProvider和MtpService綁定。
11                     context.bindService(new Intent(context, MtpService.class),
12                             mMtpServiceConnection, Context.BIND_AUTO_CREATE);
13                 }
14             }
15             break;
16        ...
17    }
18 
19    ...
20 }

說明：insertInternal()會調用bindService()將MediaProvider和MtpService綁定。

4 bindService()

在MediaProvider的insertInternal()中會調用bindService()，而bindService()則會將MediaProvider和MtpService綁定。

而之因此要綁定，是爲了將實現MTP同步。例如，當Android設備上新建一個文件時，最終後同步到MediaProvider數據庫中；而MediaProvider數據庫看同步完成以後，會發送消息給MtpService通知它進行MTP的同步。

小結：MediaProvider在MtpService啓動時和MtpService綁定，在MtpService終止時解除綁定。而綁定的目的是爲了實現MTP同步功能。

5 mDatabase=new MtpDatabase()

在MtpService的onStartCommand()中，會經過new MtpDatabase()建立MtpDatabase對象。

MtpDatabase在MTP中，充當着數據庫的功能。但它自己並無數據庫對數據進行保存，本質上是經過MediaProvider數據庫獲取所須要的數據。例如，當在PC上，須要讀取某個文件時，MtpDatabase會在MediaProvider數據庫中查詢出文件的相關信息(包括文件名、大小、擴展名等)；而後將這些信息交給MtpServer，MtpServer將消息傳遞給JNI，在JNI中會經過文件名打開，而後再文件句柄等信息傳遞給Kernel；Kernel根據文件句柄讀取文件信息，並傳給PC。

下面，經過代碼查看如下MtpDatabase的流程。先看MtpDatabase構造函數，源碼以下：

 1 public class MtpDatabase {
 2 
 3     public MtpDatabase(Context context, String volumeName, String storagePath,
 4             String[] subDirectories) {
 5         // 調用JNI函數
 6         native_setup();
 7 
 8         // 初始化
 9         mContext = context;
10         mPackageName = context.getPackageName();
11         mMediaProvider = context.getContentResolver().acquireProvider("media");
12         mVolumeName = volumeName;
13         mMediaStoragePath = storagePath;
14         mObjectsUri = Files.getMtpObjectsUri(volumeName);
15         mMediaScanner = new MediaScanner(context);
16 
17         mSubDirectories = subDirectories;
18 
19         ...
20 
21         // 初始化設備屬性，將其保存到SharedPreferences中
22         initDeviceProperties(context);
23     }
24 
25     ...
26 }

說明：MtpDatabase的構造函數主要進行的是初始化工做，它首先會調用native_setup()。

5.1 native_setup()

native_setup()在MtpDatabase.java中是一個本地方法。它的相關定義以下：

1 static {
2     System.loadLibrary("media_jni");
3 }
4 private native final void native_setup();

說明：

從中能夠看出native_setup()的實如今libmedia_jni.so中，準確的說是在android_mtp_MtpDatabase.cpp中的註冊。相關的代碼以下：

1 static JNINativeMethod gMtpDatabaseMethods[] = {
2     {"native_setup",            "()V",  (void *)android_mtp_MtpDatabase_setup},
3     {"native_finalize",         "()V",  (void *)android_mtp_MtpDatabase_finalize},
4 };

從中，咱們看出，native_setup()其實是和JNI中的android_mtp_MtpDatabase_setup()對應。android_mtp_MtpDatabase_setup()的源碼以下：

1 static void android_mtp_MtpDatabase_setup(JNIEnv *env, jobject thiz)
2 {
3     // 新建MyMtpDatabase對象database
4     MyMtpDatabase* database = new MyMtpDatabase(env, thiz);
5     // 將database對象保存「field_context」域中。
6     env->SetIntField(thiz, field_context, (int)database);
7     checkAndClearExceptionFromCallback(env, __FUNCTION__);
8 }

說明：

android_mtp_MtpDatabase_setup()會建立一個MyMtpDatabase對象，並將該對象保存"field_context"域中。這個被保存的MyMtpDatabase對象在後面會被用到。

5.2 database=new MyMtpDatabase()

MyMtpDatabase位於"JNI層"，它與"Java層的MtpDatabase"對應。MTP經過調用MyMtpDatabase的接口，給Java層的MtpDatabase發送消息；從而進行相關MTP數據的收集。

小結：MtpDatabase的至關於MTP的數據庫。在MtpDatabase的建立過程當中，它最終會調用JNI本地方法，建立一個MyMtpDatabase對象，並將該對象保存在域field_context中。MTP經過調用保存在field_context域中的MyMtpDatabase對象，從而調用MtpDatabase，進而獲取相關的數據。

6 mServer=new MtpServer()

MtpServer是一個實現Runnable接口，它至關於一個線程；而且在MtpService中被啓動。

MtpServer在MTP的Framework層中，充當着服務器的角色。例如，當MTP服務啓動時，它會通知底層；當Android設備中新增文件時，它會收到MtpService的消息，並將該消息轉發給底層。

MtpServer的構造函數源碼以下：

1 public class MtpServer implements Runnable {
2     public MtpServer(MtpDatabase database, boolean usePtp) {
3         native_setup(database, usePtp);
4     }
5 
6     ...
7 }

說明：MtpServer實現了Runnable接口，在它的構造函數中，它會調用native_setup()本地方法。在MtpServer中，聲明瞭許多native方法，它們的相關代碼以下：

 1 static {
 2     System.loadLibrary("media_jni");
 3 }
 4 private native final void native_setup(MtpDatabase database, boolean usePtp);
 5 private native final void native_run();
 6 private native final void native_cleanup();
 7 private native final void native_send_object_added(int handle);
 8 private native final void native_send_object_removed(int handle);
 9 private native final void native_add_storage(MtpStorage storage);
10 private native final void native_remove_storage(int storageId);

6.1 native_setup()

MtpServer中的native方法在android_mtp_MtpServer.cpp中註冊，註冊表格以下：

 1 static JNINativeMethod gMethods[] = {
 2     {"native_setup",                "(Landroid/mtp/MtpDatabase;Z)V",
 3                                             (void *)android_mtp_MtpServer_setup},
 4     {"native_run",                  "()V",  (void *)android_mtp_MtpServer_run},
 5     {"native_cleanup",              "()V",  (void *)android_mtp_MtpServer_cleanup},
 6     {"native_send_object_added",    "(I)V", (void *)android_mtp_MtpServer_send_object_added},
 7     {"native_send_object_removed",  "(I)V", (void *)android_mtp_MtpServer_send_object_removed},
 8     {"native_add_storage",          "(Landroid/mtp/MtpStorage;)V",
 9                                             (void *)android_mtp_MtpServer_add_storage},
10     {"native_remove_storage",       "(I)V", (void *)android_mtp_MtpServer_remove_storage},
11 };

從中，咱們直到native_setup()其實是與android_mtp_MtpServer_setup()對應。

android_mtp_MtpServer_setup()的源碼以下：

 1 static void android_mtp_MtpServer_setup(JNIEnv *env, jobject thiz, jobject javaDatabase, jboolean usePtp)
 2 {
 3     // 打開文件「/dev/mtp_usb」
 4     int fd = open("/dev/mtp_usb", O_RDWR);
 5     if (fd >= 0) {
 6         // 根據「fd」和「MtpDatabase」建立MtpServer對象server
 7         MtpServer* server = new MtpServer(fd, getMtpDatabase(env, javaDatabase),
 8                 usePtp, AID_MEDIA_RW, 0664, 0775);
 9         // 將server對象保存到「field_MtpServer_nativeContext」域中。
10         env->SetIntField(thiz, field_MtpServer_nativeContext, (int)server);
11     } else {
12         ALOGE("could not open MTP driver, errno: %d", errno);
13     }
14 }

說明：

(01) fd是文件"/dev/mtp_usb"的句柄。實際上，MTP是經過"/dev/mtp_usb"去監聽PC的請求和向PC發送數據的。

(02) getMtpDatabase(env, javaDatabase)返回的是MtpDatabase對象。

(03) 根據fd和getMtpDatabase()返回的MtpDatabase對象，建立server對象；而後經過SetIntFiel()將server對象保存到field_MtpServer_nativeContext這個域中。

6.2 fd = open("/dev/mtp_usb")

android_mtp_MtpServer_setup()會打開"/dev/mtp_usb"文件。在MTP中，MtpServer會不斷的從"/dev/mtp_usb"去讀取數據來監聽PC的請求；同時，數據反饋和其餘事件也是經過"/dev/mtp_usb"去反饋給Kernel的。

6.3 getMtpDatabase()

該函數在android_mtp_MtpDatabase.cpp中實現，源碼以下：

1 MtpDatabase* getMtpDatabase(JNIEnv *env, jobject database) {
2     return (MtpDatabase *)env->GetIntField(database, field_context);
3 }

說明：field_context在前面介紹的"android_mtp_MtpDatabase_setup()"中被初始化。因此，這裏實際上返回的是MyMtpDatabase對象。

6.4 new MtpServer(fd, ...)

MtpServer的構造函數在MtpServer.cpp中實現，源碼以下：

MtpServer::MtpServer(int fd, MtpDatabase* database, bool ptp,
                    int fileGroup, int filePerm, int directoryPerm)
    :   mFD(fd),
        mDatabase(database),
        mPtp(ptp),
        mFileGroup(fileGroup),
        mFilePermission(filePerm),
        mDirectoryPermission(directoryPerm),
        mSessionID(0),
        mSessionOpen(false),
        mSendObjectHandle(kInvalidObjectHandle),
        mSendObjectFormat(0),
        mSendObjectFileSize(0) {}

說明：

其中比較重要的兩則信息：(01) mFD是"/dev/mtp_usb"的文件句柄。 (02) mDatabase是上一步getMtpDatabase()返回的MtpDatabase對象。

7 storage = new MtpStorage()

一個MtpStorage對象表明一個MTP存儲單元。當Android設備和PC連上時，可能有幾個存儲單元：例如，內部存儲分區，SD卡分區等。

MtpStorage的構造函數以下：

 1 public class MtpStorage {
 2     private final int mStorageId;
 3     private final String mPath;
 4     private final String mDescription;
 5     private final long mReserveSpace;
 6     private final boolean mRemovable;
 7     private final long mMaxFileSize;
 8 
 9     public MtpStorage(StorageVolume volume, Context context) {
10         // 存儲設備ID
11         mStorageId = volume.getStorageId();
12         // 對應「Android設備」上的存儲路徑
13         mPath = volume.getPath();
14         // 描述
15         mDescription = context.getResources().getString(volume.getDescriptionId());
16         // (對MTP而言)可用空間
17         mReserveSpace = volume.getMtpReserveSpace() * 1024L * 1024L;
18         // 是否可移除
19         mRemovable = volume.isRemovable();
20         // 最大文件大小。(0表示無限制)
21         mMaxFileSize = volume.getMaxFileSize();
22     }
23 
24     ...
25 }

8 mDatabase.addStorage(storage)

MtpDatabase.java中addStorage()的源碼以下：

public void addStorage(MtpStorage storage) {
    mStorageMap.put(storage.getPath(), storage);
}
public void removeStorage(MtpStorage storage) {
    mStorageMap.remove(storage.getPath());
}

說明：mStorageMap是個HashMap對象。此處，addStorage()的做用就是將"存儲設備的信息保存到哈希表中"。當該存儲設備被卸載時，會調用MtpDatabase.java的removeStorage()，進而從mStorageMap中刪除相應的存儲設備。

9 mServer.addStorage(storage)

mServer.addStorage(storage) 會對應執行MtpServer.java中的addStorage()函數。源碼以下：

1 public void addStorage(MtpStorage storage) {
2     native_add_storage(storage);
3 }

根據前面介紹的gMethods表格，咱們知道native_add_storage()其實是調用的android_mtp_MtpServer_add_storage()。

9.1 android_mtp_MtpServer_add_storage()

 1 static void android_mtp_MtpServer_add_storage(JNIEnv *env, jobject thiz, jobject jstorage)
 2 {
 3     Mutex::Autolock autoLock(sMutex);
 4 
 5     // 獲取MtpServer對象
 6     MtpServer* server = getMtpServer(env, thiz);
 7     if (server) {
 8         // field_MtpStorage_storageId 和 「MtpStorage.java中的mStorageId」 對應
 9         jint storageID = env->GetIntField(jstorage, field_MtpStorage_storageId);
10         // field_MtpStorage_path 和 「MtpStorage.java中的mPath」 對應
11         jstring path = (jstring)env->GetObjectField(jstorage, field_MtpStorage_path);
12         // field_MtpStorage_description 和 「MtpStorage.java中的mDescription」 對應
13         jstring description = (jstring)env->GetObjectField(jstorage, field_MtpStorage_description);
14         // field_MtpStorage_reserveSpace 和 「MtpStorage.java中的mReserveSpace」 對應
15         jlong reserveSpace = env->GetLongField(jstorage, field_MtpStorage_reserveSpace);
16         // field_MtpStorage_removable 和 「MtpStorage.java中的mRemovable」 對應
17         jboolean removable = env->GetBooleanField(jstorage, field_MtpStorage_removable);
18         // field_MtpStorage_maxFileSize 和 「MtpStorage.java中的mMaxFileSize」 對應
19         jlong maxFileSize = env->GetLongField(jstorage, field_MtpStorage_maxFileSize);
20 
21         // 將「jstring類型的path」轉換爲「C語言中的char *類型」
22         const char *pathStr = env->GetStringUTFChars(path, NULL);
23         if (pathStr != NULL) {
24             // 獲取「存儲設備」的描述字符串
25             const char *descriptionStr = env->GetStringUTFChars(description, NULL);
26             if (descriptionStr != NULL) {
27                 // 建立(MtpStorage.cpp)MtpStorage對象
28                 MtpStorage* storage = new MtpStorage(storageID, pathStr, descriptionStr,
29                         reserveSpace, removable, maxFileSize);
30                 // 將該MtpStorage對象，添加到MtpServer中
31                 server->addStorage(storage);
32                 env->ReleaseStringUTFChars(path, pathStr);
33                 env->ReleaseStringUTFChars(description, descriptionStr);
34             } else {
35                 env->ReleaseStringUTFChars(path, pathStr);
36             }
37         }
38     } else {
39         ALOGE("server is null in add_storage");
40     }
41 }

說明：

(01) getMtpServer()返回的是MtpServer對象。

(02) 經過GetIntField(), GetObjectField()等一系列操做，將相關的域分別和MtpStorage.java中的域對應起來。

(03) 建立MtpStorage對象。

(04) 經過addStorage()將MtpStorage對象，添加到MtpServer中。

9.2 server=getMtpServer()

getMtpServer()在android_mtp_MtpServer.cpp中實現，源碼以下：

1 static inline MtpServer* getMtpServer(JNIEnv *env, jobject thiz) {
2     return (MtpServer*)env->GetIntField(thiz, field_MtpServer_nativeContext);
3 }

說明：getMtpServer()返回的是MtpServer對象。該對象，咱們在前面介紹的"android_mtp_MtpServer_setup()"的初始化的。

9.3 storage=new MtpStorage()

在android_mtp_MtpServer_add_storage()中，咱們經過GetIntField(),GetObjectField(), GetLongField()等方法獲取"JNI中的域"對應的"MtpStoarge.java中的類成員"。下面以field_MtpStorage_storageId爲例，簡單說說"JNI中的域"是如何與"MtpStorage.java中的mStorageId"關聯的。

首先，field_MtpStorage_storageId的值是在register_android_mtp_MtpServer()中初始化的。源碼以下：

 1 int register_android_mtp_MtpServer(JNIEnv *env)
 2 {
 3     jclass clazz;
 4 
 5     // 找到java中「android.mtp.MtpStorage.java」包
 6     clazz = env->FindClass("android/mtp/MtpStorage");
 7     ...
 8 
 9     // 獲取「MtpStorage.java中mStorageId」的fieldId，並保存到field_MtpStorage_storageId中
10     field_MtpStorage_storageId = env->GetFieldID(clazz, "mStorageId", "I");
11     if (field_MtpStorage_storageId == NULL) {
12         ALOGE("Can't find MtpStorage.mStorageId");
13         return -1;
14     }
15 
16     ..
17 }

register_android_mtp_MtpServer()又是什麼時候被調用的呢？

它是在android_media_MediaPlayer.cpp的JNI_OnLoad()中被調用的，而JNI_OnLoad是咱們調用JNI對應的庫時被JNI自動調用執行的。

 1 jint JNI_OnLoad(JavaVM* vm, void* reserved)
 2 {
 3     ...
 4 
 5     if (register_android_mtp_MtpServer(env) < 0) {
 6         ALOGE("ERROR: MtpServer native registration failed");
 7         goto bail;
 8     }
 9 
10     ...
11 }

因爲在register_android_mtp_MtpServer()中，"MtpStorage.java中mStorageId"的已經保存field_MtpStorage_storageId中；

在android_mtp_MtpServer_add_storage()中，咱們就能夠經過env->GetIntField(jstorage, field_MtpStorage_storageId)來獲取"MtpStorage.java中mStorageId"。

下面，咱們看看MtpStorage.h(JNI層)中的成員以下：

 1 class MtpStorage {
 2 
 3 private:
 4     MtpStorageID            mStorageID;
 5     MtpString               mFilePath;
 6     MtpString               mDescription;
 7     uint64_t                mMaxCapacity;
 8     uint64_t                mMaxFileSize;
 9     uint64_t                mReserveSpace;
10     bool                    mRemovable;
11 
12     ...
13 }

將MtpStroage.h(JNI層)中的成員和"前面介紹的MtpStroage.java的成員"進行對比，它們很是類似。實際上，MTP就是經過MtpStorage.cpp來獲取MtpStorage.java的相關信息的。

9.4 server->addStorage(storage)

MtpServer.cpp中addStorage()的源碼以下：

1 void MtpServer::addStorage(MtpStorage* storage) {
2     // 獲取「信號量」
3     Mutex::Autolock autoLock(mMutex);
4 
5     // mStorages是「MtpStorage的Vector容量對象」，至關於「MtpStorage的動態數組」。
6     mStorages.push(storage);
7     // 調用sendStoreAdded()通知PC，讓PC經過MTP掛載該存儲設備
8     sendStoreAdded(storage->getStorageID());
9 }

說明：addStorage()的做用，就是將"輸入參數storage"添加到"mStorages動態數組"中進行管理；而後，調用sendStoreAdded()告訴PC掛載該設備。下面看看sendStoreAdded()是如何處理的。

9.5 sendStoreAdded()

MtpServer.cpp中sendStoreAdded()的源碼以下：

1 void MtpServer::sendStoreAdded(MtpStorageID id) {
2     sendEvent(MTP_EVENT_STORE_ADDED, id);
3 }

說明：

MTP_EVENT_STORE_ADDED是"MtpEventCode類型"的數組中的成員，而MtpEventCode是uint16_t類型。因此，MTP_EVENT_STORE_ADDED是一個"16位的無符號整型數"，它表明的是一個MTP事件指令ID。

9.6 sendEvent()

MtpServer.cpp中sendEvent()的源碼以下：

1 void MtpServer::sendEvent(MtpEventCode code, uint32_t param1) {
2     if (mSessionOpen) {
3         mEvent.setEventCode(code);
4         mEvent.setTransactionID(mRequest.getTransactionID());
5         mEvent.setParameter(1, param1);
6         int ret = mEvent.write(mFD);
7         ALOGV("mEvent.write returned %d\n", ret);
8     }
9 }

說明：

(01) mSessionOpen是"MTP會話是否打開的標記"。當PC和Android設備連上以後，PC會發送"打開會話指令"給Android設備從而開打會話；到PC和Android設備斷開時，會話才結束。在打開會話時，會設置mSessionOpen爲true。這也意味着，此時的mSessionOpen已經爲true。

(02) mEvent是MtpEventPacket對象。而MtpEventPacket繼承於MtpPacket，MtpEventPacket聲明以下：

class MtpEventPacket : public MtpPacket {}

9.7 mEvent.write()

sendEvent()在執行mEvent.write()以前，會初始化mEvent對象。

9.7.1 setEventCode()

setEventCode()在MtpEventPacket.h中實現，源碼以下：

inline void setEventCode(MtpEventCode code) { return setContainerCode(code); }

setContainerCode()在MtpPacket.cpp中實現，源碼以下：

void MtpPacket::setContainerCode(uint16_t code) {
    putUInt16(MTP_CONTAINER_CODE_OFFSET, code);
}

putUInt16()在MtpPacket.cpp中實現，源碼以下：

void MtpPacket::putUInt16(int offset, uint16_t value) {
    mBuffer[offset++] = (uint8_t)(value & 0xFF);
    mBuffer[offset++] = (uint8_t)((value >> 8) & 0xFF);
}

說明：

putUInt16()是"將16位的無符號整型數寫入到緩衝中"。其中，mBuffer是"數據緩衝"。

綜上所述，setEventCode(code)的做用就是將"消息的編碼寫入到緩衝"，等其餘數據寫入緩衝以後，再一塊兒發送給PC。對於"添加存儲設備而言"，Android設備發給PC的消息的編碼就是MTP_EVENT_STORE_ADDED。

9.7.2 setTransactionID()

setTransactionID()在MtpPacket.cpp中實現，源碼以下：

void MtpPacket::setTransactionID(MtpTransactionID id) {
    putUInt32(MTP_CONTAINER_TRANSACTION_ID_OFFSET, id);
}

putUInt32()在MtpPacket.cpp中實現，源碼以下：

void MtpPacket::putUInt32(int offset, uint32_t value) {
    mBuffer[offset++] = (uint8_t)(value & 0xFF);
    mBuffer[offset++] = (uint8_t)((value >> 8) & 0xFF);
    mBuffer[offset++] = (uint8_t)((value >> 16) & 0xFF);
    mBuffer[offset++] = (uint8_t)((value >> 24) & 0xFF);
}

說明：

putUInt32()和putUInt16()做用相似，putUInt32()的做用是"將32位的無符號整型數寫入到緩衝中"。其中，mBuffer是"數據緩衝"。

綜上所述，setTransactionID()就是將"TransactionID寫入到緩衝"。

9.7.3 setParameter()

setParameter()在MtpPacket.cpp中實現，源碼以下：

 1 void MtpPacket::setParameter(int index, uint32_t value) {
 2     if (index < 1 || index > 5) {
 3         ALOGE("index %d out of range in MtpPacket::setParameter", index);
 4         return;
 5     }
 6     int offset = MTP_CONTAINER_PARAMETER_OFFSET + (index - 1) * sizeof(uint32_t);
 7     if (mPacketSize < offset + sizeof(uint32_t))
 8         mPacketSize = offset + sizeof(uint32_t);
 9     putUInt32(offset, value);
10 }

說明： setParameter()的做用是"將StorageID寫入緩衝"，從而告訴PC操做哪一個"存儲設備"。

9.7.4 write()

write()在MtpEventPacket.cpp中實現，源碼以下：

 1 int MtpEventPacket::write(int fd) {
 2     struct mtp_event    event;
 3 
 4     putUInt32(MTP_CONTAINER_LENGTH_OFFSET, mPacketSize);
 5     putUInt16(MTP_CONTAINER_TYPE_OFFSET, MTP_CONTAINER_TYPE_EVENT);
 6 
 7     // 將「緩衝」賦值給event.data
 8     event.data = mBuffer;
 9     event.length = mPacketSize;
10     // 經過「ioctl事件」將該消息發送給驅動，驅動再負責和PC通訊。
11     int ret = ::ioctl(fd, MTP_SEND_EVENT, (unsigned long)&event);
12     return (ret < 0 ? ret : 0);
13 }

說明：

write()的做用，就是將打包好的消息發送給PC。write()的做用是將消息傳遞給Kernel，真正傳遞給PC是在Kernel的驅動中進行處理的。感興趣的能夠看看下面Kernel的write()介紹部分。

下面簡單介紹下Kernel中write()是如何實現的。經過前面介紹的MTP架構圖，咱們知道：

(01) PC和Android設備是經過USB協議來進行MTP通訊的。

注意：MTP協議除了USB以外，還能夠經過BT等協議進行通訊；這裏只對USB進行說明。

(02) PC給Android設備發送消息時，PC會經過USB傳輸數據給內核。MTP驅動再從USB中讀取出"PC傳過來的消息"，而後寫入到"/dev/mtp_usb"文件節點上。"/dev/mtp_usb"是MTP驅動對應的節點，在Linux中，一切都是文件；用戶經過操做"/dev/mtp_usb"節點，就能讀取出"PC發過來的消息"。

(03) Android設備給PC發送消息時，會向將信息寫入到"/dev/mtp_usb"文件中。MTP驅動從"/dev/mtp_usb"中讀取數據以後，再經過USB傳給送PC。

一. MTP驅動註冊

MTP驅動文件是drivers/usb/gadget/f_mtp.c。它經過下面的代碼會映射到文件節點"/dev/mtp_usb"中。

 1 static const char mtp_shortname[] = "mtp_usb";
 2 
 3 static const struct file_operations mtp_fops = {
 4     .owner = THIS_MODULE,
 5     .read = mtp_read,
 6     .write = mtp_write,
 7     .unlocked_ioctl = mtp_ioctl,
 8     .open = mtp_open,
 9     .release = mtp_release,
10 }; 
11 
12 static struct miscdevice mtp_device = {
13     .minor = MISC_DYNAMIC_MINOR,
14     .name = mtp_shortname,
15     .fops = &mtp_fops,
16 };  
17 
18 static int mtp_setup(void)
19 {
20     ...
21 
22     ret = misc_register(&mtp_device);
23 
24     ...
25 }

說明：

(01) misc_register(&mtp_device)會將MTP註冊到虛擬文件系統"/dev"中，而對應的註冊的文件節點的名稱是"mtp_usb"，即完成的節點是"/dev/mtp_usb"。

(02) 用戶空間操做節點"/dev/mtp_usb"就是調用MTP驅動中file_operations中的相關函數。

例如，用戶空間經過read()去讀取"/dev/mtp_usb"，實際上調用內核空間的是mtp_read()；用戶空間經過write()去寫"/dev/mtp_usb"，實際上調用內核空間的是mtp_write()。

二. mtp_read()

該函數在f_mtp.c中實現，源碼以下：

 1 static ssize_t mtp_read(struct file *fp, char __user *buf,
 2     size_t count, loff_t *pos)
 3 {
 4     // 從「USB」消息隊列中中讀取PC發給Android設備的請求，請求消息保存在req中。
 5     ret = usb_ep_queue(dev->ep_out, req, GFP_KERNEL);
 6     ...
 7 
 8     // 等待cpu將工做隊列(read_wq)上已有的消息處理完畢
 9     ret = wait_event_interruptible(dev->read_wq, dev->rx_done);
10     ...
11 
12     // 將「PC的請求數據(req->)」從「內核空間」拷貝到「用戶空間」
13     if (copy_to_user(buf, req->buf, xfer))
14         r = -EFAULT;
15 
16     ...
17 }

說明：mtp_read()會經過USB讀取"PC發給Android設備的請求"，獲取到請求後，會經過copy_to_user()會將數據從"內核空間"拷貝到"用戶空間"，這樣用戶就能在用戶空間讀取到該數據。

三. mtp_write()

 1 static ssize_t mtp_write(struct file *fp, const char __user *buf,
 2     size_t count, loff_t *pos)
 3 {
 4 
 5     while (count > 0 || sendZLP) {
 6 
 7         // 將「用戶空間」傳來的消息(buf)拷貝到「內核空間」的req->buf中。
 8         if (xfer && copy_from_user(req->buf, buf, xfer)) 
 9         ...
10 
11         // 將打包好的消息req放到USB消息隊列中。
12         ret = usb_ep_queue(dev->ep_in, req, GFP_KERNEL);
13         ...
14     }
15 
16     ...
17 }

說明：mtp_write()會將"用戶空間"發來的消息拷貝到"內核空間"，並將該消息打包；而後，將打包好的消息添加到USB消息隊列中。USB驅動負責將消息隊列中的消息傳遞給PC。

10 mServer.start()

MtpServer其實是一個Runnable線程接口。在"MtpReceiver的handleUsbState()"中，初始化MtpServer以後，會啓動MtpServer。

MtpServer中的run()方法以下：

@Override
public void run() {
    native_run();
    native_cleanup();
}

從中，咱們發現run()其實是調用的本地方法native_run()。

10.1 native_run()

根據前面的gMethods表格，咱們知道native_run()對應JNI層的android_mtp_MtpServer_run()方法，它的源碼以下：

 1 static void android_mtp_MtpServer_run(JNIEnv *env, jobject thiz)
 2 {
 3     // 返回MtpServer對象
 4     MtpServer* server = getMtpServer(env, thiz);
 5     // 若是server不爲NULL，則調用它的run()方法。
 6     if (server)
 7         server->run();
 8     else
 9         ALOGE("server is null in run");
10 }

說明：

(01) getMtpServer()返回的是MtpServer對象。這個前面已經介紹過！

(02) 調用MtpServer對象的run()方法。

10.2 run()

 1 void MtpServer::run() {
 2     // 將mFD賦值給fd，fd就是「/dev/mtp_usb」的句柄
 3     int fd = mFD;
 4 
 5     while (1) {
 6         // 讀取「/dev/mtp_usb」
 7         int ret = mRequest.read(fd);
 8 
 9         ...
10         // 獲取「MTP操做碼」
11         MtpOperationCode operation = mRequest.getOperationCode();
12         MtpTransactionID transaction = mRequest.getTransactionID();
13 
14         ...
15 
16         // 在handleRequest()中，根據讀取的指令做出相應的處理
17         if (handleRequest()) {
18             ...
19         }
20     }
21 
22     ...
23 }

說明：

run()會不斷的從"/dev/mtp_usb"中讀取數據。若是是有效的指令，則在handleRequest()做出相應的處理。

(01) mRequest是MtpRequestPacket對象，MtpRequestPacket是解析"PC請求指令"的類。

(02) handleRequest()是具體處理"MTP各個指令的類"。例如，PC獲取Android設備的設備信息指令，是在handleRequest()中處理的。

10.3 while(1){...}

在run()中，會經過while(1)循環不斷的"執行read()，從"/dev/mtp_usb中讀取數據"；而後調用handleRequest()對數據進行處理"。

read()函數最終會調用到Kernel的mtp_read()，mtp_read()已經在前面介紹過了。

handleRequest()則是對讀取出來的消息進行處理，它的源碼以下：

 1 bool MtpServer::handleRequest() {
 2     Mutex::Autolock autoLock(mMutex);
 3 
 4     MtpOperationCode operation = mRequest.getOperationCode();
 5     MtpResponseCode response;
 6 
 7     mResponse.reset();
 8 
 9     if (mSendObjectHandle != kInvalidObjectHandle && operation != MTP_OPERATION_SEND_OBJECT) {
10         mSendObjectHandle = kInvalidObjectHandle;
11     }
12 
13     switch (operation) {
14         case MTP_OPERATION_GET_DEVICE_INFO:
15             response = doGetDeviceInfo();
16             break;
17         case MTP_OPERATION_OPEN_SESSION:
18             response = doOpenSession();
19             break;
20         case MTP_OPERATION_CLOSE_SESSION:
21             response = doCloseSession();
22             break;
23         ...
24         case MTP_OPERATION_GET_OBJECT:
25             response = doGetObject();
26             break;
27         case MTP_OPERATION_SEND_OBJECT:
28             response = doSendObject();
29             break;
30         ...
31     }
32 
33     if (response == MTP_RESPONSE_TRANSACTION_CANCELLED)
34         return false;
35     mResponse.setResponseCode(response);
36     return true;
37 }

總結：在"PC和Android設備"鏈接後，MtpReceiver會收到廣播。接着MtpReceiver會啓動MtpService，MtpService會啓動MtpServer(Java層)。MtpServer(Java)層會調用底層的JNI函數。在JNI中，會打開MTP文件節點"/dev/mtp_usb"，而後MtpServer(JNI層)會不斷的從中讀取消息並進行處理。

第4部分 MTP協議之I->R流程

下面以"PC中打開一個MTP上的文件(讀取文件內容)"來對"MTP協議中Initiator到Reponser的流程"進行說明。PC讀取文件內容的時序圖如圖4-01所示：

圖4-01

1 read()

根據MTP啓動流程中分析可知： MTP啓動後，MtpServer.cpp中的MtpServer::run()會經過read()不斷地從"/dev/mtp_usb"中讀取出"PC發來的消息"。

2 handleRequest()

read()在讀取到PC來的消息以後，會交給MtpServer::handleRequest()進行處理。"PC讀取文件內容"的消息的ID是MTP_OPERATION_GET_OBJECT；所以，它會經過doGetObject()進行處理。

3. doGetObject()

MtpServer.cpp中doGetObject()的源碼以下：

 1 MtpResponseCode MtpServer::doGetObject() {
 2     ...
 3     
 4     // 根據handle獲取文件的路徑(pathBuf)、大小(fileLength)和「格式」。
 5     int result = mDatabase->getObjectFilePath(handle, pathBuf, fileLength, format);
 6     if (result != MTP_RESPONSE_OK)
 7         return result;
 8 
 9     // 將文件路徑轉換爲const char*類型。
10     const char* filePath = (const char *)pathBuf;
11     // 將文件的信息傳遞給mfr，mfr是kernel的一個結構體；最終將mfr傳遞給kernel。
12     mtp_file_range  mfr;
13     mfr.fd = open(filePath, O_RDONLY);                 // 設置「文件句柄」。
14     if (mfr.fd < 0) {
15         return MTP_RESPONSE_GENERAL_ERROR;
16     }
17     mfr.offset = 0;                                    // 設置「文件偏移」
18     mfr.length = fileLength;
19     mfr.command = mRequest.getOperationCode();         // 設置「command」
20     mfr.transaction_id = mRequest.getTransactionID();  // 設置「transaction ID」
21 
22     // 經過ioctl將文件傳給kernel。
23     int ret = ioctl(mFD, MTP_SEND_FILE_WITH_HEADER, (unsigned long)&mfr);
24     // 關閉文件
25     close(mfr.fd);
26 
27     ...
28 }

說明：

doGetDeviceInfo的流程就是，先經過JNI回調Java中的函數，(根據文件句柄)從MediaProvider數據庫中獲取文件的路徑、大小和格式等信息。接着，將這些信息封裝到kernel的"mtp_file_range結構體"中。最後，經過ioctl將"mtp_file_range結構體"傳遞給kernel。這樣，kernel就收到文件的相關信息了，kernel負責將文件信息經過USB協議傳遞給PC。

4 getObjectFilePath()

doGetObject()會調用的getObjectFilePath()。該函數在android_mtp_MtpDatabase.cpp中實現。

 1 MtpResponseCode MyMtpDatabase::getObjectFilePath(MtpObjectHandle handle,
 2                                             MtpString& outFilePath,
 3                                             int64_t& outFileLength,
 4                                             MtpObjectFormat& outFormat) {
 5     ...
 6 
 7     // 調用MtpDatabase.java中的getObjectFilePath()。
 8     // 做用是根據文件句柄，獲取「文件路徑」、「文件大小」、「文件格式」
 9     jint result = env->CallIntMethod(mDatabase, method_getObjectFilePath,
10                 (jint)handle, mStringBuffer, mLongBuffer);
11 
12     // 設置「文件路徑」
13     jchar* str = env->GetCharArrayElements(mStringBuffer, 0);
14     outFilePath.setTo(str, strlen16(str));
15     env->ReleaseCharArrayElements(mStringBuffer, str, 0);
16 
17     // 設置「文件大小」和「文件格式」
18     jlong* longValues = env->GetLongArrayElements(mLongBuffer, 0);
19     outFileLength = longValues[0];
20     outFormat = longValues[1];
21     env->ReleaseLongArrayElements(mLongBuffer, longValues, 0);
22 
23 
24     ...
25 }

說明：

MyMtpDatabase::getObjectFilePath()實際上經過MtpDatabase.java中的getObjectFilePath()來獲取文件的相關信息的。

5 getObjectFilePath()

MtpDatabase.java中getObjectFilePath()的源碼以下：

 1 private int getObjectFilePath(int handle, char[] outFilePath, long[] outFileLengthFormat) {
 2     ...
 3 
 4     // 在MediaProvider中查找文件對應的路徑。
 5     // mObjectsUri是根據文件handle獲取到的URI。
 6     c = mMediaProvider.query(mPackageName, mObjectsUri, PATH_FORMAT_PROJECTION,
 7                     ID_WHERE, new String[] {  Integer.toString(handle) }, null, null);
 8     if (c != null && c.moveToNext()) {
 9         // 獲取「文件路徑」
10         String path = c.getString(1);
11         path.getChars(0, path.length(), outFilePath, 0);
12         outFilePath[path.length()] = 0;
13         // 獲取「文件大小」
14         outFileLengthFormat[0] = new File(path).length();
15         // 獲取「文件格式」
16         outFileLengthFormat[1] = c.getLong(2);
17         return MtpConstants.RESPONSE_OK;
18     } else {
19         return MtpConstants.RESPONSE_INVALID_OBJECT_HANDLE;
20     }
21 
22     ...
23 }

說明：getObjectFilePath()會從MediaProvider的數據庫中查找相應的文件，從而獲取文件信息。而後，將文件的信息回傳給JNI。

6 ioctl

MtpServer.cpp中doGetObject()中獲取到文件信息以後，會經過ioctl將MTP_SEND_FILE_WITH_HEADER消息傳遞給Kernel。

根據前面介紹的Kernel內容克制，ioctl在file_operations中註冊，ioctl實際上會執行mtp_ioctl()函數。它的源碼以下：

 1 static long mtp_ioctl(struct file *fp, unsigned code, unsigned long value)
 2 {
 3     ...
 4 
 5     switch (code) {
 6     case MTP_SEND_FILE:
 7     case MTP_RECEIVE_FILE:
 8     case MTP_SEND_FILE_WITH_HEADER:
 9     {
10         struct mtp_file_range    mfr;
11         struct work_struct *work;
12 
13         // 將「用戶空間」傳來的值(value)拷貝到「內核空間」的mfr中。
14         if (copy_from_user(&mfr, (void __user *)value, sizeof(mfr))) {
15             ret = -EFAULT;
16             goto fail;
17         }
18         // 獲取文件句柄
19         filp = fget(mfr.fd);
20         if (!filp) {
21             ret = -EBADF;
22             goto fail;
23         }
24 
25         // 將「文件相關的信息」賦值給dev。
26         dev->xfer_file = filp;
27         dev->xfer_file_offset = mfr.offset;
28         dev->xfer_file_length = mfr.length;
29         smp_wmb();
30 
31         if (code == MTP_SEND_FILE_WITH_HEADER) {
32             // 設置work的值
33             work = &dev->send_file_work;
34             dev->xfer_send_header = 1;
35             dev->xfer_command = mfr.command;
36             dev->xfer_transaction_id = mfr.transaction_id;
37         } 
38         ...
39 
40         // 將work添加到工做隊列(dev->wq)中。
41         queue_work(dev->wq, work);
42         // 對工做隊列執行flush操做。
43         flush_workqueue(dev->wq);
44 
45         break;
46     }
47 
48     ...
49 }

說明：mtp_ioctl()在收到MTP_SEND_FILE_WITH_HEADER消息以後，會獲取文件相關信息。而後將"work"添加到工做隊列dev->wq中進行調度。work對應的函數指針是send_file_work()函數；這就意味着，工做隊列會制定send_file_work()函數。

send_file_work()的源碼以下：

 1 static void send_file_work(struct work_struct *data)
 2 {
 3     // 獲取dev結構體
 4     struct mtp_dev *dev = container_of(data, struct mtp_dev,
 5                         send_file_work);
 6     ...
 7 
 8     // 讀取文件消息
 9     smp_rmb();
10     filp = dev->xfer_file;
11     offset = dev->xfer_file_offset;
12     count = dev->xfer_file_length;
13 
14 
15     while (count > 0 || sendZLP) {
16 
17         ...
18 
19         // 從文件中讀取數據到內存中。
20         ret = vfs_read(filp, req->buf + hdr_size, xfer - hdr_size,
21                                 &offset);
22 
23         ...
24 
25         // 將req添加到usb終端的隊列中
26         ret = usb_ep_queue(dev->ep_in, req, GFP_KERNEL);
27 
28         ...
29     }
30 
31     ...
32 }

說明：send_file_work()的做用就是不斷地將文件中的數據讀取到內存中，並封裝到USB請求結構體req中。而後，再將數據req傳遞到USB工做隊列，USB賦值將文件內容傳遞給PC。

至此，PC讀取文件內容的流程分析完畢！

第5部分 MTP協議之R->I流程

下面以"Android設備中將一個文件拷貝到其餘目錄"來對"MTP協議中Reponser到Initiator的流程"進行說明。對應的時序圖如圖5-01所示：

圖5-01

1 MediaProvider.java中sendObjectAdded()

在Android設備上將一個文件拷貝到其餘目錄。文件瀏覽器中會發出一個Intent事件，通知MediaProvider更新數據庫。MediaProvider更新了數據庫以後，會通知MTP進行同步處理。MediaProvider通知MTP的源碼以下：

 1 private void sendObjectAdded(long objectHandle) {
 2     synchronized (mMtpServiceConnection) {
 3         if (mMtpService != null) {
 4             try {
 5                 mMtpService.sendObjectAdded((int)objectHandle);
 6             } catch (RemoteException e) {
 7                 Log.e(TAG, "RemoteException in sendObjectAdded", e);
 8                 mMtpService = null;
 9             }
10         }
11     }
12 }

說明：該函數會通知MtpService，Android設備中新建了個文件。

2 MtpService.java中sendObjectAdded()

MtpService.java中sendObjectAdded()的源碼以下：

1 MtpService.java中sendObjectAdded()的源碼以下：
2 public void sendObjectAdded(int objectHandle) {
3     synchronized (mBinder) {
4         if (mServer != null) {
5             mServer.sendObjectAdded(objectHandle);
6         }
7     }
8 }

說明：該函數會發送消息給mServer，而mServer是MtpServer對象。

3 MtpServer.java中的sendObjectAdded

1 public void sendObjectAdded(int handle) {
2     native_send_object_added(handle);
3 }

說明：該函數會調研JNI本地方法。

4 native_send_object_added()

native_send_object_added()在android_mtp_MtpServer.cpp中實現。根據前面介紹相關內容可知，native_send_object_added()和android_mtp_MtpServer_send_object_added()對應。後者的源碼以下：

 1 static void android_mtp_MtpServer_send_object_added(JNIEnv *env, jobject thiz, jint handle)
 2 {
 3     Mutex::Autolock autoLock(sMutex);
 4 
 5     // 獲取MtpServer，而後調用MtpServer的sendObjectAdded()方法。
 6     MtpServer* server = getMtpServer(env, thiz);
 7     if (server)
 8         server->sendObjectAdded(handle);
 9     else
10         ALOGE("server is null in send_object_added");
11 }

說明：該函數會將消息發送給MtpServer。

5 MtpServer.cpp中的sendObjectAdded

MtpServer.cpp中sendObjectAdded()的源碼以下：

1 void MtpServer::sendObjectAdded(MtpObjectHandle handle) {
2     sendEvent(MTP_EVENT_OBJECT_ADDED, handle);
3 }

說明：sendEvent()的做用，咱們前面已經介紹過了。它在此處的目的，就是經過ioctl將消息發送給Kernel。

6 Kernel中的ioctl

在Kernel中，ioctl消息會調用mtp_ioctl()進行處理。它的源碼以下：

 1 static long mtp_ioctl(struct file *fp, unsigned code, unsigned long value)
 2 {
 3     ...
 4 
 5     case MTP_SEND_EVENT:
 6     {
 7         struct mtp_event    event;
 8         // 將「用戶空間」傳來的值(value)拷貝到「內核空間」的event中。
 9         if (copy_from_user(&event, (void __user *)value, sizeof(event)))
10             ret = -EFAULT;
11         else
12             ret = mtp_send_event(dev, &event);
13 
14         ...
15     }
16     
17     ...
18 }

說明：對於MTP_SEND_EVENT消息，mtp_ioctl會先將"用戶空間"傳遞來的消息拷貝到"內核空間"；而後，調用mtp_send_event()進行處理。

7 Kernel中的mtp_send_event()

 1 static int mtp_send_event(struct mtp_dev *dev, struct mtp_event *event)
 2 {
 3     ...
 4 
 5     // 將「用戶空間」傳來的「消息的內容(event->data)」拷貝到「內核空間」中
 6     if (copy_from_user(req->buf, (void __user *)event->data, length)) 
 7     ...
 8 
 9     // 將req請求添加到USB隊列中。
10     ret = usb_ep_queue(dev->ep_intr, req, GFP_KERNEL);
11 
12     ...
13 }