Google官网蓝牙通信模块BluetoothChatService类分析与使用

来源：互联网发布：云服务百度计算编辑：程序博客网时间：2024/06/08 18:17

BluetoothChatService类包含了三个Thread的内部类：
· AcceptThread类：监听来自其他设备的蓝牙连接（ This thread runs while listening for incoming connections. It behaves like a server-side client. It runs until a connection is accepted (or until cancelled).）

· ConnectThread类：这个线程运行时试图做一个外向的连接一个设备。（This thread runs while attempting to make an outgoing connection with a device. It runs straight through; the connection either succeeds or fails.）

· ConnectedThread类：当两个设备连接时这个线程开始运行。它处理所有传入和传出的传输。（This thread runs during a connection with a remote device. It handles all incoming and outgoing transmissions.）

接下来依次分析三个类：
AcceptThread类：在构造函数里，首先获得 BluetoothServerSocket ；BluetoothServerSocket 官方介绍说是一个监听蓝牙socket 的接口，在服务器端，使用BluetoothServerSocket创建监听套接字服务器。当连接被接受BluetoothServerSocket时，它将返回一个新的BluetoothSocket来管理连接。在客户端（在ConnectThread类终将会用到），使用单个BluetoothSocket到两个发起传出连接并管理连接。通过BluetoothServerSocket 可以通过它的accept()得到一个BluetoothSocket对象socket ，在要得到socket 之前首先判断蓝牙socket是否已经连接，因为该蓝牙通讯模块只允许与一个设备通讯。拿到socket，此时两个设备已经连接了，所以接下开启ConnectedThread线程监听通讯，调用connected(socket,socket.getRemoteDevice(),mSocketType)方法。AcceptThread类主要功能就这些，对了还有cancel()方法，它主要是关闭BluetoothServerSocket ，因为当我们拿到socket之后，我们不需要在监听接受一个连接，而且BluetoothServerSocket 的accept()方法会被阻塞，直到连接建立，所以要记得关闭BluetoothServerSocket 。

private class AcceptThread extends Thread {        // The local server socket        private final BluetoothServerSocket mmServerSocket;        private String mSocketType;        public AcceptThread(boolean secure) {            BluetoothServerSocket tmp = null;            mSocketType = secure ? "Secure" : "Insecure";            // Create a new listening server socket            try {                if (secure) {                    tmp = mAdapter.listenUsingRfcommWithServiceRecord(NAME_SECURE,                            MY_UUID_SECURE);                } else {                    tmp = mAdapter.listenUsingInsecureRfcommWithServiceRecord(                            NAME_INSECURE, MY_UUID_INSECURE);                }            } catch (IOException e) {            }            mmServerSocket = tmp;        }        public void run() {            Log.e(TAG, "Socket Type: " + mSocketType + " BEGIN mAcceptThread" + this);            setName("AcceptThread" + mSocketType);            BluetoothSocket socket = null;            // Listen to the server socket if we're not connected            while (mState != STATE_CONNECTED) {                try {                    // This is a blocking call and will only return on a                    // successful connection or an exception                    socket = mmServerSocket.accept();                } catch (IOException e) {                    Log.e(TAG, String.valueOf(e));                    break;                }                // If a connection was accepted                if (socket != null) {                    synchronized (BluetoothChatService.this) {                        switch (mState) {                            case STATE_LISTEN:                            case STATE_CONNECTING:                                // Situation normal. Start the connected thread.                                connected(socket, socket.getRemoteDevice(),                                        mSocketType);                                break;                            case STATE_NONE:                            case STATE_CONNECTED:                                // Either not ready or already connected. Terminate new socket.                                try {                                    socket.close();                                } catch (IOException e) {                                    Log.e(TAG, "Could not close unwanted socket", e);                                }                                break;                        }                    }                }            }            Log.e(TAG, "END mAcceptThread, socket Type: " + mSocketType);        }        public void cancel() {            Log.d(TAG, "Socket Type" + mSocketType + "cancel " + this);            try {                mmServerSocket.close();            } catch (IOException e) {                Log.e(TAG, "Socket Type" + mSocketType + "close() of server failed", e);            }        }    }

ConnectThread类：这个比较简单，首先它会通过UUID获得一个socket，再通过BluetoothSocket类的connect()方法进行通信连接，切记在调用connect()方法是一定不要忘记BluetoothAdapter.cancelDiscovery();否则哼哼……后果你可以试试。，这一部分直接上代码：

private class ConnectThread extends Thread {        private final BluetoothSocket mmSocket;        private final BluetoothDevice mmDevice;        private String mSocketType;        public ConnectThread(BluetoothDevice device, boolean secure) {            mmDevice = device;            BluetoothSocket tmp = null;            mSocketType = secure ? "Secure" : "Insecure";            // Get a BluetoothSocket for a connection with the            // given BluetoothDevice            try {                if (secure) {                    tmp = device.createRfcommSocketToServiceRecord(                            MY_UUID_SECURE);                } else {                    tmp = device.createInsecureRfcommSocketToServiceRecord(                            MY_UUID_INSECURE);                }            } catch (IOException e) {                Log.e(TAG, "Socket Type: " + mSocketType + " create() failed", e);            }            mmSocket = tmp;        }        public void run() {            Log.e(TAG, "BEGIN mConnectThread SocketType:" + mSocketType);            setName("ConnectThread" + mSocketType);            // Always cancel discovery because it will slow down a connection            mAdapter.cancelDiscovery();            // Make a connection to the BluetoothSocket            try {                // This is a blocking call and will only return on a                // successful connection or an exception                mmSocket.connect();            } catch (IOException e) {                // Close the socket                try {                    mmSocket.close();                } catch (IOException e2) {                    Log.e(TAG, "unable to close() " + mSocketType +                            " socket during connection failure", e2);                }                //表明,该连接请求失败并通知UI,不用关心。                connectionFailed();                return;            }            // Reset the ConnectThread because we're done            synchronized (BluetoothChatService.this) {                mConnectThread = null;            }            // 开启连接之后的线程，这个方法在AcceptThread类中也有使用。             connected(mmSocket, mmDevice, mSocketType);        }        public void cancel() {            try {                mmSocket.close();            } catch (IOException e) {                Log.e(TAG, "close() of connect " + mSocketType + " socket failed", e);            }        }    }

ConnectedThread类：它的主要功能是接收和发送数据，首先通过AcceptThread类和ConnectThread类得到的socket获得InputStream，OutputStream，这两个类就不用我说了吧！然后在run()方法中通过while语句一直监听收到的数据，而write()方法是发送数据。这两个方法都通过handler发送到UI，当然你也可以同过回调。代码如下：

