android 蓝牙模块Bluetooth 使用十六进制数据发送

谁践踏了优雅 2024-02-17 21:59 34阅读 0赞

一个蓝牙模块看起来很小，弄起来还是有点复杂的，从网上找了一个示例代码，http://blog.csdn.net/vnanyesheshou/article/details/51554852但是不能直接用，需要自己进行阅读理解和修改后才能使用。

先贴一张自制的uml图：

![Center][]

从图中不难看出涉及的类还是挺多的，大致上分为设备初始化、建立连接、发送消息三个大致的步骤吧。网上的代码封装成了一个BluetoothChatUtil实用的类，负责建立通信和发送消息，然后通过消息的方式让界面显示获取到的数据。BroadcastReceiver负责接收蓝牙扫描时获取到的设备，由于项目中的目标蓝牙是已经绑定的，所以直接使用BluetoothAdapter类的getBondedDevices()函数来获取已经绑定的蓝牙设备，然后通过设定名称或者地址来进行连接。

为现有项目添加蓝牙模块的步骤大致如下（简单地从代码出发）：

（1）**增加成员变量：**

//获取消息的Handler

Handler mHandler;

//蓝牙模块

//待连接的蓝牙名称

publicstatic final String BLUETOOTH\_NAME = "XXXX";

//连接 msg

publicstatic final String OPEN\_BLUE\_HEX\_STRING = "00 00 00 00 ";

//关闭 msg

publicstatic final String CLOSE\_BLUE\_HEX\_STRING = "FF FF FF FF";

//待连接的蓝牙地址

privateString mBluetoothAddress = "XX:XX:XX:XX:XX:XX";

boolean hasregister = false;

private ProgressDialog mProgressDialog;

//蓝牙通信模块

privateBluetoothChatUtil mBlthChatUtil;

//当前activity的句柄

privateContext mContext;

privateint REQUEST\_ENABLE\_BT = 1;

(2)**onCreate中初始化：**

mContext = this;

mProgressDialog= new ProgressDialog(this);

**在handleMessage(Message msg)中捕获几个消息：**

//连接成功

caseBluetoothChatUtil.STATE\_CONNECTED:

