背景

上篇文章中我們瞭解了嵌入式裝置端將Android手機設定為accessory模式的流程以及嵌入式裝置端接收和傳送資料的流程，本文將對應介紹Android端accessory模式被啟用的過程，以及接下來如何與嵌入式裝置端進行通訊。本文的原始碼下載地址：https://git.oschina.net/vonchenchen/aoa_android.git

實現

USBConnStatusManager 底層啟動accessory模式

Android系統api通過UsbManager類管理usb相關，這裡我們關注一下與accessory模式相關的內容。
當裝置端啟動android的accessory模式時，系統將會發送一條廣播，裝置拔出時也會發送一條廣播，同時還有一條申請usb使用許可權的廣播。所以，要做的第一步就是動態註冊這些廣播，並編寫一個廣播接收者來處理對應的事件。這裡對於的方法我們封裝到了USBConnStatusManager類中，用來管理accessory相關連線。

IntentFilter filter = new IntentFilter();
        //接收許可權資訊
        filter.addAction(ACTION_USB_PERMISSION);
        //接收accessory連線事件
        filter.addAction(UsbManager.ACTION_USB_ACCESSORY_ATTACHED);
        //接收accessory斷開事件
        filter.addAction(UsbManager.ACTION_USB_ACCESSORY_DETACHED);
        getContext().registerReceiver(mUsbReceiver, filter
 
);

下面是對應的廣播接收者，這裡其實只需要監聽兩個廣播，一個是獲取usb許可權，一旦這個廣播發出我們就可以認為裝置現在正在啟動手機的accessory模式，第一次連線時手機會彈出對話方塊，讓我們選擇是否執行usb許可權，另外一個就是需要在usb斷開時做出反應，告訴裝置連線已經斷開了。下面是處理廣播事件的過程：

mUsbReceiver = new BroadcastReceiver() {

            @Override
            public void onReceive(Context context, Intent intent) {
                String
 
 action = intent.getAction();

                Log.i(TAG, "receive usb connect broadcast:" + action);

                if (ACTION_USB_PERMISSION.equals(action)) {
                    synchronized (this) {
                        //UsbAccessory accessory = UsbManager.getAccessory(intent);
                        UsbAccessory accessory = (UsbAccessory) intent.getParcelableExtra(UsbManager.EXTRA_ACCESSORY);

                        //獲取accessory控制代碼成功
                        if (intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false)) {
                            Log.d(TAG, "prepare to open usb stream");

                            sCurStatus = STATUS_CONN_OK;
                            mUsbAccessory = accessory;

                            if (mOnUSBConnStatusChanged != null) {
                                mOnUSBConnStatusChanged.onUSBConnect(accessory);
                            }

                        } else {
                            Log.d(TAG, "permission denied for accessory " + accessory);

                            sCurStatus = STATUS_CONN_ERR;
                            mUsbAccessory = null;

                            if (mOnUSBConnStatusChanged != null) {
                                mOnUSBConnStatusChanged.onUSBConnectFailed(accessory);
                            }
                        }
                    }
                } else if (UsbManager.ACTION_USB_ACCESSORY_DETACHED.equals(action)) {
                    UsbAccessory accessory = (UsbAccessory) intent.getParcelableExtra(UsbManager.EXTRA_ACCESSORY);
                    //if (accessory != null && accessory.equals(mAccessory)) {

                       //檢測到usb斷開
                       Log.d(TAG, "USB_ACCESSORY_DETACHED " + accessory);

                        sCurStatus = STATUS_DISCONN;
                        mUsbAccessory = null;
                        //closeAccessory();
                        //synchronized (USBConnStatusManager.class) {
                            if (mOnUSBConnStatusChanged != null) {
                                mOnUSBConnStatusChanged.onUSBDisconnect(accessory);
                            }
                        //}
                    //}
                }
            }
        };