 private class ConnectedThread extends Thread {        private final BluetoothSocket mmSocket;        private final InputStream mmInStream;        private final OutputStream mmOutStream;        public ConnectedThread(BluetoothSocket socket, String socketType) {            Log.e(TAG, "create ConnectedThread: " + socketType);            mmSocket = socket;            InputStream tmpIn = null;            OutputStream tmpOut = null;            // Get the BluetoothSocket input and output streams            try {                tmpIn = socket.getInputStream();                tmpOut = socket.getOutputStream();            } catch (IOException e) {                Log.e(TAG, "temp sockets not created", e);            }            mmInStream = tmpIn;            mmOutStream = tmpOut;        }        public void run() {            Log.i(TAG, "BEGIN mConnectedThread");            byte[] buffer = new byte[1024];            int bytes;            // Keep listening to the InputStream while connected            while (mState == STATE_CONNECTED) {                try {                    // Read from the InputStream                    bytes = mmInStream.read(buffer);                    // Send the obtained bytes to the UI Activity                    mHandler.obtainMessage(Constants.MESSAGE_READ, bytes, -1, buffer)                            .sendToTarget();                } catch (IOException e) {                    Log.e(TAG, "disconnected", e);                    connectionLost();                    // Start the service over to restart listening mode                    BluetoothChatService.this.start();                    break;                }            }        }        /**         * Write to the connected OutStream.         *         * @param buffer The bytes to write         */        public void write(byte[] buffer) {            try {                mmOutStream.write(buffer);                // Share the sent message back to the UI Activity                mHandler.obtainMessage(Constants.MESSAGE_WRITE, -1, -1, buffer)                        .sendToTarget();            } catch (IOException e) {                Log.e(TAG, "Exception during write", e);            }        }        public void cancel() {            try {                mmSocket.close();            } catch (IOException e) {                Log.e(TAG, "close() of connect socket failed", e);            }        }    }

这三个内部方法都很容易理解，接下来看看它的使用流程，我们从它的state来捋一捋。它定义了四个状态

