概要

本文的目的是介紹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！ 

第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中的源碼如下：

<receiver android:name=".MtpReceiver"> 
    <intent-filter> 
        <action android:name="android.intent.action.BOOT_COMPLETED" /> 
    </intent-filter> 
    <intent-filter> 
        <action android:name="android.hardware.usb.action.USB_STATE" /> 
    </intent-filter> 
</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中實現，源碼如下：

public void onReceive(Context context, Intent intent) {  
    final String action = intent.getAction();  
    if (Intent.ACTION_BOOT_COMPLETED.equals(action)) {  
        final Intent usbState = context.registerReceiver(  
                null, new IntentFilter(UsbManager.ACTION_USB_STATE));  
        if (usbState != null) {  
            handleUsbState(context, usbState);  
        }  
    } else if (UsbManager.ACTION_USB_STATE.equals(action)) {  
        handleUsbState(context, intent);  
    }  
} 

說明：

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中實現，源碼如下：

private void handleUsbState(Context context, Intent intent) {  
    Bundle extras = intent.getExtras();  
    boolean connected = extras.getBoolean(UsbManager.USB_CONFIGURED);    // 獲取USB的連接狀態  
    boolean mtpEnabled = extras.getBoolean(UsbManager.USB_FUNCTION_MTP); // 獲取MTP的Enable狀態  
    boolean ptpEnabled = extras.getBoolean(UsbManager.USB_FUNCTION_PTP); // 獲取PTP的Enable狀態  
 
    if (connected && (mtpEnabled || ptpEnabled)) {  
        // 如果USB是連接狀態，並且“MTP或者PTP是Enable狀態”就執行下面的代碼  
 
        intent = new Intent(context, MtpService.class);  
        if (ptpEnabled) {  
            intent.putExtra(UsbManager.USB_FUNCTION_PTP, true);  
        }  
        // 啟動MtpService服務  
        context.startService(intent);  
        // 通知MediaProvider，MTP已經連上。  
        context.getContentResolver().insert(Uri.parse(  
                "content://media/none/mtp_connected"), null);  
    } else {  
        // 結束MtpService服務  
        context.stopService(new Intent(context, MtpService.class));  
        // 通知MediaProvider，MTP已經斷開。  
        context.getContentResolver().delete(Uri.parse(  
                "content://media/none/mtp_connected"), null, null);  
    }  
} 

說明：

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()的源碼如下：

public class MtpService extends Service {  
 
    @Override 
    public void onCreate() {  
        // 監聽“屏幕解鎖”廣播  
        registerReceiver(mReceiver, new IntentFilter(Intent.ACTION_USER_PRESENT));  
 
        // 獲取StorageManager對象。根據靜態工廠方法獲取的。  
        mStorageManager = StorageManager.from(this);  
        synchronized (mBinder) {  
            // 根據“屏幕鎖定與否”來啟動/禁用Mtp功能。  
            // 如果是當前用戶在設定了屏幕解鎖密碼的情況下鎖屏，則禁用Mtp功能。  
            updateDisabledStateLocked();  
            // 監聽“存儲設備的掛載/卸載等廣播事件”。  
            mStorageManager.registerListener(mStorageEventListener);  
            // 遍歷“Android設備”上所有存儲設備。  
            // 如果該存儲設備是“掛載狀態(MEDIA_MOUNTED)”，則通過Mtp鎖定該存儲設備；  
            // 這裡的Mtp鎖定，是指Mtp能識別到該存儲設備，並將該存儲設備映射到PC上。  
            StorageVolume[] volumes = mStorageManager.getVolumeList();  
            mVolumes = volumes;  
            for (int i = 0; i < volumes.length; i++) {  
                String path = volumes[i].getPath();  
                String state = mStorageManager.getVolumeState(path);  
                if (Environment.MEDIA_MOUNTED.equals(state)) {  
                    volumeMountedLocked(path);  
                }  
            }  
        }  
    }  
 
    ...  
} 

說明：

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

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

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

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

2.2 volumeMountedLocked()

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

