ANDROID经典蓝牙通讯
最近写了一个关于蓝牙的操作类，对蓝牙不熟悉的同学可以参考一下 功能包括 发现，搜索，连接，发送，接收等/ 直接上代码：
package com.***.****.BlueToothM;
import android.app.Activity;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothManager;
import android.bluetooth.BluetoothSocket;
import android.content.Context;
import android.content.Intent;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import com.***.***.utils.LogUtil;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.UUID;
/**
* Created by bysd-2 on 2018/10/19.
*/
public class BlueToothHelper {
public static final int REQUEST_BLUE_ENABLE = 110;
private static Context mContext;
private static BluetoothAdapter bluetoothAdapter;
private static String UUID_STR = "00001101-0000-1000-8000-00805F9B34FB";
public static CURR_STATUS curr_status;
private static ConnectThread connectThread;
private static ReadThread readThread;
private static SendThread sendThread;
private static Handler queueMsg;
public enum CURR_STATUS {
CONNECTED, DISCONNECTED
}
// 初始化 这里需要注意是蓝牙如果没有开启则要开启后 在activity回调里再次获取发现搜索一下设备；
public static BluetoothAdapter initBlueTooth(Context context, Activity currActivity) {
mContext = context;
BluetoothManager bluetoothManager = (BluetoothManager) context.getSystemService(Context.BLUETOOTH_SERVICE);
bluetoothAdapter = bluetoothManager.getAdapter();
if (bluetoothAdapter != null) {
if (!bluetoothAdapter.isEnabled()) {
Intent intent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
// intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
currActivity.startActivityForResult(intent, REQUEST_BLUE_ENABLE);
}
return bluetoothAdapter;
} else {
return null;
}
}
// 初始化后可以调用此方法，还有在activity回调成功时调用； 此处还需要一个广播来接收相应的消息，这个广播我稍后发出来 ，广播其实也可以放到此工具类里，我只是分出来了，放到这个工具类里好处时各个状态比较好监听，放到外面则需要两个监听，有些多余；
public static void startDiscover() {
if (bluetoothAdapter != null) {
if (bluetoothAdapter.isDiscovering()) {
bluetoothAdapter.cancelDiscovery();
bluetoothAdapter.startDiscovery();
} else {
bluetoothAdapter.startDiscovery();
}
}
}
// 这个在连接之前，扫描设备超时的时候调用；节省资源；
public static void cancelDiscover() {
if (bluetoothAdapter != null) {
bluetoothAdapter.cancelDiscovery();
}
}
// 退出的时候调用，释放及重置
public static void close() {
if (bluetoothSocket != null) {
try {
bluetoothSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (bluetoothAdapter != null) {
bluetoothAdapter = null;
}
if (connectThread != null) {
connectThread = null;
}
if (readThread != null) {
readThread = null;
}
if (sendThread != null) {
sendThread = null;
}
//
curr_status = CURR_STATUS.DISCONNECTED;
}
// 连接时的回调； 里面加了一个接收数据的回调；
public static IConnectListener iConnectListener;
public interface IConnectListener {
void connectDevSuccess();//连接成功；
void connectDevFail(String exception); // 连接出错；
void dataRespon(byte[] bytes); // 接收
}
// connect
public static void connectDevice(IConnectListener l, BluetoothDevice device) {
iConnectListener = l;
//
if (connectThread == null) {
connectThread = new ConnectThread(device);
connectThread.start();
} else {
LogUtil.e(TAG, "connectThread != null");
}
}
private static final String TAG = BlueToothHelper.class.getSimpleName();
//
private static InputStream inS = null;
private static OutputStream outs = null;
private static BluetoothSocket bluetoothSocket;
private static final int SEND_CONNECT_FAIL = 1;
private static final int SEND_CONNECT_SUCCESS = 2;
private static final int SEND_FLAG = 110;
static class ConnectThread extends Thread {
private BluetoothDevice device;
public ConnectThread(BluetoothDevice device) {
this.device = device;
}
@Override
public void run() {
super.run();
//
try {
UUID uuid = UUID.fromString(UUID_STR);
BluetoothDevice remoteDevice = bluetoothAdapter.getRemoteDevice(device.getAddress());
// // TODO: 2018/10/23 此处通过uuid连接蓝牙；但有时候连接不上，不能保证每次都可以连接上；
bluetoothSocket = remoteDevice.createRfcommSocketToServiceRecord(uuid); // RFcomm 是一种简单的传输协议
bluetoothSocket.connect();
// 靠谱的方式； 这种是比较暴力的方式，直接连蓝牙，API没有开放，估计是为了安全的角度，通过信道连接，范围1-30； 通过递归直到练到正确的信道上；
// bluetoothSocket = cretateBluetoothSocketbyChannel(remoteDevice, 1, true);
if (bluetoothSocket == null) {
sendMSG(SEND_CONNECT_FAIL, "0: " + "change channel always error");
return;
}
LogUtil.e(TAG, "ok");
//
inS = bluetoothSocket.getInputStream();
outs = bluetoothSocket.getOutputStream();
} catch (IOException e) {
e.printStackTrace();
try {
if (bluetoothSocket != null) {
bluetoothSocket.close();
}
if (inS != null) {
inS.close();
}
if (outs != null) {
outs.close();
}
bluetoothSocket = null;
inS = null;
outs = null;
} catch (IOException e1) {
e1.printStackTrace();
//
sendMSG(SEND_CONNECT_FAIL, "1: " + e.getMessage());
return;
}
//
sendMSG(SEND_CONNECT_FAIL, "2: " + e.getMessage());
return;
}
//
sendMSG(SEND_CONNECT_SUCCESS, null);
}
}
/**
* 有时候用api提供的方法remoteDevice.createRfcommSocketToServiceRecord(uuid)不能成功连接，connect总出错误；
*
* @param Device
* @param channel
* @param autoForward
* @return
*/
private static BluetoothSocket cretateBluetoothSocketbyChannel(BluetoothDevice Device, int channel, boolean autoForward) {
BluetoothSocket socket = null;
try {
// createRfcommSocket为内置方法，入参为int类型； invoke执行该方法并需传入当前类对象及所需的入参类型；得到该方法的返回；
socket = (BluetoothSocket) Device.getClass().getMethod("createRfcommSocket", new Class[]{int.class}).invoke(Device, Integer.valueOf(channel));
socket.connect();
LogUtil.e(TAG, "connect is ok . " + channel);
} catch (Exception e) {
LogUtil.e(TAG, "get socket is failed . e: " + e.getMessage());
if (channel < 30) {
if (autoForward) {
socket = cretateBluetoothSocketbyChannel(Device, channel + 1, autoForward);
}
} else {
return null;
}
}
return socket;
}
private static void sendMSG(int what, Object object) {
Message msg = mHandler.obtainMessage();
msg.what = what;
msg.obj = object;
mHandler.sendMessage(msg);
}
private static Handler mHandler = new Handler() {
public void handleMessage(Message msg) {
switch (msg.what) {
case SEND_CONNECT_FAIL:
if (iConnectListener != null) {
iConnectListener.connectDevFail((String) msg.obj);
}
//
curr_status = CURR_STATUS.DISCONNECTED;
break;
case SEND_CONNECT_SUCCESS:
//
curr_status = CURR_STATUS.CONNECTED;
//
if (iConnectListener != null) {
iConnectListener.connectDevSuccess();
}
//
if (readThread == null) {
readThread = new ReadThread();
readThread.start();
} else {
LogUtil.e(TAG, "readThread != null");
}
//
if (sendThread == null) {
sendThread = new SendThread();
sendThread.start();
}
break;
}
}
};
static class SendThread extends Thread {
@Override
public void run() {
super.run();
//
Looper.prepare();
queueMsg = new Handler() {
@Override
public void handleMessage(Message msg) {
if (msg.what == SEND_FLAG) {
byte[] bytes = (byte[]) msg.obj;
sendToBlt(bytes);
}
super.handleMessage(msg);
}
};
Looper.loop();
}
}
static class ReadThread extends Thread {
@Override
public void run() {
super.run();
if (curr_status == CURR_STATUS.CONNECTED) {
if (inS == null) {
return;
}
try {
int available = inS.available();
byte[] bRec = new byte[available];
int read = inS.read(bRec);
//
LogUtil.e(TAG, "rece /// available: " + available + " read: " + read);
if (read > 0) {
if (iConnectListener != null) {
iConnectListener.dataRespon(bRec);
}
}
Thread.sleep(200);
} catch (IOException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
// 蓝牙发送 会放到队列里；
public static void sendData(byte[] data) {
if (queueMsg != null) {
Message message = queueMsg.obtainMessage();
message.what = SEND_FLAG;
message.obj = data;
queueMsg.sendMessage(message);
}
}
private static void sendToBlt(byte[] data) {
if (curr_status == CURR_STATUS.CONNECTED) {
try {
LogUtil.e(TAG, "send data");
outs.write(data);
} catch (IOException e) {
LogUtil.e(TAG, "e: " + e.getMessage());
e.printStackTrace();
}
} else {
LogUtil.e(TAG, "sendToBlt is fail...");
}
}
}
还有一个广播的 这个广播监听蓝牙的状态，可以根据自己的需要来进行你想监听的消息； 之前已经说了 这个广播可以放到上面一起 // 注意 下面没有获取了RSSI DEVICE这两个，没有去重；
package com.***.***.BlueToothM;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import com.***.***.BlueToothM.bean.BlueToothBean;
/**
* Created by bysd-2 on 2018/10/19.
*/
public class BlueToothReceiver extends BroadcastReceiver {
private IStatusListener listener;
public interface IStatusListener {
void foundDevice(BlueToothBean btBean);
void discoveryFinished();
void disConnected();
void connected();
}
public void setIStatusListener(IStatusListener l) {
this.listener = l;
}
@Override
public void onReceive(Context context, Intent intent) {
if (intent != null) {
String action = intent.getAction();
if (BluetoothDevice.ACTION_FOUND.equals(action)) {
BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
short rssi = intent.getExtras().getShort(BluetoothDevice.EXTRA_RSSI);
BlueToothBean btBean = new BlueToothBean(device, rssi);
if (listener != null) {
listener.foundDevice(btBean);
}
} else if (BluetoothAdapter.ACTION_DISCOVERY_FINISHED.equals(action)) {
if (listener != null) {
listener.discoveryFinished();
}
} else if (BluetoothDevice.ACTION_ACL_DISCONNECTED.equals(action)) {
BlueToothHelper.curr_status = BlueToothHelper.CURR_STATUS.DISCONNECTED;
if (listener != null) {
listener.disConnected();
}
} else if (BluetoothDevice.ACTION_ACL_CONNECTED.equals(action)) {
BlueToothHelper.curr_status = BlueToothHelper.CURR_STATUS.CONNECTED;
if (listener != null) {
listener.connected();
}
}
}
}
}
// 使用
registerListener(); // 注册那个广播，要记得解注册；
blueToothReceiver.setIStatusListener(new MyListener()); // 实现这个监听；
bluetoothAdapter = BlueToothHelper.initBlueTooth(getApplicationContext(), this); // 初始化
//
BlueToothHelper.startDiscover(); // 开始搜素
//
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
if (requestCode == BlueToothHelper.REQUEST_BLUE_ENABLE && resultCode == RESULT_OK) {
Toast.makeText(MainActivity.this, "open bluetooth success", Toast.LENGTH_LONG).show()；
BlueToothHelper.startDiscover();
} else {
LogUtil.e(TAG, "requestCode: " + requestCode);
}
}
// 连接蓝牙
BlueToothHelper.connectDevice(new BlueToothHelper.IConnectListener() {
@Override
public void connectDevSuccess() {
}
@Override
public void connectDevFail(String exception) {
}
@Override
public void dataRespon(byte[] bytes) {
}
}, device);
好了 关于普通蓝牙的大概这么多， 还有发送的 方法 sendData（byte[]）；
写的比较简单，主要是为了对蓝牙使用不了解的人，大家使用之前一定要先看看大体的流程，不要直接使用，对自己并没有好处。