美文网首页
蓝牙的数据传输

蓝牙的数据传输

作者: 学android的小新 | 来源:发表于2016-06-13 18:04 被阅读454次

    我们可以将手机的蓝牙设置成客户端也可以是服务器端然后将两者之间绑定起来然后传递数据
    在传输数据的时候客户端和服务器端要有相同的UUID(必须是这个类似与网络传输中的IP地址)

    public static final String CONNECTTION_UUID = "00001101-0000-1000-8000-00805F9B34FB";
    

    客户端与服务器端分别开启两个线程
    服务器端

    package com.example.blue.connect;
    
    import android.bluetooth.BluetoothAdapter;
    import android.bluetooth.BluetoothServerSocket;
    import android.bluetooth.BluetoothSocket;
    import android.os.Handler;
    
    import java.io.IOException;
    import java.util.UUID;
    
    /**
     * Created by 小新 on 2016/6/11.
     */
    //服务器端线程
    public class AcceptThread extends Thread {
        private static final String NAME = "BlueToothClass";
        private static final UUID MY_UUID = UUID.fromString(Constant.CONNECTTION_UUID);
    
        private final BluetoothServerSocket mmServerSocket;
        private final BluetoothAdapter mBluetoothAdapter;
        private final Handler mHandler;
        private ConnectedThread mConnectedThread;
    
        public AcceptThread(BluetoothAdapter adapter, Handler handler) {
            // Use a temporary object that is later assigned to mmServerSocket,
            // because mmServerSocket is final
            mBluetoothAdapter = adapter;
            mHandler = handler;
            BluetoothServerSocket tmp = null;
            try {
                // MY_UUID is the app's UUID string, also used by the client code
                tmp = mBluetoothAdapter.listenUsingRfcommWithServiceRecord(NAME, MY_UUID);
            } catch (IOException e) { }
            mmServerSocket = tmp;
        }
    
        public void run() {
            BluetoothSocket socket = null;
            // Keep listening until exception occurs or a socket is returned
            while (true) {
                try {
                    mHandler.sendEmptyMessage(Constant.MSG_START_LISTENING);
                    socket = mmServerSocket.accept();
                } catch (IOException e) {
                    mHandler.sendMessage(mHandler.obtainMessage(Constant.MSG_ERROR, e));
                    break;
                }
                // If a connection was accepted
                if (socket != null) {
                    // Do work to manage the connection (in a separate thread)
                    manageConnectedSocket(socket);
                    try {
                        mmServerSocket.close();
                        mHandler.sendEmptyMessage(Constant.MSG_FINISH_LISTENING);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    break;
                }
            }
        }
    
        private void manageConnectedSocket(BluetoothSocket socket) {
            //只支持同时处理一个连接
            if( mConnectedThread != null) {
                mConnectedThread.cancel();
            }
            mHandler.sendEmptyMessage(Constant.MSG_GOT_A_CLINET);
            mConnectedThread = new ConnectedThread(socket, mHandler);
            mConnectedThread.start();
        }
    
        /** Will cancel the listening socket, and cause the thread to finish */
        public void cancel() {
            try {
                mmServerSocket.close();
                mHandler.sendEmptyMessage(Constant.MSG_FINISH_LISTENING);
            } catch (IOException e) { }
        }
    
        public void sendData(byte[] data) {
            if( mConnectedThread!=null){
                mConnectedThread.write(data);
            }
        }
    }
    

    客户端

    package com.example.blue.connect;
    
    import android.bluetooth.BluetoothAdapter;
    import android.bluetooth.BluetoothDevice;
    import android.bluetooth.BluetoothSocket;
    import android.os.Handler;
    
    import java.io.IOException;
    import java.util.UUID;
    
    /**
     * Created by 小新 on 2016/6/11. */
    public class ConnectThread extends Thread {
        private static final UUID MY_UUID = UUID.fromString(Constant.CONNECTTION_UUID);
        private final BluetoothSocket mmSocket;
        private final BluetoothDevice mmDevice;
        private BluetoothAdapter mBluetoothAdapter;
        private final Handler mHandler;
        private ConnectedThread mConnectedThread;
    
        public ConnectThread(BluetoothDevice device, BluetoothAdapter adapter, Handler handler) {
            // Use a temporary object that is later assigned to mmSocket,
            // because mmSocket is final
            BluetoothSocket tmp = null;
            mmDevice = device;
            mBluetoothAdapter = adapter;
            mHandler = handler;
            // Get a BluetoothSocket to connect with the given BluetoothDevice
            try {
                // MY_UUID is the app's UUID string, also used by the server code
                tmp = device.createRfcommSocketToServiceRecord(MY_UUID);
            } catch (IOException e) { }
            mmSocket = tmp;
        }
    
        public void run() {
            // Cancel discovery because it will slow down the connection
            mBluetoothAdapter.cancelDiscovery();
    
            try {
                // Connect the device through the socket. This will block
                // until it succeeds or throws an exception
                mmSocket.connect();
            } catch (Exception connectException) {
                mHandler.sendMessage(mHandler.obtainMessage(Constant.MSG_ERROR, connectException));
                // Unable to connect; close the socket and get out
                try {
                    mmSocket.close();
                } catch (IOException closeException) { }
                return;
            }
    
            // Do work to manage the connection (in a separate thread)
            manageConnectedSocket(mmSocket);
        }
    
        private void manageConnectedSocket(BluetoothSocket mmSocket) {
            mHandler.sendEmptyMessage(Constant.MSG_CONNECTED_TO_SERVER);
            mConnectedThread = new ConnectedThread(mmSocket, mHandler);
            mConnectedThread.start();
        }
    
        /** Will cancel an in-progress connection, and close the socket */
        public void cancel() {
            try {
                mmSocket.close();
            } catch (IOException e) { }
        }
    
        public void sendData(byte[] data) {
            if( mConnectedThread!=null){
                mConnectedThread.write(data);
            }
        }
    }
    

    发送数据接收数据

    package com.example.blue.connect;
    
    import android.bluetooth.BluetoothSocket;
    import android.os.Handler;
    import android.os.Message;
    import android.util.Log;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    
    /**
     * Created by 小新 on 2016/6/11.
     */
    public class ConnectedThread extends Thread {
        private final BluetoothSocket mmSocket;
        private final InputStream mmInStream;
        private final OutputStream mmOutStream;
        private final Handler mHandler;
    
        public ConnectedThread(BluetoothSocket socket, Handler handler) {
            mmSocket = socket;
            InputStream tmpIn = null;
            OutputStream tmpOut = null;
            mHandler = handler;
            // Get the input and output streams, using temp objects because
            // member streams are final
            try {
                tmpIn = socket.getInputStream();
                tmpOut = socket.getOutputStream();
            } catch (IOException e) { }
    
            mmInStream = tmpIn;
            mmOutStream = tmpOut;
        }
    
    
        public void run() {
            byte[] buffer = new byte[1024];  // buffer store for the stream
            int bytes; // bytes returned from read()
    
            // Keep listening to the InputStream until an exception occurs
            //一直读数据
            while (true) {
                try {
    
                    // Read from the InputStream
                    bytes = mmInStream.read(buffer);
                    // Send the obtained bytes to the UI activity
                    if( bytes >0) {
                        Message message = mHandler.obtainMessage(Constant.MSG_GOT_DATA, new String(buffer, 0, bytes, "utf-8"));
                        mHandler.sendMessage(message);
                    }
                    Log.d("GOTMSG", "message size" + bytes);
                } catch (IOException e) {
                    mHandler.sendMessage(mHandler.obtainMessage(Constant.MSG_ERROR, e));
                    break;
                }
            }
        }
    
        /* Call this from the main activity to send data to the remote device */
        //发送数据
        public void write(byte[] bytes) {
            try {
                mmOutStream.write(bytes);
            } catch (IOException e) { }
        }
    
        /* Call this from the main activity to shutdown the connection */
        public void cancel() {
            try {
                mmSocket.close();
            } catch (IOException e) { }
        }
    }
    

    Demo地址:Demo地址

    相关文章

      网友评论

          本文标题:蓝牙的数据传输

          本文链接:https://www.haomeiwen.com/subject/eegedttx.html