private void volumeMountedLocked(String path) {  
    // 忽略“U盤”  
    if(MediaProvider.UDISK_MOUNT_POINT.equals(path))  
        return;  
    // 在所有的存儲設備中遍歷，找出該“path對應的存儲設備”，並將它添加到mVolumeMap中。  
    for (int i = 0; i < mVolumes.length; i++) {  
        StorageVolume volume = mVolumes[i];  
        if (volume.getPath().equals(path)) {  
            long reserveSpace = volume.getMtpReserveSpace() * 1024 * 1024;  
            if(path.equals(MediaProvider.LOCAL_MOUNT_POINT))  
                volume.setStorageId(0);  
            else if(path.equals(MediaProvider.UDISK_MOUNT_POINT)){  
                volume.setStorageId(2);  
            }else{  
                volume.setStorageId(1);  
            }  
            mVolumeMap.put(path, volume);  
            if (!mMtpDisabled) {  
                if (volume.isPrimary() || !mPtpMode) {  
                    addStorageLocked(volume);  
                }  
            }  
            break;  
        }  
    }  
} 

說明：

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

 

2.3 onStartCommand()

由於MtpService是"Started Service"類型的服務，而不是"Bound Service"。所以，MtpService啟動之後會執行onStartCommand()。

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

public int onStartCommand(Intent intent, int flags, int startId) {  
    synchronized (mBinder) {  
        // 根據“屏幕鎖定與否”來啟動/禁用Mtp功能。  
        // 如果是當前用戶在設定了屏幕解鎖密碼的情況下鎖屏，則禁用Mtp功能。  
        updateDisabledStateLocked();  
        mPtpMode = (intent == null ? false 
                : intent.getBooleanExtra(UsbManager.USB_FUNCTION_PTP, false));  
        String[] subdirs = null;  
        if (mPtpMode) {  
            // PTP模型才執行到這裡。  
            int count = PTP_DIRECTORIES.length;  
            subdirs = new String[count];  
            for (int i = 0; i < count; i++) {  
                File file =  
                        Environment.getExternalStoragePublicDirectory(PTP_DIRECTORIES[i]);  
                // make sure this directory exists  
                file.mkdirs();  
                subdirs[i] = file.getPath();  
            }  
        }  
        // 獲取“主存儲分區”。  
        final StorageVolume primary = StorageManager.getPrimaryVolume(mVolumes);  
        // 新建MtpDatabase對象  
        mDatabase = new MtpDatabase(this, MediaProvider.LOCAL_VOLUME,  
            primary.getPath(), subdirs);  
        manageServiceLocked();  
    }  
 
    return START_STICKY;  
} 

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

2.4 manageServiceLocked()

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

private void manageServiceLocked() {  
    // 是不是當前用戶  
    final boolean isCurrentUser = UserHandle.myUserId() == ActivityManager.getCurrentUser();  
    if (mServer == null && isCurrentUser) {  
        // 新建mServer對象  
        mServer = new MtpServer(mDatabase, mPtpMode);  
        // 如果MTP沒被禁用調，則調用addStorageDevicesLocked()  
        if (!mMtpDisabled) {  
            addStorageDevicesLocked();  
        }  
        // 啟動MtpServer  
        mServer.start();  
    } else if (mServer != null && !isCurrentUser) {  
        mServer = null;  
    }  
} 

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

 

2.5 addStorageDevicesLocked()

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

private void addStorageDevicesLocked() {  
    if (mPtpMode) {  
        final StorageVolume primary = StorageManager.getPrimaryVolume(mVolumes);  
        final String path = primary.getPath();  
        if (path != null) {  
            String state = mStorageManager.getVolumeState(path);  
            if (Environment.MEDIA_MOUNTED.equals(state)) {  
                addStorageLocked(mVolumeMap.get(path));  
            }  
        }  
    } else {  
        // 如果是MTP模式，則調用addStorageLocked()，mVolumeMap中的存儲設備添加到Mtp中。  
        for (StorageVolume volume : mVolumeMap.values()) {  
            addStorageLocked(volume);  
        }  
    }  
} 

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

2.6 addStorageLocked()

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

該函數在MtpService.java中實現，源碼如下：  
private void addStorageLocked(StorageVolume volume) {  
    // 忽略 “volume為空” 或者 “volume是u盤”的情況  
    if(volume != null && MediaProvider.UDISK_MOUNT_POINT.equals(volume.getPath()))  
        return;  
    // 新建該“存儲設備”對應的MtpStorage，並將該“存儲設備”添加到哈希表mStorageMap中。  
    MtpStorage storage = new MtpStorage(volume, getApplicationContext());  
    String path = storage.getPath();  
    mStorageMap.put(path, storage);  
 
    // 將storage添加到mDatabase中  
    if (mDatabase != null) {  
        mDatabase.addStorage(storage);  
    }  
    // 將storage添加到mServer中  
    if (mServer != null) {  
        mServer.addStorage(storage);  
    }  
} 