這裡拿到accessory的引用以後就可以用這個引用獲取usb的讀寫流，然後將accessory交給外部介面，由外部類處理資料的具體讀寫內容。如果接收到裝置拔出廣播，則手動釋放引用，更新連線狀態。
另外，如果裝置已經插入並且處於accessory模式，廣播接受者並不會呼叫，這時可以同步開啟裝置。可以檢查mUsbManager.getAccessoryList()，如果有accessory裝置則可以直接獲取裝置引用。由於一般手機都只有一個U口，此處預設只要有一個accessory連線就是我們的裝置。下面程式碼用於同步開啟已經存在的於accessory表中的裝置：

    public void checkUSBDevice() {

        UsbAccessory[] accessories = mUsbManager.getAccessoryList();

        if(accessories == null){
            Log.i(TAG, "accessories list is null");
            return;
        }

        Log.i(TAG, "accessories length "+accessories.length);

        UsbAccessory accessory = (accessories == null ? null : accessories[0]);
        if (accessory != null) {
            if (mUsbManager.hasPermission(accessory)) {

                sCurStatus = STATUS_CONN_OK;
                mUsbAccessory = accessory;

                //synchronized (USBConnStatusManager.class) {
                    if (mOnUSBConnStatusChanged != null) {
                        mOnUSBConnStatusChanged.onUSBConnect(accessory);
                    }
                //}
            } else {
                //synchronized (mUsbReceiver) {
                    if (!mPermissionRequestPending) {
                        mUsbManager.requestPermission(accessory, mPermissionIntent);
                        mPermissionRequestPending = true;
                    }
                //}

            }
        }
    }

USBHelper 具體操作usb的開關和讀寫等功能

USBHelper類具體操作usb的功能，這個類中持有USBConnStatusManager的單例物件，有了USBConnStatusManager就可以拿到accessroy，通過USBConnStatusManager獲取到讀寫流，這個類就是在外層呼叫USBConnStatusManager方法，對usb進行操作。

openAsync

這個方法用來開啟usb，首先註冊廣播接收者回調，用來檢測usb插拔資訊，註冊完畢後檢查當前系統中存在的accessory裝置，如果已經連線了accessroy裝置，則直接獲取其accessroy的引用，通過這個引用獲取讀寫流，者就是usb的開啟過程。

    /**
     * accessory模式開啟android的 usb裝置
     * 如果當前列表有處於accessory模式的控制代碼則直接開啟
     * 如果當前沒有則回監聽usb插拔，監聽到對應事件後檢查系統列表
     * @param onUSBConnStatusChanged
     */
    @Override
    public void openAsync(final OnUSBConnStatusChanged onUSBConnStatusChanged) {

        mReciveBuffer = new byte[RECIVE_BUF_SIZE];

        //註冊USB連線狀態監聽
        mUSBConnStatusManager.registOnUSBConnStatusChangedListener(new OnUSBConnStatusChanged() {
            @Override
            public void onUSBConnect(UsbAccessory accessory) {

                openAccessory(accessory);
                if (onUSBConnStatusChanged != null) {
                    onUSBConnStatusChanged.onUSBConnect(accessory);
                }
            }

            @Override
            public void onUSBConnectFailed(UsbAccessory accessory) {

                closeAccessory();
                if (onUSBConnStatusChanged != null) {
                    onUSBConnStatusChanged.onUSBConnectFailed(accessory);
                }
            }

            @Override
            public void onUSBDisconnect(UsbAccessory accessory) {

                closeAccessory();
                if (onUSBConnStatusChanged != null) {
                    onUSBConnStatusChanged.onUSBDisconnect(accessory);
                }
            }
        });

        //檢查usb列表 檢視是否已經連線accessory裝置
        mUSBConnStatusManager.checkUSBDevice();
    }

        /**
     * 通過accessory控制代碼拿到usb裝置的輸入輸出流
     * @param accessory
     */
    private void openAccessory(UsbAccessory accessory) {

        mFileDescriptor = mUsbManager.openAccessory(accessory);

        if (mFileDescriptor != null) {
            mAccessory = accessory;
            FileDescriptor fd = mFileDescriptor.getFileDescriptor();

            //usb讀寫流
            mInputStream = new FileInputStream(fd);
            mOutputStream = new FileOutputStream(fd);

            if (mOnDataTranPrepared != null) {
                Log.d(TAG, "accessory opened DataTranPrepared");
                mOnDataTranPrepared.onDataTranPrepared(mInputStream, mOutputStream);
            }

            Log.d(TAG, "accessory opened");
        } else {
            Log.d(TAG, "accessory open fail");
        }
    }