    public static final int STATE_NONE = 0;       // we're doing nothing    public static final int STATE_LISTEN = 1;     // now listening for incoming connections    public static final int STATE_CONNECTING = 2; // now initiating an outgoing connection    public static final int STATE_CONNECTED = 3;  // now connected to a remote device

初始化时state为 STATE_NONE
初始化完成后我们要调用它的start()方法开启AcceptThread监听来自其他设备的连接请求，此时state为 STATE_LISTEN
此时将分两种情况：①主动连接其他设备，则调用它的connect()方法，开启ConnectThread线程，此时state为 STATE_CONNECTING ，当连接成功后，调用它的connected()方法，在此方法中将开启ConnectedThread线程，并通知UI连接设备的名字，设置state为 STATE_CONNECTED 。②监听其他设备的连接请求，则是在第2步之后，在监听有设备请求socket连接后，把获得到socket通过调用它的connected()方法传递给ConnectedThread类，之后的流程和①一样，可以看出②整个过程没有state为 STATE_CONNECTING 状态，只有STATE_NONE 、STATE_LISTEN 、STATE_CONNECTED 。

下面是start()、connect()、connected()、stop()源码：

 /**     * Start the chat service. Specifically start AcceptThread to begin a     * session in listening (server) mode. Called by the Activity onResume()     */    public synchronized void start() {        // Cancel any thread attempting to make a connection        if (mConnectThread != null) {            mConnectThread.cancel();            mConnectThread = null;        }        // Cancel any thread currently running a connection        if (mConnectedThread != null) {            mConnectedThread.cancel();            mConnectedThread = null;        }        setState(STATE_LISTEN);        // Start the thread to listen on a BluetoothServerSocket        if (mSecureAcceptThread == null) {            mSecureAcceptThread = new AcceptThread(true);            mSecureAcceptThread.start();        }        if (mInsecureAcceptThread == null) {            mInsecureAcceptThread = new AcceptThread(false);            mInsecureAcceptThread.start();        }    }    /**     * Start the ConnectThread to initiate a connection to a remote device.     *     * @param device The BluetoothDevice to connect     * @param secure Socket Security type - Secure (true) , Insecure (false)     */    public synchronized void connect(BluetoothDevice device, boolean secure) {        // Cancel any thread attempting to make a connection        if (mState == STATE_CONNECTING) {            if (mConnectThread != null) {                mConnectThread.cancel();                mConnectThread = null;            }        }        // Cancel any thread currently running a connection        if (mConnectedThread != null) {            mConnectedThread.cancel();            mConnectedThread = null;        }        // Start the thread to connect with the given device        mConnectThread = new ConnectThread(device, secure);        mConnectThread.start();        setState(STATE_CONNECTING);    }    /**     * Start the ConnectedThread to begin managing a Bluetooth connection     *     * @param socket The BluetoothSocket on which the connection was made     * @param device The BluetoothDevice that has been connected     */    public synchronized void connected(BluetoothSocket socket, BluetoothDevice            device, final String socketType) {        // Cancel the thread that completed the connection        if (mConnectThread != null) {            mConnectThread.cancel();            mConnectThread = null;        }        // Cancel any thread currently running a connection        if (mConnectedThread != null) {            mConnectedThread.cancel();            mConnectedThread = null;        }        // Cancel the accept thread because we only want to connect to one device        if (mSecureAcceptThread != null) {            mSecureAcceptThread.cancel();            mSecureAcceptThread = null;        }        if (mInsecureAcceptThread != null) {            mInsecureAcceptThread.cancel();            mInsecureAcceptThread = null;        }        // Start the thread to manage the connection and perform transmissions        mConnectedThread = new ConnectedThread(socket, socketType);        mConnectedThread.start();        // Send the name of the connected device back to the UI Activity        Message msg = mHandler.obtainMessage(Constants.MESSAGE_DEVICE_NAME);        Bundle bundle = new Bundle();        bundle.putString(Constants.DEVICE_NAME, device.getName());        msg.setData(bundle);        mHandler.sendMessage(msg);        setState(STATE_CONNECTED);    }    /**     * Stop all threads     */    public synchronized void stop() {        if (mConnectThread != null) {            mConnectThread.cancel();            mConnectThread = null;        }        if (mConnectedThread != null) {            mConnectedThread.cancel();            mConnectedThread = null;        }        if (mSecureAcceptThread != null) {            mSecureAcceptThread.cancel();            mSecureAcceptThread = null;        }        if (mInsecureAcceptThread != null) {            mInsecureAcceptThread.cancel();            mInsecureAcceptThread = null;        }        setState(STATE_NONE);    }

0 0