小結：

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

 

3 insert("mtp_connected")

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

3.1 MediaProvider靜態注冊塊

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

static 
{  
    ...  
 
    URI_MATCHER.addURI("media", "*/mtp_connected", MTP_CONNECTED);  
 
    ...  
} 

3.2 MediaProvider中的insert()

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

@Override 
public Uri insert(Uri uri, ContentValues initialValues) {  
    int match = URI_MATCHER.match(uri);  
 
    ArrayList<Long> notifyRowIds = new ArrayList<Long>();  
    Uri newUri = insertInternal(uri, match, initialValues, notifyRowIds);  
    notifyMtp(notifyRowIds);  
 
    // we will signal instead after file transfer is successful.  
    if (newUri != null && match != MTP_OBJECTS) {  
        getContext().getContentResolver().notifyChange(uri, null);  
    }  
    return newUri;  
} 

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

 

3.3 MediaProvider中的insertInternal()

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

private Uri insertInternal(Uri uri, int match, ContentValues initialValues,  
                           ArrayList<Long> notifyRowIds) {  
    ...  
 
    switch (match) {  
        case MTP_CONNECTED:  
            synchronized (mMtpServiceConnection) {  
                if (mMtpService == null) {  
                    Context context = getContext();  
                    // 將MediaProvider和MtpService綁定。  
                    context.bindService(new Intent(context, MtpService.class),  
                            mMtpServiceConnection, Context.BIND_AUTO_CREATE);  
                }  
            }  
            break;  
       ...  
   }  
 
   ...  
} 

說明：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構造函數，源碼如下：

public class MtpDatabase {  
 
    public MtpDatabase(Context context, String volumeName, String storagePath,  
            String[] subDirectories) {  
        // 調用JNI函數  
        native_setup();  
 
        // 初始化  
        mContext = context;  
        mPackageName = context.getPackageName();  
        mMediaProvider = context.getContentResolver().acquireProvider("media");  
        mVolumeName = volumeName;  
        mMediaStoragePath = storagePath;  
        mObjectsUri = Files.getMtpObjectsUri(volumeName);  
        mMediaScanner = new MediaScanner(context);  
 
        mSubDirectories = subDirectories;  
 
        ...  
 
        // 初始化設備屬性，將其保存到SharedPreferences中  
        initDeviceProperties(context);  
    }  
 
    ...  
} 

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

 

5.1 native_setup()

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

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

說明：

從中可以看出native_setup()的實現在libmedia_jni.so中，准確的說是在android_mtp_MtpDatabase.cpp中的注冊。相關的代碼如下：

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

從中，我們看出，native_setup()實際上是和JNI中的android_mtp_MtpDatabase_setup()對應。android_mtp_MtpDatabase_setup()的源碼如下：

static void android_mtp_MtpDatabase_setup(JNIEnv *env, jobject thiz)  
{  
    // 新建MyMtpDatabase對象database  
    MyMtpDatabase* database = new MyMtpDatabase(env, thiz);  
    // 將database對象保存“field_context”域中。  
    env->SetIntField(thiz, field_context, (int)database);  
    checkAndClearExceptionFromCallback(env, __FUNCTION__);  
} 

 

說明：

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的構造函數源碼如下：

public class MtpServer implements Runnable {  
    public MtpServer(MtpDatabase database, boolean usePtp) {  
        native_setup(database, usePtp);  
    }  
 
    ...  
} 

 

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

static {  
    System.loadLibrary("media_jni");  
}  
private native final void native_setup(MtpDatabase database, boolean usePtp);  
private native final void native_run();  
private native final void native_cleanup();  
private native final void native_send_object_added(int handle);  
private native final void native_send_object_removed(int handle);  
private native final void native_add_storage(MtpStorage storage);  
private native final void native_remove_storage(int storageId); 

6.1 native_setup()

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