另外這個類還提供了usb資料讀寫和關閉裝置等方法，大家可以參考專案原始碼。

SimpleTcpWrapper 封裝上層通訊協議

打通底層資料通道，下面就是封裝我們自己協議了，在專案中使用tcp頭簡單封裝了一個協議，可以實現三次握手，資料包通過序列號校驗以及根據不同埠分發資料的功能。本章只討論Android裝置底層通訊的實現，所以刪除了協議部分，只是將usb傳送過來的資料原樣傳送回去。

SimpleTcpWrapper中建立一個USBHelper物件用來管理usb資料通訊，呼叫openAsync非同步開啟資料。一旦資料連線成功，我們就是開啟一個數據接收執行緒，讀取這個accessory的inputstream，一旦收到資料就將資料寫入accessory的outputstrem中。

/**
 * 資料通訊協議封裝類，本例中只涉及簡單usb層傳輸，並沒有封裝上層協議
 * Created by lidechen on 2/25/17.
 */

public class SimpleTcpWrapper implements ISimpleTcpManager {

    private static final String TAG = "SimpleTcpWrapper";

    private Context mContext;

    /**
     * 資料通訊物件引用
     */
    private USBHelper mConmunicateHelper;

    private Thread mRecieveThread;
    private ReciveTask mReciveTask;

    /**
     * 強制重啟usb標誌
     */
    private boolean mForceOpenUSB = false;

    public SimpleTcpWrapper(Context context) {

        mContext = context;

        mConmunicateHelper = new USBHelper(mContext);
    }

    public void start(){

        //資料傳輸層準備就緒 可以開啟資料收發任務
        mConmunicateHelper.setOnDataTranPrepared(new USBHelper.OnDataTranPrepared() {
            @Override
            public void onDataTranPrepared(FileInputStream inputStream, FileOutputStream outputStream) {

                if (Config.DEBUG) {
                    Log.i(TAG, "accessory opened: inputStream " + inputStream + " outputStream " + outputStream);
                }

                //建立從usb讀取資料的任務
                mReciveTask = new ReciveTask(inputStream);
                mRecieveThread = new Thread(mReciveTask);
                mRecieveThread.start();
            }
        });
    }

    public void openUSBAsync(boolean reset) {

        if (mForceOpenUSB == false) {

            //狀態為已連線且不是從後臺進入 直接返回
            if (!reset) {
                return;
            }

            if(Config.DEBUG){
                Log.i(TAG, "openUSBAsync ...");
            }
        }

        mForceOpenUSB = false;


        mConmunicateHelper.openAsync(new OnUSBConnStatusChanged() {
            @Override
            public void onUSBConnect(UsbAccessory accessory) {

            }

            @Override
            public void onUSBConnectFailed(UsbAccessory accessory) {

                Log.i(TAG, "connect state ### onUSBConnectFailed ###");

                mConmunicateHelper.close();

                mForceOpenUSB = true;
            }

            @Override
            public void onUSBDisconnect(UsbAccessory accessory) {

                Log.i(TAG, "connect state ### onUSBDisconnect ###");

                mConmunicateHelper.close();

                mForceOpenUSB = true;
            }
        });
    }

    public void closeUSB() {

        if (mRecieveThread != null) {
            mReadTaskRun = false;
            Thread.State state = mRecieveThread.getState();
            if (state == Thread.State.BLOCKED || state == Thread.State.TIMED_WAITING || state == Thread.State.TIMED_WAITING) {
                mRecieveThread.interrupt();
            }
            mRecieveThread = null;
        }

        mConmunicateHelper.close();
    }