if(mProgressDialog.isShowing())\{

mProgressDialog.dismiss();

StringdeviceName = msg.getData().getString(BluetoothChatUtil.DEVICE\_NAME);

//mBtnBluetoothConnect.setText("已成功连接到设备"+ deviceName);

Toast.makeText(getApplicationContext(),"连接成功："+deviceName, Toast.LENGTH\_SHORT).show();

//连接后就发送你需要发送的消息

sendBluetoothMessage(OPEN\_BLUE\_HEX\_STRING);

break;

//连接失败

caseBluetoothChatUtil.STATAE\_CONNECT\_FAILURE:

if(mProgressDialog.isShowing())\{

mProgressDialog.dismiss();

Toast.makeText(getApplicationContext(),"连接失败", Toast.LENGTH\_SHORT).show();

break;

//断开连接

caseBluetoothChatUtil.MESSAGE\_DISCONNECTED:

if(mProgressDialog.isShowing())\{

mProgressDialog.dismiss();

//mBtnBluetoothConnect.setText("与设备断开连接");

break;

//收到消息

caseBluetoothChatUtil.MESSAGE\_READ:

byte\[\]buf = msg.getData().getByteArray(BluetoothChatUtil.READ\_MSG);

Stringstr = new String(buf,0,buf.length);

Toast.makeText(getApplicationContext(),"读成功" + str, Toast.LENGTH\_SHORT).show();

break;

**实例化通信模块，并连接蓝牙：**

//蓝牙模块

mBlthChatUtil= BluetoothChatUtil.getInstance(mContext);

mBlthChatUtil.registerHandler(mHandler);

initBluetooth();

//根据自己的需求来选择需不需要扫描设备

//mBluetoothAdapter.startDiscovery();

//连接设备

connect();

if (mBlthChatUtil.getState() == BluetoothChatUtil.STATE\_NONE) \{

//启动蓝牙聊天服务

mBlthChatUtil.start();

**蓝牙初始化函数initBluetooth()和connect函数：**

private void initBluetooth() \{

mBluetoothAdapter= BluetoothAdapter.getDefaultAdapter();

if(mBluetoothAdapter == null) \{//设备不支持蓝牙

Toast.makeText(getApplicationContext(),"设备不支持蓝牙", Toast.LENGTH\_LONG).show();

finish();

return;

//判断蓝牙是否开启

if(!mBluetoothAdapter.isEnabled()) \{//蓝牙未开启

IntentenableIntent = new Intent(

BluetoothAdapter.ACTION\_REQUEST\_ENABLE);

startActivityForResult(enableIntent,REQUEST\_ENABLE\_BT);

//开启蓝牙

mBluetoothAdapter.enable();

IntentFilterfilter = new IntentFilter();

filter.addAction(BluetoothDevice.ACTION\_FOUND);

filter.addAction(BluetoothAdapter.ACTION\_DISCOVERY\_FINISHED);

//registerReceiver(mBluetoothReceiver,filter);

//hasregister= true;

if(mBluetoothAdapter.isEnabled()) \{

intnMode = mBluetoothAdapter.getScanMode();

if(nMode== BluetoothAdapter.SCAN\_MODE\_CONNECTABLE)\{

Log.e(TAG\_BLUE,"getScanMode= SCAN\_MODE\_CONNECTABLE");

if(nMode== BluetoothAdapter.SCAN\_MODE\_NONE)\{

Log.e(TAG\_BLUE,"getScanMode= SCAN\_MODE\_NONE");

if(nMode== BluetoothAdapter.SCAN\_MODE\_CONNECTABLE\_DISCOVERABLE)\{

Log.e(TAG\_BLUE,"getScanMode= SCAN\_MODE\_CONNECTABLE\_DISCOVERABLE");

//if(nMode == BluetoothAdapter.SCAN\_MODE\_CONNECTABLE\_DISCOVERABLE) \{

// IntentdiscoverableIntent = new Intent(BluetoothAdapter.ACTION\_REQUEST\_DISCOVERABLE);

//  discoverableIntent.putExtra(BluetoothAdapter.EXTRA\_DISCOVERABLE\_DURATION,300);

// startActivity(discoverableIntent);

//\}

//本身蓝牙的名称和地址

Stringname = mBluetoothAdapter.getName();

Stringaddress = mBluetoothAdapter.getAddress();

Log.d(TAG\_BLUE,"bluetoothname ="+name+" address ="+address);

publicvoid connect() \{

Set<BluetoothDevice>device = mBluetoothAdapter.getBondedDevices();

if(device.size()>0)\{ //存在已经配对过的蓝牙设备

for(Iterator<BluetoothDevice>it=device.iterator();it.hasNext();)\{

BluetoothDevicebtd=it.next();

String name = btd.getName();

String address =btd.getAddress();

String nameString =btd.getName()+'\\n'+btd.getAddress();

Log.e(TAG\_BLUE,"getBondedDevices :" + nameString);

//if(name != null &&name.equals(BLUETOOTH\_NAME))\{

if(address != null &&address.equals(mBluetoothAddress))\{

mBlthChatUtil.connect(btd);

break;

//Toast.makeText(mContext,"连接成功", Toast.LENGTH\_SHORT).show();

\}else\{ //不存在已经配对过的蓝牙设备

Log.e(TAG,"No can bematched to use bluetooth");

**十六进制数据转换**HexCommandtoByte**和消息发送函数**sendBluetoothMessage**：**

// 十六进制的字符串转换成byte数组

public static byte\[\]HexCommandtoByte(byte\[\] data) \{

if (data == null) \{

return null;

int nLength = data.length;

String strTemString = new String(data, 0, nLength);

String\[\] strings = strTemString.split(" ");

nLength = strings.length;

data = new byte\[nLength\];

for (int i = 0; i < nLength; i++) \{

if (strings\[i\].length() != 2) \{

data\[i\] = 00;

continue;

try \{

data\[i\] =(byte)Integer.parseInt(strings\[i\], 16);

\} catch (Exception e) \{

data\[i\] = 00;

continue;

return data;

public void sendBluetoothMessage(Stringmessagesend)\{

Log.e(TAG\_BLUE,"sendmessage : " + messagesend);

byte\[\] sendByte =HexCommandtoByte(messagesend.getBytes());

//mBlthChatUtil.write(messagesend.getBytes());

mBlthChatUtil.write(sendByte);

**(3)在返回onBackPressed()或者onDestroy()发送关闭蓝牙消息，并注销蓝牙：**

//关闭

sendBluetoothMessage(CLOSE\_BLUE\_HEX\_STRING);

if(mBluetoothAdapter!=null &&mBluetoothAdapter.isDiscovering())\{

mBluetoothAdapter.cancelDiscovery();

if (mBlthChatUtil.getState() !=BluetoothChatUtil.STATE\_CONNECTED) \{

Toast.makeText(mContext,"蓝牙未连接", Toast.LENGTH\_SHORT).show();

\}else \{

mBlthChatUtil.stop();

BluetoothChatUtil.java内容如下：

package XXX;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.util.UUID;
    import android.bluetooth.BluetoothAdapter;
    import android.bluetooth.BluetoothDevice;
    import android.bluetooth.BluetoothServerSocket;
    import android.bluetooth.BluetoothSocket;
    import android.content.Context;
    import android.os.Bundle;
    import android.os.Handler;
    import android.os.Message;
    import android.util.Log;
    
    /**
     这类做所有的工作，建立和管理蓝牙
    *连接其他装置。它有一个线程，监听
    *传入连接，螺纹连接装置，和一个
    *执行数据传输线连接时。
     */
    public class BluetoothChatUtil {
        // 调试
        private static final String TAG = "BluetoothChatService";
        private static final boolean D = true;
    
        // 名社民党记录当创建服务器套接字
        private static final String NAME = "BluetoothChat";
        									 				
        private static final UUID MY_UUID = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");
    	public static StringBuffer hexString = new StringBuffer();
        // 适配器成员
        private final BluetoothAdapter mAdapter;
        private Handler mHandler;
        private AcceptThread mAcceptThread;
        private ConnectThread mConnectThread;
        private ConnectedThread mConnectedThread;
        private int mState;
    	private static BluetoothChatUtil mBluetoothChatUtil;
    	private BluetoothDevice mConnectedBluetoothDevice;
        //常数，指示当前的连接状态
        public static final int STATE_NONE = 0;       // 当前没有可用的连接
        public static final int STATE_LISTEN = 1;     // 现在侦听传入的连接
        public static final int STATE_CONNECTING = 2; // 现在开始传出联系
        public static final int STATE_CONNECTED = 3;  // 现在连接到远程设备
        public static final int STATAE_CONNECT_FAILURE = 4;
        public static boolean bRun = true;
        public static final int MESSAGE_DISCONNECTED = 5;
        public static final int STATE_CHANGE = 6;
        public static final String DEVICE_NAME = "device_name";
        public static final int MESSAGE_READ = 7;
        public static final int MESSAGE_WRITE= 8;
        public static final String READ_MSG = "read_msg";
        /**
         * 构造函数。准备一个新的bluetoothchat会话。
         * @param context  用户界面活动的背景
         */
        private BluetoothChatUtil(Context context) {
            mAdapter = BluetoothAdapter.getDefaultAdapter();
            mState = STATE_NONE;       
        }
    
        public static BluetoothChatUtil getInstance(Context c){
        	if(null == mBluetoothChatUtil){
        		mBluetoothChatUtil = new BluetoothChatUtil(c);
        	}
        	return mBluetoothChatUtil;
        }
        public void registerHandler(Handler handler){
        	mHandler = handler;
        }
        
        public void unregisterHandler(){
        	mHandler = null;
        }
        /**
         * 设置当前状态的聊天连接
         * @param state  整数定义当前连接状态
         */
        private synchronized void setState(int state) {
            if (D) Log.d(TAG, "setState() " + mState + " -> " + state);
            mState = state;
            // 给新状态的处理程序，界面活性可以更新
            mHandler.obtainMessage(STATE_CHANGE, state, -1).sendToTarget();
        }
    
        /**
         * 返回当前的连接状态。 */
        public synchronized int getState() {
            return mState;
        }
        
        public BluetoothDevice getConnectedDevice(){
        	return mConnectedBluetoothDevice;
        }
        /**
         * 开始聊天服务。特别acceptthread开始    开始
         * 会话听力（服务器）模式。所谓的活动onresume() */
        public synchronized void start() {
            if (D) Log.d(TAG, "start");
            //取消任何线程试图建立连接
            if (mConnectThread != null) {mConnectThread.cancel(); mConnectThread = null;}
            // 取消任何线程正在运行的连接
            if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread = null;}
            // 启动线程来听一个bluetoothserversocket
            if (mAcceptThread == null) {
                mAcceptThread = new AcceptThread();
                mAcceptThread.start();
            }
            setState(STATE_LISTEN);
        }
       
        //连接按键响应函数
        /**
         * 开始connectthread启动连接到远程设备。
         * @param 装置连接的蓝牙设备
         */
        public synchronized void connect(BluetoothDevice device) {
            if (D) Log.d(TAG, "connect to: " + device);
            // 取消任何线程试图建立连接
            if (mState == STATE_CONNECTING) {
                if (mConnectThread != null) {mConnectThread.cancel(); mConnectThread = null;}
            }
            // 取消任何线程正在运行的连接
            if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread = null;}
    
            //启动线程连接的设备
            mConnectThread = new ConnectThread(device);
            mConnectThread.start();
            setState(STATE_CONNECTING);
        }
    
        /**
         * 开始connectedthread开始管理一个蓝牙连接
         * @param bluetoothsocket插座上连接了
         * @param 设备已连接的蓝牙设备
         */
        @SuppressWarnings("unused")
    	public synchronized void connected(BluetoothSocket socket, BluetoothDevice device) {
            if (D) Log.d(TAG, "connected");
            // 取消线程完成连接
            if (mConnectThread != null) {mConnectThread.cancel(); mConnectThread = null;}
            //取消任何线程正在运行的连接
            if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread = null;}
    
            // 取消接受线程只因为我们要连接到一个设备
            if (mAcceptThread != null) {mAcceptThread.cancel(); mAcceptThread = null;}
    
            // 启动线程管理连接和传输
            mConnectedThread = new ConnectedThread(socket);
            mConnectedThread.start();
            //把名字的连接设备到Activity
            mConnectedBluetoothDevice =  device;
            Message msg = mHandler.obtainMessage(STATE_CONNECTED);
            Bundle bundle = new Bundle();
            bundle.putString(DEVICE_NAME, device.getName());
            msg.setData(bundle);
            mHandler.sendMessage(msg);
            setState(STATE_CONNECTED);
           }
    
        /**
         * 停止所有的线程
         */
        public synchronized void stop() {
            if (D) Log.d(TAG, "stop");
            if (mConnectThread != null) {mConnectThread.cancel(); mConnectThread = null;}
            if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread = null;}
            if (mAcceptThread != null) {mAcceptThread.cancel(); mAcceptThread = null;}
            setState(STATE_NONE);
            //start();
        }
    
        /**
         * Write to the ConnectedThread in an unsynchronized manner
         * @param out The bytes to write
         * @see ConnectedThread#write(byte[])
         */
        public void write(byte[] out) {
            //创建临时对象
            ConnectedThread r;
            // 同步副本的connectedthread
            synchronized (this) {
                if (mState != STATE_CONNECTED) return;
                r = mConnectedThread;
            }
            // 执行写同步
            r.write(out);
        }
    
        /**
         * Indicate that the connection attempt failed and notify the UI Activity.
         */
        private void connectionFailed() {
            setState(STATE_LISTEN);
            // 发送失败的信息带回活动
            Message msg = mHandler.obtainMessage(STATAE_CONNECT_FAILURE);
            mHandler.sendMessage(msg);
            mConnectedBluetoothDevice = null;
        }
    
        /**
         * Indicate that the connection was lost and notify the UI Activity.
         */
        private void connectionLost() {
            setState(STATE_LISTEN);
            // 发送失败的信息带回Activity
            Message msg = mHandler.obtainMessage(MESSAGE_DISCONNECTED);
            mHandler.sendMessage(msg);
            mConnectedBluetoothDevice = null;
            stop();
        }
    
        /**
        *本线同时侦听传入的连接。它的行为
        *喜欢一个服务器端的客户端。它运行直到连接被接受
        *（或取消）。
         */
        private class AcceptThread extends Thread {
            // 本地服务器套接字
            private final BluetoothServerSocket mServerSocket;
            public AcceptThread() {       	
                BluetoothServerSocket tmp = null;
                // 创建一个新的侦听服务器套接字
                try {
                    tmp = mAdapter.listenUsingRfcommWithServiceRecord(NAME, MY_UUID);
                } catch (IOException e) {
                    Log.e(TAG, "listen() failed", e);
                }
                mServerSocket = tmp;
            }
    
            public void run() {
                if (D) Log.d(TAG, "BEGIN mAcceptThread" + this);
                setName("AcceptThread");
                BluetoothSocket socket = null;
                // 循环，直到连接成功
                while (mState != STATE_CONNECTED) {
                    try {
                        // 这是一个阻塞调用和将只返回一个
                        // 成功的连接或例外
                        socket = mServerSocket.accept();
                    } catch (IOException e) {
                        Log.e(TAG, "accept() failed", e);
                        break;
                    }
                    // 如果连接被接受
                    if (socket != null) {
                        synchronized (BluetoothChatUtil.this) {
                            switch (mState) {
                            case STATE_LISTEN:
                            case STATE_CONNECTING:
                                // 正常情况。启动连接螺纹。
                                connected(socket, socket.getRemoteDevice());
                                break;
                            case STATE_NONE:
                            case STATE_CONNECTED:
                                // 没有准备或已连接。新插座终止。
                                try {
                                    socket.close();
                                } catch (IOException e) {
                                    Log.e(TAG, "Could not close unwanted socket", e);
                                }
                                break;
                            }
                        }
                    }
                }
                if (D) Log.i(TAG, "END mAcceptThread");
            }
    
            public void cancel() {
                if (D) Log.d(TAG, "cancel " + this);
                try {
                    mServerSocket.close();
                } catch (IOException e) {
                    Log.e(TAG, "close() of server failed", e);
                }
            }
        }
    
    
        /**
         * 本线在试图使传出联系
         *与设备。它径直穿过连接；或者
         *成功或失败。
         */
        private class ConnectThread extends Thread {
            private BluetoothSocket mmSocket;
            private final BluetoothDevice mmDevice;
            public ConnectThread(BluetoothDevice device) {
                mmDevice = device;
                BluetoothSocket tmp = null;
                // 得到一个bluetoothsocket
                try {
                	mmSocket = device.createRfcommSocketToServiceRecord(MY_UUID);
                } catch (IOException e) {
                    Log.e(TAG, "create() failed", e);
                    mmSocket = null;
                }
            }
    
            public void run() {
                Log.i(TAG, "BEGIN mConnectThread");
                setName("ConnectThread");
                mAdapter.cancelDiscovery();
                // 使一个连接到bluetoothsocket
                try {
                    // socket 连接
                    mmSocket.connect();
                } catch (IOException e) {
                    connectionFailed();
                    //关闭这个socket
                    try {
                        mmSocket.close();
                    } catch (IOException e2) {
                        Log.e(TAG, "unable to close() socket during connection failure", e2);
                    }
                    // 启动服务在重新启动聆听模式
                    BluetoothChatUtil.this.start();
                    return;
                }
                // 因为我们所做的connectthread复位
                synchronized (BluetoothChatUtil.this) {
                    mConnectThread = null;
                }
                // 启动连接线程
                connected(mmSocket, mmDevice);
            }
    
            public void cancel() {
                try {
                    mmSocket.close();
                } catch (IOException e) {
                    Log.e(TAG, "close() of connect socket failed", e);
                }
            }
        }
    
        /**
         * 本线在连接与远程设备。
         * 它处理所有传入和传出的传输。
         */
        private class ConnectedThread extends Thread {
            private final BluetoothSocket mmSocket;
            private final InputStream mmInStream;
            private final OutputStream mmOutStream;
            
            public ConnectedThread(BluetoothSocket socket) {
                Log.d(TAG, "create ConnectedThread");
                mmSocket = socket;
                InputStream tmpIn = null;
                OutputStream tmpOut = null;
                // 获得bluetoothsocket输入输出流
                try {
                    tmpIn = socket.getInputStream();
                    tmpOut = socket.getOutputStream();
                } catch (IOException e) {
                    Log.e(TAG, "没有创建临时sockets", e);
                }
                mmInStream = tmpIn;
                mmOutStream = tmpOut;
            }  
           
            public void run() {
                Log.i(TAG, "BEGIN mConnectedThread");
                int bytes;
                // 继续听InputStream同时连接
                while (true) {
                    try {
                    	 byte[] buffer = new byte[1024];
                        // 读取输入流
                        bytes = mmInStream.read(buffer);
    
                        // 发送获得的字节的用户界面
                        Message msg = mHandler.obtainMessage(MESSAGE_READ);
                        Bundle bundle = new Bundle();
                        bundle.putByteArray(READ_MSG, buffer);
                        msg.setData(bundle);
                        mHandler.sendMessage(msg);          
                    } catch (IOException e) {
                        Log.e(TAG, "disconnected", e);
                        connectionLost();
                        break;
                    }
                }
           }
            /**
             * 写输出的连接。
             * @param buffer  这是一个字节流
             */
            public void write(byte[] buffer) {
                try {
                    mmOutStream.write(buffer);
                    // 分享发送的信息到Activity
                    mHandler.obtainMessage(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);
                }
            }
        }
    }

自己修改后的代码下载地址是：http://download.csdn.net/detail/u200814342a/9839396，记得要改一下连接的蓝牙地址或者名称！

[Center]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/03f458a8f9ae4e0fb9dff2f225e9869f.png