static JNINativeMethod gMethods[] = {  
    {"native_setup",                "(Landroid/mtp/MtpDatabase;Z)V",  
                                            (void *)android_mtp_MtpServer_setup},  
    {"native_run",                  "()V",  (void *)android_mtp_MtpServer_run},  
    {"native_cleanup",              "()V",  (void *)android_mtp_MtpServer_cleanup},  
    {"native_send_object_added",    "(I)V", (void *)android_mtp_MtpServer_send_object_added},  
    {"native_send_object_removed",  "(I)V", (void *)android_mtp_MtpServer_send_object_removed},  
    {"native_add_storage",          "(Landroid/mtp/MtpStorage;)V",  
                                            (void *)android_mtp_MtpServer_add_storage},  
    {"native_remove_storage",       "(I)V", (void *)android_mtp_MtpServer_remove_storage},  
}; 

從中，我們直到native_setup()實際上是與android_mtp_MtpServer_setup()對應。

 

android_mtp_MtpServer_setup()的源碼如下：

static void android_mtp_MtpServer_setup(JNIEnv *env, jobject thiz, jobject javaDatabase, jboolean usePtp)  
{  
    // 打開文件“/dev/mtp_usb”  
    int fd = open("/dev/mtp_usb", O_RDWR);  
    if (fd >= 0) {  
        // 根據“fd”和“MtpDatabase”創建MtpServer對象server  
        MtpServer* server = new MtpServer(fd, getMtpDatabase(env, javaDatabase),  
                usePtp, AID_MEDIA_RW, 0664, 0775);  
        // 將server對象保存到“field_MtpServer_nativeContext”域中。  
        env->SetIntField(thiz, field_MtpServer_nativeContext, (int)server);  
    } else {  
        ALOGE("could not open MTP driver, errno: %d", errno);  
    }  
} 

 

說明：

(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中實現，源碼如下：

 

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

說明：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的構造函數如下：

public class MtpStorage {  
    private final int mStorageId;  
    private final String mPath;  
    private final String mDescription;  
    private final long mReserveSpace;  
    private final boolean mRemovable;  
    private final long mMaxFileSize;  
 
    public MtpStorage(StorageVolume volume, Context context) {  
        // 存儲設備ID  
        mStorageId = volume.getStorageId();  
        // 對應“Android設備”上的存儲路徑  
        mPath = volume.getPath();  
        // 描述  
        mDescription = context.getResources().getString(volume.getDescriptionId());  
        // (對MTP而言)可用空間  
        mReserveSpace = volume.getMtpReserveSpace() * 1024L * 1024L;  
        // 是否可移除  
        mRemovable = volume.isRemovable();  
        // 最大文件大小。(0表示無限制)  
        mMaxFileSize = volume.getMaxFileSize();  
    }  
 
    ...  
} 

 

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()函數。源碼如下：

public void addStorage(MtpStorage storage) {  
    native_add_storage(storage);  
}  

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

 

9.1 android_mtp_MtpServer_add_storage()

static void android_mtp_MtpServer_add_storage(JNIEnv *env, jobject thiz, jobject jstorage)  
{  
    Mutex::Autolock autoLock(sMutex);  
 
    // 獲取MtpServer對象  
    MtpServer* server = getMtpServer(env, thiz);  
    if (server) {  
        // field_MtpStorage_storageId 和 “MtpStorage.java中的mStorageId” 對應  
        jint storageID = env->GetIntField(jstorage, field_MtpStorage_storageId);  
        // field_MtpStorage_path 和 “MtpStorage.java中的mPath” 對應  
        jstring path = (jstring)env->GetObjectField(jstorage, field_MtpStorage_path);  
        // field_MtpStorage_description 和 “MtpStorage.java中的mDescription” 對應  
        jstring description = (jstring)env->GetObjectField(jstorage, field_MtpStorage_description);  
        // field_MtpStorage_reserveSpace 和 “MtpStorage.java中的mReserveSpace” 對應  
        jlong reserveSpace = env->GetLongField(jstorage, field_MtpStorage_reserveSpace);  
        // field_MtpStorage_removable 和 “MtpStorage.java中的mRemovable” 對應  
        jboolean removable = env->GetBooleanField(jstorage, field_MtpStorage_removable);  
        // field_MtpStorage_maxFileSize 和 “MtpStorage.java中的mMaxFileSize” 對應  
        jlong maxFileSize = env->GetLongField(jstorage, field_MtpStorage_maxFileSize);  
 
        // 將“jstring類型的path”轉換為“C語言中的char *類型”  
        const char *pathStr = env->GetStringUTFChars(path, NULL);  
        if (pathStr != NULL) {  
            // 獲取“存儲設備”的描述字符串  
            const char *descriptionStr = env->GetStringUTFChars(description, NULL);  
            if (descriptionStr != NULL) {  
                // 創建(MtpStorage.cpp)MtpStorage對象  
                MtpStorage* storage = new MtpStorage(storageID, pathStr, descriptionStr,  
                        reserveSpace, removable, maxFileSize);  
                // 將該MtpStorage對象，添加到MtpServer中  
                server->addStorage(storage);  
                env->ReleaseStringUTFChars(path, pathStr);  
                env->ReleaseStringUTFChars(description, descriptionStr);  
            } else {  
                env->ReleaseStringUTFChars(path, pathStr);  
            }  
        }  
    } else {  
        ALOGE("server is null in add_storage");  
    }  
} 

說明：

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

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

(03) 創建MtpStorage對象。

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

 

9.2 server=getMtpServer()

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

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

說明：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()中初始化的。源碼如下：

int register_android_mtp_MtpServer(JNIEnv *env)  
{  
    jclass clazz;  
 
    // 找到java中“android.mtp.MtpStorage.java”包  
    clazz = env->FindClass("android/mtp/MtpStorage");  
    ...  
 
    // 獲取“MtpStorage.java中mStorageId”的fieldId，並保存到field_MtpStorage_storageId中  
    field_MtpStorage_storageId = env->GetFieldID(clazz, "mStorageId", "I");  
    if (field_MtpStorage_storageId == NULL) {  
        ALOGE("Can't find MtpStorage.mStorageId");  
        return -1;  
    }  
 
    ..  
} 

 

register_android_mtp_MtpServer()又是何時被調用的呢？

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

jint JNI_OnLoad(JavaVM* vm, void* reserved)  
{  
    ...  
 
    if (register_android_mtp_MtpServer(env) < 0) {  
        ALOGE("ERROR: MtpServer native registration failed");  
        goto bail;  
    }  
 
    ...  
} 

 

由於在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層)中的成員如下：