    @Override
    public int readTcpData(byte[] data, int realLen) {

        return 0;
    }

    @Override
    public void writeRawData(byte[] data, int realLen) {
    }

    private byte[] mReciveBuffer;
    private static final int RECIVE_BUF_SIZE = 1024*10;
    private boolean mReadTaskRun = false;

    public class ReciveTask implements Runnable {

        private FileInputStream mInputStream;

        public ReciveTask(FileInputStream inputStream) {

            mInputStream = inputStream;
        }

        @Override
        public void run() {

            mReciveBuffer = new byte[RECIVE_BUF_SIZE];

            mReadTaskRun = true;

            int off = 0;
            int len = 0;

            while (mReadTaskRun) {
                try {

                    if (Config.DEBUG) {
                        Log.i(TAG, "accessory opened start read");
                    }

                    //usb資料接收
                    int ret = mInputStream.read(mReciveBuffer, off, RECIVE_BUF_SIZE - off);

                    //將接收到的資料返回給usb
                    byte[] retBuf = new byte[ret];
                    System.arraycopy(mReciveBuffer, 0, retBuf, 0, ret);
                    mConmunicateHelper.writeSyncToUSB(retBuf);
                    Log.i(TAG, "feedback "+new String(retBuf));

                } catch (IOException e) {

                    if (Config.DEBUG) {
                        Log.i(TAG, "ReciveTask exception :\n" + e.toString());
                    }

                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e1) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

}

建立連線服務

在實踐中發現上述SimpleTcpWrapper如果與應用建立在本app服務中，如果應用閃退usb則不能被正確釋放，有時候服務還會被殺死，相對而言開一個單獨程序的服務則比較穩定，app奔潰也不會掛掉，如果手動殺死app則外部服務也會被正確釋放，不會佔用usb資源。
獨立程序的服務可以通過socket與我們的app進行資料互動。

關於嵌入式裝置啟動app應用

上一篇文章我們提到了裝置開啟android的app，會寫入一些資訊，那麼android端是如何對應這些資訊的呢？我們看看嵌入式端給android寫的那些資訊是什麼

    const char *setupStrings[6];
    setupStrings[0] = vendor;
    setupStrings[1] = model;
    setupStrings[2] = description;
    setupStrings[3] = version;
    setupStrings[4] = uri;
    setupStrings[5] = serial;

這裡我們在android的專案下資原始檔中建立一個xml資料夾。建立一個accessory_filter.xml檔案，檔案內容如下：

<!--?xml version="1.0" encoding="utf-8"?-->
<resources>
    <usb-accessory manufacturer="vonchenchen" model="android.usbaoa" version="0.1">
</usb-accessory></resources>
<!--
const char *vendor = "vonchenchen";
const char *model = "android.usbaoa";
const char *description = "Android Aoa Interface";
const char *version = "0.1";
const char *uri = "https://www.baidu.com/";
const char *serial = "1234567890";
-->

下面的註釋是c程式碼中對應的字串，manufacturer與vendor對應，model，version兩個量對應一樣，accessory就會被啟動起來。假如手機中沒有對應app，就會彈出對話方塊，選擇是否啟動瀏覽器，訪問uri對應的地址。對話方塊中的描述資訊就是description對應的字串。

總結

到此，Android通過AOA協議與嵌入式裝置通訊的流程就已經分析完了，在裝置端我們藉助了libusb庫，通過其api操作usb，將手機設定為accessory模式，然後通過libusb讀寫資料，在Android手機端監聽accessory事件，同時查詢本地accessory列表，一旦拿到accessory引用，就可以獲取讀寫流，同時Android
端最好將accessory的相關處理放在單獨程序的服務中處理，防止應用閃退導致usb資源無法釋放，在此連線無法成功的問題。