Android之 MTP框架和流程分析
概要
本文的目的是介紹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！
轉載請注明出處：http://www.cnblogs.com/skywang12345/p/3474206.html
第1部分 MTP簡介
MTP，全稱是Media Transfer Protocol（媒體傳輸協議）。它是微軟的一個為計算機和便攜式設備之間傳輸圖像、音樂等所定制的協議。
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
", 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本地方法。
4native_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 }
說明：mtp_send_event()會先將"用戶空間"傳遞來的消息的具體內容拷貝到"內核空間"，并將該消息封裝在一個USB請求對象req中；然后，將USB請求添加到USB隊列中。USB驅動負責將該數據通過USB線發送給PC。
至此，Android設備中將一個文件拷貝到其他目錄的流程分析完畢！
總結
以上是生活随笔為你收集整理的Android之 MTP框架和流程分析的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： git拉取分支报错：fatal:‘XXX
- 下一篇： 独家！支付宝小程序技术架构全解析