class MtpStorage {  
 
private:  
    MtpStorageID            mStorageID;  
    MtpString               mFilePath;  
    MtpString               mDescription;  
    uint64_t                mMaxCapacity;  
    uint64_t                mMaxFileSize;  
    uint64_t                mReserveSpace;  
    bool                    mRemovable;  
 
    ...  
} 

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

 

9.4 server->addStorage(storage)

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

void MtpServer::addStorage(MtpStorage* storage) {  
    // 獲取“信號量”  
    Mutex::Autolock autoLock(mMutex);  
 
    // mStorages是“MtpStorage的Vector容量對象”，相當於“MtpStorage的動態數組”。  
    mStorages.push(storage);  
    // 調用sendStoreAdded()通知PC，讓PC通過MTP掛載該存儲設備  
    sendStoreAdded(storage->getStorageID());  
} 

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

 

9.5 sendStoreAdded()

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

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

說明：

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

 

9.6 sendEvent()

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

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

說明：

(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中實現，源碼如下：

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

 

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

 

9.7.4 write()

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

int MtpEventPacket::write(int fd) {  
    struct mtp_event    event;  
 
    putUInt32(MTP_CONTAINER_LENGTH_OFFSET, mPacketSize);  
    putUInt16(MTP_CONTAINER_TYPE_OFFSET, MTP_CONTAINER_TYPE_EVENT);  
 
    // 將“緩沖”賦值給event.data  
    event.data = mBuffer;  
    event.length = mPacketSize;  
    // 通過“ioctl事件”將該消息發送給驅動，驅動再負責和PC通信。  
    int ret = ::ioctl(fd, MTP_SEND_EVENT, (unsigned long)&event);  
    return (ret < 0 ? ret : 0);  
} 

說明：

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"中。

static const char mtp_shortname[] = "mtp_usb";  
 
static const struct file_operations mtp_fops = {  
    .owner = THIS_MODULE,  
    .read = mtp_read,  
    .write = mtp_write,  
    .unlocked_ioctl = mtp_ioctl,  
    .open = mtp_open,  
    .release = mtp_release,  
};   
 
static struct miscdevice mtp_device = {  
    .minor = MISC_DYNAMIC_MINOR,  
    .name = mtp_shortname,  
    .fops = &mtp_fops,  
};    
 
static int mtp_setup(void)  
{  
    ...  
 
    ret = misc_register(&mtp_device);  
 
    ...  
} 

說明：

(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中實現，源碼如下：

static ssize_t mtp_read(struct file *fp, char __user *buf,  
    size_t count, loff_t *pos)  
{  
    // 從“USB”消息隊列中中讀取PC發給Android設備的請求，請求消息保存在req中。  
    ret = usb_ep_queue(dev->ep_out, req, GFP_KERNEL);  
    ...  
 
    // 等待cpu將工作隊列(read_wq)上已有的消息處理完畢  
    ret = wait_event_interruptible(dev->read_wq, dev->rx_done);  
    ...  
 
    // 將“PC的請求數據(req->)”從“內核空間”拷貝到“用戶空間”  
    if (copy_to_user(buf, req->buf, xfer))  
        r = -EFAULT;  
 
    ...  
} 

 

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

 

三. mtp_write()

static ssize_t mtp_write(struct file *fp, const char __user *buf,  
    size_t count, loff_t *pos)  
{  
 
    while (count > 0 || sendZLP) {  
 
        // 將“用戶空間”傳來的消息(buf)拷貝到“內核空間”的req->buf中。  
        if (xfer && copy_from_user(req->buf, buf, xfer))   
        ...  
 
        // 將打包好的消息req放到USB消息隊列中。  
        ret = usb_ep_queue(dev->ep_in, req, GFP_KERNEL);  
        ...  
    }  
 
    ...  
} 

說明：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()方法，它的源碼如下：

static void android_mtp_MtpServer_run(JNIEnv *env, jobject thiz)  
{  
    // 返回MtpServer對象  
    MtpServer* server = getMtpServer(env, thiz);  
    // 如果server不為NULL，則調用它的run()方法。  
    if (server)  
        server->run();  
    else 
        ALOGE("server is null in run");  
} 

說明：

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

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

 

10.2 run()

void MtpServer::run() {  
    // 將mFD賦值給fd，fd就是“/dev/mtp_usb”的句柄  
    int fd = mFD;  
 
    while (1) {  
        // 讀取“/dev/mtp_usb”  
        int ret = mRequest.read(fd);  
 
        ...  
        // 獲取“MTP操作碼”  
        MtpOperationCode operation = mRequest.getOperationCode();  
        MtpTransactionID transaction = mRequest.getTransactionID();  
 
        ...  
 
        // 在handleRequest()中，根據讀取的指令作出相應的處理  
        if (handleRequest()) {  
            ...  
        }  
    }  
 
    ...  
} 

說明：

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()則是對讀取出來的消息進行處理，它的源碼如下：

bool MtpServer::handleRequest() {  
    Mutex::Autolock autoLock(mMutex);  
 
    MtpOperationCode operation = mRequest.getOperationCode();  
    MtpResponseCode response;  
 
    mResponse.reset();  
 
    if (mSendObjectHandle != kInvalidObjectHandle && operation != MTP_OPERATION_SEND_OBJECT) {  
        mSendObjectHandle = kInvalidObjectHandle;  
    }  
 
    switch (operation) {  
        case MTP_OPERATION_GET_DEVICE_INFO:  
            response = doGetDeviceInfo();  
            break;  
        case MTP_OPERATION_OPEN_SESSION:  
            response = doOpenSession();  
            break;  
        case MTP_OPERATION_CLOSE_SESSION:  
            response = doCloseSession();  
            break;  
        ...  
        case MTP_OPERATION_GET_OBJECT:  
            response = doGetObject();  
            break;  
        case MTP_OPERATION_SEND_OBJECT:  
            response = doSendObject();  
            break;  
        ...  
    }  
 
    if (response == MTP_RESPONSE_TRANSACTION_CANCELLED)  
        return false;  
    mResponse.setResponseCode(response);  
    return true;  
} 

 

 

總結：在"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()的源碼如下：

MtpResponseCode MtpServer::doGetObject() {  
    ...  
      
    // 根據handle獲取文件的路徑(pathBuf)、大小(fileLength)和“格式”。  
    int result = mDatabase->getObjectFilePath(handle, pathBuf, fileLength, format);  
    if (result != MTP_RESPONSE_OK)  
        return result;  
 
    // 將文件路徑轉換為const char*類型。  
    const char* filePath = (const char *)pathBuf;  
    // 將文件的信息傳遞給mfr，mfr是kernel的一個結構體；最終將mfr傳遞給kernel。  
    mtp_file_range  mfr;  
    mfr.fd = open(filePath, O_RDONLY);                 // 設置“文件句柄”。  
    if (mfr.fd < 0) {  
        return MTP_RESPONSE_GENERAL_ERROR;  
    }  
    mfr.offset = 0;                                    // 設置“文件偏移”  
    mfr.length = fileLength;  
    mfr.command = mRequest.getOperationCode();         // 設置“command”  
    mfr.transaction_id = mRequest.getTransactionID();  // 設置“transaction ID”  
 
    // 通過ioctl將文件傳給kernel。  
    int ret = ioctl(mFD, MTP_SEND_FILE_WITH_HEADER, (unsigned long)&mfr);  
    // 關閉文件  
    close(mfr.fd);  
 
    ...  
} 

說明：

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中實現。

MtpResponseCode MyMtpDatabase::getObjectFilePath(MtpObjectHandle handle,  
                                            MtpString& outFilePath,  
                                            int64_t& outFileLength,  
                                            MtpObjectFormat& outFormat) {  
    ...  
 
    // 調用MtpDatabase.java中的getObjectFilePath()。  
    // 作用是根據文件句柄，獲取“文件路徑”、“文件大小”、“文件格式”  
    jint result = env->CallIntMethod(mDatabase, method_getObjectFilePath,  
                (jint)handle, mStringBuffer, mLongBuffer);  
 
    // 設置“文件路徑”  
    jchar* str = env->GetCharArrayElements(mStringBuffer, 0);  
    outFilePath.setTo(str, strlen16(str));  
    env->ReleaseCharArrayElements(mStringBuffer, str, 0);  
 
    // 設置“文件大小”和“文件格式”  
    jlong* longValues = env->GetLongArrayElements(mLongBuffer, 0);  
    outFileLength = longValues[0];  
    outFormat = longValues[1];  
    env->ReleaseLongArrayElements(mLongBuffer, longValues, 0);  
 
 
    ...  
} 

說明：

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

5 getObjectFilePath()

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

private int getObjectFilePath(int handle, char[] outFilePath, long[] outFileLengthFormat) {  
    ...  
 
    // 在MediaProvider中查找文件對應的路徑。  
    // mObjectsUri是根據文件handle獲取到的URI。  
    c = mMediaProvider.query(mPackageName, mObjectsUri, PATH_FORMAT_PROJECTION,  
                    ID_WHERE, new String[] {  Integer.toString(handle) }, null, null);  
    if (c != null && c.moveToNext()) {  
        // 獲取“文件路徑”  
        String path = c.getString(1);  
        path.getChars(0, path.length(), outFilePath, 0);  
        outFilePath[path.length()] = 0;  
        // 獲取“文件大小”  
        outFileLengthFormat[0] = new File(path).length();  
        // 獲取“文件格式”  
        outFileLengthFormat[1] = c.getLong(2);  
        return MtpConstants.RESPONSE_OK;  
    } else {  
        return MtpConstants.RESPONSE_INVALID_OBJECT_HANDLE;  
    }  
 
    ...  
} 

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

 

6 ioctl

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

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

static long mtp_ioctl(struct file *fp, unsigned code, unsigned long value)  
{  
    ...  
 
    switch (code) {  
    case MTP_SEND_FILE:  
    case MTP_RECEIVE_FILE:  
    case MTP_SEND_FILE_WITH_HEADER:  
    {  
        struct mtp_file_range    mfr;  
        struct work_struct *work;  
 
        // 將“用戶空間”傳來的值(value)拷貝到“內核空間”的mfr中。  
        if (copy_from_user(&mfr, (void __user *)value, sizeof(mfr))) {  
            ret = -EFAULT;  
            goto fail;  
        }  
        // 獲取文件句柄  
        filp = fget(mfr.fd);  
        if (!filp) {  
            ret = -EBADF;  
            goto fail;  
        }  
 
        // 將“文件相關的信息”賦值給dev。  
        dev->xfer_file = filp;  
        dev->xfer_file_offset = mfr.offset;  
        dev->xfer_file_length = mfr.length;  
        smp_wmb();  
 
        if (code == MTP_SEND_FILE_WITH_HEADER) {  
            // 設置work的值  
            work = &dev->send_file_work;  
            dev->xfer_send_header = 1;  
            dev->xfer_command = mfr.command;  
            dev->xfer_transaction_id = mfr.transaction_id;  
        }   
        ...  
 
        // 將work添加到工作隊列(dev->wq)中。  
        queue_work(dev->wq, work);  
        // 對工作隊列執行flush操作。  
        flush_workqueue(dev->wq);  
 
        break;  
    }  
 
    ...  
} 

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

 

send_file_work()的源碼如下：

static void send_file_work(struct work_struct *data)  
{  
    // 獲取dev結構體  
    struct mtp_dev *dev = container_of(data, struct mtp_dev,  
                        send_file_work);  
    ...  
 
    // 讀取文件消息  
    smp_rmb();  
    filp = dev->xfer_file;  
    offset = dev->xfer_file_offset;  
    count = dev->xfer_file_length;  
 
 
    while (count > 0 || sendZLP) {  
 
        ...  
 
        // 從文件中讀取數據到內存中。  
        ret = vfs_read(filp, req->buf + hdr_size, xfer - hdr_size,  
                                &offset);  
 
        ...  
 
        // 將req添加到usb終端的隊列中  
        ret = usb_ep_queue(dev->ep_in, req, GFP_KERNEL);  
 
        ...  
    }  
 
    ...  
} 

說明：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的源碼如下：

private void sendObjectAdded(long objectHandle) {  
    synchronized (mMtpServiceConnection) {  
        if (mMtpService != null) {  
            try {  
                mMtpService.sendObjectAdded((int)objectHandle);  
            } catch (RemoteException e) {  
                Log.e(TAG, "RemoteException in sendObjectAdded", e);  
                mMtpService = null;  
            }  
        }  
    }  
} 

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

 

2 MtpService.java中sendObjectAdded()

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

MtpService.java中sendObjectAdded()的源碼如下：  
public void sendObjectAdded(int objectHandle) {  
    synchronized (mBinder) {  
        if (mServer != null) {  
            mServer.sendObjectAdded(objectHandle);  
        }  
    }  
} 

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

 

3 MtpServer.java中的sendObjectAdded

public void sendObjectAdded(int handle) {  
    native_send_object_added(handle);  
}  

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

 

4 native_send_object_added()

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

static void android_mtp_MtpServer_send_object_added(JNIEnv *env, jobject thiz, jint handle)  
{  
    Mutex::Autolock autoLock(sMutex);  
 
    // 獲取MtpServer，然後調用MtpServer的sendObjectAdded()方法。  
    MtpServer* server = getMtpServer(env, thiz);  
    if (server)  
        server->sendObjectAdded(handle);  
    else 
        ALOGE("server is null in send_object_added");  
} 

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

 

5 MtpServer.cpp中的sendObjectAdded

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

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

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

 

6 Kernel中的ioctl

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

static long mtp_ioctl(struct file *fp, unsigned code, unsigned long value)  
{  
    ...  
 
    case MTP_SEND_EVENT:  
    {  
        struct mtp_event    event;  
        // 將“用戶空間”傳來的值(value)拷貝到“內核空間”的event中。  
        if (copy_from_user(&event, (void __user *)value, sizeof(event)))  
            ret = -EFAULT;  
        else 
            ret = mtp_send_event(dev, &event);  
 
        ...  
    }  
      
    ...  
} 

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

7 Kernel中的mtp_send_event()

static int mtp_send_event(struct mtp_dev *dev, struct mtp_event *event)  
{  
    ...  
 
    // 將“用戶空間”傳來的“消息的內容(event->data)”拷貝到“內核空間”中  
    if (copy_from_user(req->buf, (void __user *)event->data, length))   
    ...  
 
    // 將req請求添加到USB隊列中。  
    ret = usb_ep_queue(dev->ep_intr, req, GFP_KERNEL);  
 
    ...  
} 

說明：mtp_send_event()會先將"用戶空間"傳遞來的消息的具體內容拷貝到"內核空間"，並將該消息封裝在一個USB請求對象req中；然後，將USB請求添加到USB隊列中。USB驅動負責將該數據通過USB線發送給PC。

 

至此，Android設備中將一個文件拷貝到其他目錄的流程分析完畢！