android通过蓝牙程序实现与血压计设备的通信

子曰鸿程 07-30 157

前言：

现在大家对“java连接蓝牙通信协议”可能比较看重，我们都需要剖析一些“java连接蓝牙通信协议”的相关知识。那么小编在网上汇集了一些关于“java连接蓝牙通信协议””的相关内容，希望朋友们能喜欢，朋友们快快来了解一下吧！

手里有一台蓝牙的血压计，正好厂家发来了对接协议，于是开发了个安卓程序，可以实时接收血压计测量的数据。主要实现的功能有：

1、自动扫描蓝牙设备并配对

2、当发现设备工作时自动连接设备（因设备长时间休眠状态的，需要一旦发现设备工作就立刻保持蓝牙连接）

3、通过消息订阅实现设备状态的检测（如发现设备、匹配设备、连接设备，设备离线等）

4、收到测量结果后自动将数据通过网络上传至服务器用于统计和记录。

5、在手机app中可对设备进行控制，如开始测量、停止测量功能。

准备素材：

1、平板一个

2、血压设备（支持蓝牙）

开发工具：adnroid studio

开发语言：java

说明：代码中为了实现连接指定设备，代码中有配置蓝牙名称的变量，用以发现此蓝牙设备发起主动连接。

蓝牙电子血压计

工作中的状态

采集到的数据

开发代码环境

布局图

蓝牙工具类BleController：

使用单例模式实例化获取类，主要实现蓝牙设备的扫描、连接、状态检测及数据读写等操作。

具体功能可以看代码及注释。

package com.totcms.blefamdoc.bleutils;

import android.bluetooth.BluetoothAdapter;

import android.bluetooth.BluetoothDevice;

import android.bluetooth.BluetoothGatt;

import android.bluetooth.BluetoothGattCallback;

import android.bluetooth.BluetoothGattCharacteristic;

import android.bluetooth.BluetoothGattDescriptor;

import android.bluetooth.BluetoothGattService;

import android.bluetooth.BluetoothManager;

import android.bluetooth.BluetoothProfile;

import android.content.Context;

import android.os.Handler;

import android.os.Looper;

import android.util.Log;

import com.totcms.blefamdoc.bleutils.callback.BleDevceScanCallback;

import com.totcms.blefamdoc.bleutils.callback.ConnectCallback;

import com.totcms.blefamdoc.bleutils.callback.OnReceiverCallback;

import com.totcms.blefamdoc.bleutils.callback.OnWriteCallback;

import com.totcms.blefamdoc.bleutils.callback.ScanCallback;

import com.totcms.blefamdoc.bleutils.request.ReceiverRequestQueue;

import com.totcms.blefamdoc.utils.HexUtil;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.UUID;

public class BleController {

private static final String TAG = "BleController";

private static BleController mBleController;

private Context mContext;

private BluetoothManager mBlehManager;

private BluetoothAdapter mBleAdapter;

private BluetoothGatt mBleGatt;

private BluetoothGattCharacteristic mBleGattCharacteristic;

private Handler mHandler = new Handler(Looper.getMainLooper());

private BleGattCallback mGattCallback;

private OnWriteCallback writeCallback;

private boolean mScanning;

//默认扫描时间：10s

private static final int SCAN_TIME = 10000;

//默认连接超时时间:10s

private static final int CONNECTION_TIME_OUT = 10000;

//获取到所有服务的集合

private HashMap<String, Map<String, BluetoothGattCharacteristic>> servicesMap = new HashMap<>();

//连接请求是否ok

private boolean isConnectok = false;

//是否是用户手动断开

private boolean isMybreak = false;

//连接结果的回调

private ConnectCallback connectCallback;

//读操作请求队列

private ReceiverRequestQueue mReceiverRequestQueue = new ReceiverRequestQueue();

//此属性一般不用修改

private static final String BLUETOOTH_NOTIFY_D = "00002902-0000-1000-8000-00805f9b34fb";

//TODO 以下uuid根据公司硬件改变

public String UUID_SERVICE = "0000fff0-0000-1000-8000-00805f9b34fb";

public String UUID_INDICATE = "0000000-0000-0000-8000-00805f9b0000";

public String UUID_NOTIFY = "0000fff6-0000-1000-8000-00805f9b34fb";

public String UUID_WRITE = "0000fff6-0000-1000-8000-00805f9b34fb";

public String UUID_READ = "0000fff6-0000-1000-8000-00805f9b34fb";

public static synchronized BleController getInstance() {

if (null == mBleController) {

mBleController = new BleController();

}

return mBleController;

}

public BleController initble(Context context,String uuidService,String uuidNotify,String uuidWrite) {

UUID_SERVICE=uuidService;

UUID_NOTIFY=uuidNotify;

UUID_WRITE=uuidWrite;

if (mContext == null) {

mContext = context.getApplicationContext();

mBlehManager = (BluetoothManager) mContext.getSystemService(Context.BLUETOOTH_SERVICE);

if (null == mBlehManager) {

Log.e(TAG, "BluetoothManager init error!");

}

mBleAdapter = mBlehManager.getAdapter();

if (null == mBleAdapter) {

Log.e(TAG, "BluetoothManager init error!");

}

mGattCallback = new BleGattCallback();

}

return this;

}

/**

* 扫描设备

* @param time 指定扫描时间

* @param scanCallback 扫描回调

public void ScanBle(int time, final boolean enable, final ScanCallback scanCallback) {

if (!isEnable()) {

mBleAdapter.enable();

Log.e(TAG, "蓝牙没有开启");

}

if (null != mBleGatt) {

mBleGatt.close();

}

reset();

final BleDevceScanCallback bleDeviceScanCallback = new BleDevceScanCallback(scanCallback);

if (enable) {

if (mScanning) return;

mHandler.postDelayed(new Runnable() {

@Override

public void run() {

mScanning = false;

//time后停止扫描

mBleAdapter.stopLeScan(bleDeviceScanCallback);

scanCallback.onSuccess();

}

}, time <= 0 ? SCAN_TIME : time);

mScanning = true;

mBleAdapter.startLeScan(bleDeviceScanCallback);

} else {

mScanning = false;

mBleAdapter.stopLeScan(bleDeviceScanCallback);

}

/**

* 扫描设备

* 默认扫描10s

* @param scanCallback

public void ScanBle(final boolean enable, final ScanCallback scanCallback) {

ScanBle(SCAN_TIME, enable, scanCallback);

}

/**

* 连接设备

* @param connectionTimeOut 指定连接超时

* @param address 设备mac地址

* @param connectCallback 连接回调

public void Connect(final int connectionTimeOut, final String address, ConnectCallback connectCallback) {

if (mBleAdapter == null || address == null) {

Log.e(TAG, "地址或adapter为空：" + address);

return ;

}

BluetoothDevice remoteDevice = mBleAdapter.getRemoteDevice(address);

if (remoteDevice == null) {

Log.w(TAG, "没有找到设备.");

return;

}

this.connectCallback = connectCallback;

mBleGatt = remoteDevice.connectGatt(mContext, false, mGattCallback);

Log.e(TAG, "连接到地址:" + address);

delayConnectResponse(connectionTimeOut);

}

/**

* 连接设备

* @param address 设备mac地址

* @param connectCallback 连接回调

public void Connect(final String address, ConnectCallback connectCallback) {

Connect(CONNECTION_TIME_OUT, address, connectCallback);

}

/**

* 发送数据

* @param value 指令

* @param writeCallback 发送回调

public void WriteBuffer(String value, OnWriteCallback writeCallback) {

this.writeCallback = writeCallback;

if (!isEnable()) {

writeCallback.onFailed(OnWriteCallback.FAILED_BLUETOOTH_DISABLE);

Log.e(TAG, "无法写入数据");

return;

}

if (mBleGattCharacteristic == null) {

mBleGattCharacteristic = getBluetoothGattCharacteristic(UUID_SERVICE, UUID_WRITE);

}

if (null == mBleGattCharacteristic) {

writeCallback.onFailed(OnWriteCallback.FAILED_INVALID_CHARACTER);

Log.e(TAG, "找不到服务或特征值");

return;

}

//设置数组进去

mBleGattCharacteristic.setValue(HexUtil.hexStringToBytes(value));

//发送

boolean b = mBleGatt.writeCharacteristic(mBleGattCharacteristic);

Log.i(TAG, "发送结果:" + b + "数据：" + value);

}

/**

* 设置读取数据的监听

* @param requestKey

* @param onReceiverCallback

public void RegistReciveListener(String requestKey, OnReceiverCallback onReceiverCallback) {

mReceiverRequestQueue.set(requestKey, onReceiverCallback);

}

/**

* 移除读取数据的监听

* @param requestKey

public void UnregistReciveListener(String requestKey) {

mReceiverRequestQueue.removeRequest(requestKey);

}

/**

* 手动断开Ble连接

public void CloseBleConn() {

disConnection();

isMybreak = true;

mBleGattCharacteristic = null;

mBlehManager = null;

}

//------------------------------------分割线--------------------------------------

/**

* 当前蓝牙是否打开

private boolean isEnable() {

if (null != mBleAdapter) {

return mBleAdapter.isEnabled();

}

return false;

}

/**

* 重置数据

private void reset() {

isConnectok = false;

servicesMap.clear();

}

/**

* 超时断开

* @param connectionTimeOut

private void delayConnectResponse(int connectionTimeOut) {

mHandler.removeCallbacksAndMessages(null);

mHandler.postDelayed(new Runnable() {

@Override

public void run() {

if (!isConnectok && !isMybreak) {

Log.e(TAG, "连接超时");

disConnection();

reConnect();

} else {

isMybreak = false;

}

}, connectionTimeOut <= 0 ? CONNECTION_TIME_OUT : connectionTimeOut);

}

/**

* 断开连接

private void disConnection() {

if (null == mBleAdapter || null == mBleGatt) {

Log.e(TAG, "disconnection error maybe no init");

return;

}

mBleGatt.disconnect();

reset();

}

/**

* 蓝牙GATT连接及操作事件回调

private class BleGattCallback extends BluetoothGattCallback {

@Override

public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {

Log.i(TAG,"状态变化："+newState);

if (newState == BluetoothProfile.STATE_CONNECTED) { //连接成功

isMybreak = false;

isConnectok = true;

mBleGatt.discoverServices();

connSuccess();

} else if (newState == BluetoothProfile.STATE_DISCONNECTED) { //断开连接

if (!isMybreak) {

reConnect();

}

reset();

}

//发现新服务

@Override

public void onServicesDiscovered(BluetoothGatt gatt, int status) {

super.onServicesDiscovered(gatt, status);

Log.i(TAG,"发现新服务："+status);

if (null != mBleGatt && status == BluetoothGatt.GATT_SUCCESS) {

List<BluetoothGattService> services = mBleGatt.getServices();

for (int i = 0; i < services.size(); i++) {

HashMap<String, BluetoothGattCharacteristic> charMap = new HashMap<>();

BluetoothGattService bluetoothGattService = services.get(i);

String serviceUuid = bluetoothGattService.getUuid().toString();

List<BluetoothGattCharacteristic> characteristics = bluetoothGattService.getCharacteristics();

for (int j = 0; j < characteristics.size(); j++) {

charMap.put(characteristics.get(j).getUuid().toString(), characteristics.get(j));

}

servicesMap.put(serviceUuid, charMap);

}

BluetoothGattCharacteristic NotificationCharacteristic=getBluetoothGattCharacteristic(UUID_SERVICE,UUID_NOTIFY);

if (NotificationCharacteristic==null)

return;

enableNotification(true,NotificationCharacteristic);

}

//读数据

@Override

public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {

Log.i(TAG,"---读数据---");

super.onCharacteristicRead(gatt, characteristic, status);

}

//写数据

@Override

public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {

super.onCharacteristicWrite(gatt, characteristic, status);

Log.i(TAG,"---写数据---");

if (null != writeCallback) {

if (status == BluetoothGatt.GATT_SUCCESS) {

runOnMainThread(new Runnable() {

@Override

public void run() {

writeCallback.onSuccess();

}

});

Log.e(TAG, "发送 success!");

} else {

runOnMainThread(new Runnable() {

@Override

public void run() {

writeCallback.onFailed(OnWriteCallback.FAILED_OPERATION);

}

});

Log.e(TAG, "发送 failed!");

}

//通知数据

@Override

public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {

super.onCharacteristicChanged(gatt, characteristic);

Log.i(TAG,"---数据通知变化---");

if (null != mReceiverRequestQueue) {

HashMap<String, OnReceiverCallback> map = mReceiverRequestQueue.getMap();

final byte[] rec = characteristic.getValue();

for (String key : mReceiverRequestQueue.getMap().keySet()) {

final OnReceiverCallback onReceiverCallback = map.get(key);

runOnMainThread(new Runnable() {

@Override

public void run() {

onReceiverCallback.onReceiver(rec);

}

});

}

@Override

public void onDescriptorRead(BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status) {

Log.i(TAG,"---读描述---");

super.onDescriptorRead(gatt, descriptor, status);

}

/**

* 设置通知

* @param enable true为开启false为关闭

* @param characteristic 通知特征

* @return

private boolean enableNotification(boolean enable, BluetoothGattCharacteristic characteristic) {

if (mBleGatt == null || characteristic == null)

return false;

if (!mBleGatt.setCharacteristicNotification(characteristic, enable))

return false;

BluetoothGattDescriptor clientConfig = characteristic.getDescriptor(UUID.fromString(BLUETOOTH_NOTIFY_D));

if (clientConfig == null)

return false;

if (enable) {

clientConfig.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);

} else {

clientConfig.setValue(BluetoothGattDescriptor.DISABLE_NOTIFICATION_VALUE);

}

return mBleGatt.writeDescriptor(clientConfig);

}

public BluetoothGattService getService(UUID uuid) {

if (mBleAdapter == null || mBleGatt == null) {

Log.e(TAG, "BluetoothAdapter not initialized");

return null;

}

return mBleGatt.getService(uuid);

}

/**

* 根据服务UUID和特征UUID,获取一个特征{@link BluetoothGattCharacteristic}

* @param serviceUUID 服务UUID

* @param characterUUID 特征UUID

private BluetoothGattCharacteristic getBluetoothGattCharacteristic(String serviceUUID, String characterUUID) {

if (!isEnable()) {

throw new IllegalArgumentException(" Bluetooth is no enable please call BluetoothAdapter.enable()");

}

if (null == mBleGatt) {

Log.e(TAG, "mBluetoothGatt is null");

return null;

}

//找服务

Map<String, BluetoothGattCharacteristic> bluetoothGattCharacteristicMap = servicesMap.get(serviceUUID);

if (null == bluetoothGattCharacteristicMap) {

Log.e(TAG, "没有找到 serviceUUID!");

return null;

}

//找特征

Set<Map.Entry<String, BluetoothGattCharacteristic>> entries = bluetoothGattCharacteristicMap.entrySet();

BluetoothGattCharacteristic gattCharacteristic = null;

for (Map.Entry<String, BluetoothGattCharacteristic> entry : entries) {

if (characterUUID.equals(entry.getKey())) {

gattCharacteristic = entry.getValue();

break;

}

return gattCharacteristic;

}

private void runOnMainThread(Runnable runnable) {

if (isMainThread()) {

runnable.run();

} else {

if (mHandler != null) {

mHandler.post(runnable);

}

private boolean isMainThread() {

return Looper.myLooper() == Looper.getMainLooper();

}

// TODO 此方法断开连接或连接失败时会被调用。可在此处理自动重连,内部代码可自行修改，如发送广播

private void reConnect() {

if (connectCallback != null) {

runOnMainThread(new Runnable() {

@Override

public void run() {

connectCallback.onConnFailed();

}

});

}

Log.e(TAG, "Ble disconnect or connect failed!");

}

// TODO 此方法Notify成功时会被调用。可在通知界面连接成功,内部代码可自行修改，如发送广播

private void connSuccess() {

if (connectCallback != null) {

runOnMainThread(new Runnable() {

@Override

public void run() {

connectCallback.onConnSuccess();

}

});

}

Log.e(TAG, "Ble connect success!");

}

血压实体类：XueyaActivity.java

package com.totcms.blefamdoc.activity;

import androidx.core.app.ActivityCompat;

import androidx.core.content.ContextCompat;

import android.Manifest;

import android.app.ProgressDialog;

import android.bluetooth.BluetoothAdapter;

import android.bluetooth.BluetoothDevice;

import android.content.BroadcastReceiver;

import android.content.Context;

import android.content.Intent;

import android.content.IntentFilter;

import android.content.SharedPreferences;

import android.content.pm.PackageManager;

import android.graphics.Bitmap;

import android.os.Build;

import android.os.Bundle;

import android.os.Handler;

import android.os.Message;

import android.text.TextUtils;

import android.util.Log;

import android.view.View;

import android.widget.EditText;

import android.widget.TextView;

import android.widget.Toast;

import com.totcms.blefamdoc.R;

import com.totcms.blefamdoc.bleutils.BleController;

import com.totcms.blefamdoc.bleutils.callback.ConnectCallback;

import com.totcms.blefamdoc.bleutils.callback.OnReceiverCallback;

import com.totcms.blefamdoc.bleutils.callback.OnWriteCallback;

import com.totcms.blefamdoc.utils.AppUtil;

import com.totcms.blefamdoc.utils.ClsUtils;

import com.totcms.blefamdoc.utils.Constant;

import com.totcms.blefamdoc.utils.HexUtil;

import com.totcms.blefamdoc.utils.HttpUtil;

import org.json.JSONException;

import org.json.JSONObject;

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import java.util.Set;

public class XueyaActivity extends BaseActivity {

private final int STOP_SCAN = 1;

private boolean scanStatus = false;

private ProgressDialog progressDialog = null;

private static final int REQUEST_CODE_ACCESS_COARSE_LOCATION = 1;

private static final int REQUEST_DISCOVERABLE_BLUETOOTH = 3;

private BluetoothAdapter mBluetoothAdapter;

private BleController mBleController;//蓝牙工具类

private Context mContenxt;

TextView etData;

String dvAddr=null;

HttpUtil hu=null;

public final String UUID_SERVICE = "0000fff0-0000-1000-8000-00805f9b34fb";

public final String UUID_NOTIFY = "0000fff6-0000-1000-8000-00805f9b34fb";

public final String UUID_WRITE = "0000fff6-0000-1000-8000-00805f9b34fb";

private final String TAG = "XueyaActivity", PWD = "0000", TEST_DEVICE_NAME = "FSRKB_BT-001";

private final String ACTION_PAIRING_REQUEST = "android.bluetooth.device.action.PAIRING_REQUEST";//其它设备蓝牙配对请求

TextView connSts;

boolean isDevconn=false;

EditText etHighp;

EditText etLowP;

EditText etPulse;

EditText etCard;

private Handler handler= new Handler(){

public void handleMessage(android.os.Message msg) {

switch (msg.what) {

case Constant.HttpOk:

try {

JSONObject jo=new JSONObject((String)msg.obj);

if(jo==null){

AppUtil.showDialog(mContenxt,"提交失败了");

return;

}

if(jo.getInt("ret")==100){

AppUtil.showDialog(mContenxt,"成功提交");

}else {

AppUtil.showDialog(mContenxt,jo.getString("msg"));

}

} catch (JSONException e) {

AppUtil.showDialog(mContenxt,"提交失败了");

}

break;

default:

break;

}

};

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_xueya);

mContenxt=this;

etCard=findViewById(R.id.etcard2);

etData=findViewById(R.id.tv_msg);

connSts=findViewById(R.id.connsts);

etHighp=findViewById(R.id.ethp);

etLowP=findViewById(R.id.etlp);

etPulse=findViewById(R.id.etpulse);

hu=new HttpUtil();

mBleController = BleController.getInstance().initble(this,UUID_SERVICE,UUID_NOTIFY,UUID_WRITE);

mBleController.RegistReciveListener(TAG, new OnReceiverCallback() {

@Override

public void onReceiver(byte[] value) {

Log.i(TAG,HexUtil.bytesToHexString(value));

String getv=HexUtil.bytesToHexString(value);

//下面部分是蓝牙设备的数据通讯协议，可以根据你的血压设备的协议来具体调整。

if(getv.startsWith("d0c2")){

String cmd=getv.substring(6,8);

if(cmd.equals("cc")){

int ph=Integer.parseInt(getv.substring(8,10), 16);

int pl=Integer.parseInt(getv.substring(10,12), 16);

int pulse=Integer.parseInt(getv.substring(12,14), 16);

etHighp.setText(String.valueOf(ph));

etLowP.setText(String.valueOf(pl));

etPulse.setText(String.valueOf(pulse));

//etData.setText("高压："+ph+",低压："+pl+",心率："+pulse);

}

});

initSearchBroadcast();

initData();

getBluetoothMsg();

}

public void btnXySubmit(View view){

String postd="?userid="+baseUserId+"&token="+baseToken+"&cardid="+etCard.getText().toString()+"&lowp="+etLowP.getText().toString()+"&highp="+etHighp.getText().toString()+"&pulse="+etPulse.getText().toString();;

hu.getHtmlByThread(Constant.BloodpUrl+postd,handler,Constant.HttpOk);

}

public void btnClick(View view){

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {

if (checkSelfPermission(Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {

requestPermissions(new String[] {Manifest.permission.CAMERA}, 1);

return;

}

Intent intent = new Intent(XueyaActivity.this, QRCodeScanActivity.class);

startActivityForResult(intent, 100);

}

@Override

public void onActivityResult(int requestCode, int resultCode, Intent data) {

if (data == null || data.getExtras() == null || TextUtils.isEmpty(data.getExtras().getString("result"))) {

return;

}

String result = data.getExtras().getString("result");

if (etCard != null) {

etCard.setText(result);

}

@Override

protected void onResume() {

super.onResume();

checkGps();

}

public void goBack(View view){

finish();

}

@Override

protected void onDestroy() {

super.onDestroy();

hideProgressDialog();

if (bluetoothReceiver != null) {

unregisterReceiver(bluetoothReceiver);

}

mBleController.UnregistReciveListener(TAG);

mBleController.CloseBleConn();

}

public void connDevice(String address){

if (scanStatus) {

mBluetoothAdapter.cancelDiscovery();

Log.i(TAG,"--------取消扫描（已找到设备)---------------");

scanStatus = false;

}

Log.i(TAG,"--------连接到设备："+address+"---------------");

connSts.setText("正在连接设备...");

mBleController.Connect(address, new ConnectCallback() {

@Override

public void onConnSuccess() {

hideProgressDialog();

isDevconn=true;

connSts.setText("设备连接成功");

//Toast.makeText(XueyaActivity.this, "连接成功", Toast.LENGTH_SHORT).show();

}

@Override

public void onConnFailed() {

isDevconn=false;

connSts.setText("设备连接失败");

try {

Thread.currentThread().sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

if(!scanStatus) {

connSts.setText("重新连接到设备...");

scanBluetooth();

Log.i(TAG, "--------重新连接到设备：" + dvAddr + "---------------");

}

});

}

public void Write(String value){

mBleController.WriteBuffer(value, new OnWriteCallback() {

@Override

public void onSuccess() {

Toast.makeText(XueyaActivity.this, "ok", Toast.LENGTH_SHORT).show();

}

@Override

public void onFailed(int state) {

Toast.makeText(XueyaActivity.this, "fail", Toast.LENGTH_SHORT).show();

}

});

}

public void btnSendStart(View view){

Write("BEB001C036");

}

public void btnSendStop(View view){

Write("BEB001C168");

}

private void scanBluetooth() {

Log.i(TAG, "--------设备扫描中---------------");

connSts.setText("设备扫描中....");

mBluetoothAdapter.startDiscovery();

scanStatus = true;

mHandler.sendEmptyMessageDelayed(STOP_SCAN, 1000 * 12);

}

private void initData() {

mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();

//mBluetoothAdapter.setName("blueTestPhone"); //设置蓝牙名称

if (mBluetoothAdapter == null) {

Toast.makeText(this, "没有检测到蓝牙设备", Toast.LENGTH_LONG).show();

finish();

return;

}

boolean originalBluetooth = (mBluetoothAdapter != null && mBluetoothAdapter.isEnabled());

if (originalBluetooth) {

scanBluetooth();

} else if (originalBluetooth == false) {

mBluetoothAdapter.enable();

}

private void getBluetoothMsg() {

try {

StringBuilder sb = new StringBuilder();

//获取本机蓝牙名称

String name = mBluetoothAdapter.getName();

//获取本机蓝牙地址

String address = mBluetoothAdapter.getAddress();

//获取已配对蓝牙设备

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

sb.append("本机名称：" + name).append("\r\n");

sb.append("本机地址:" + address).append("\r\n");

//etData.setText(sb.toString());

} catch (Exception e) {

e.printStackTrace();

} finally {

}

private Handler mHandler = new Handler() {

@Override

public void handleMessage(Message msg) {

super.handleMessage(msg);

switch (msg.what) {

case STOP_SCAN:

if (scanStatus) {

mBluetoothAdapter.cancelDiscovery();

scanStatus = false;

hideProgressDialog();

}

break;

}

};

private void findDevice(Intent intent) throws Exception{

//获取到设备对象

BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);

String dvname=device.getName()==null?"null":device.getName();

String str =dvname + "|" + device.getAddress();

Log.e(TAG,"扫描到设备：" + str);

if (device.getBondState() == BluetoothDevice.BOND_BONDED) {//判断当前设备地址下的device是否已经配对

Log.e(TAG,dvname+ "已配对");

} else {

if (dvname.equals(TEST_DEVICE_NAME)) {

boolean bondStatus = ClsUtils.createBond(device.getClass(), device);

Log.i(TAG , dvname+" 配对结果:" + bondStatus);

}

if (dvname.equals(TEST_DEVICE_NAME)) {

connSts.setText("找到设备："+TEST_DEVICE_NAME);

dvAddr=device.getAddress();

connDevice(dvAddr);

}

//Log.e("error", "搜索完毕，准备刷新!");

}

private void initSearchBroadcast() {

IntentFilter intentFilter = new IntentFilter();

//发现设备

intentFilter.addAction(BluetoothDevice.ACTION_FOUND);

//设备配对状态改变

intentFilter.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED);

//蓝牙设备状态改变

intentFilter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED);

//开始扫描

intentFilter.addAction(BluetoothAdapter.ACTION_DISCOVERY_STARTED);

//结束扫描

intentFilter.addAction(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);

//其它设备请求配对

intentFilter.addAction(ACTION_PAIRING_REQUEST);

//intentFilter.addAction(BluetoothAdapter.CONNECTION_STATE_CHANGED);

registerReceiver(bluetoothReceiver, intentFilter);

}

private BroadcastReceiver bluetoothReceiver = new BroadcastReceiver() {

@Override

public void onReceive(Context context, Intent intent) {

String action = intent.getAction();

Log.e(TAG, "mBluetoothReceiver action =" + action);

try {

if (BluetoothAdapter.ACTION_DISCOVERY_STARTED.equals(action)) {//开始扫描

setProgressBarIndeterminateVisibility(true);

Log.e(TAG, "开始扫描");

} else if (BluetoothAdapter.ACTION_DISCOVERY_FINISHED.equals(action)) {//结束扫描

Log.e(TAG, "设备搜索完毕");

setProgressBarIndeterminateVisibility(false);

hideProgressDialog();

if(dvAddr==null || !isDevconn){

if(!scanStatus) {

Log.e(TAG, "--------没有连接到设备，再次连接-------");

Thread.sleep(300);

scanBluetooth();

}

}else{

scanStatus = false;

}

} else if (BluetoothDevice.ACTION_FOUND.equals(action)) {//发现设备

findDevice(intent);

} else if (BluetoothDevice.ACTION_BOND_STATE_CHANGED.equals(action)) {//蓝牙配对状态的广播

BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);

Log.e(TAG, device.getName() + "蓝牙配对广播:" + device.getBondState());

switch (device.getBondState()) {

case BluetoothDevice.BOND_BONDING:

Log.e(TAG, device.getName() + "蓝牙配对广播正在配对......");

break;

case BluetoothDevice.BOND_BONDED:

Log.e(TAG, device.getName() + "蓝牙配对广播完成配对,本机自动配对");

break;

case BluetoothDevice.BOND_NONE:

Log.e(TAG, device.getName() + "蓝牙配对广播取消配对");

default:

break;

}

} else if (action.equals(ACTION_PAIRING_REQUEST)) {//其它设备蓝牙配对请求

BluetoothDevice btDevice = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);

int state = intent.getIntExtra(BluetoothDevice.EXTRA_BOND_STATE, BluetoothDevice.BOND_NONE); //当前的配对的状态

try {

String deviceName = btDevice.getName();

Log.e(TAG, "蓝牙匹配信息：" + deviceName + "," + btDevice.getAddress() + ",state:" + state);

if(deviceName.equals(TEST_DEVICE_NAME)){//TEST_DEVICE_NAME 为被匹配蓝牙设备的名称，自己手动定义

Object object = ClsUtils.setPairingConfirmation(btDevice.getClass(), btDevice, true);

abortBroadcast();

boolean ret = ClsUtils.setPin(btDevice.getClass(), btDevice, PWD);

}

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

Toast.makeText(mContenxt, "error:" + btDevice + "," + state, Toast.LENGTH_LONG).show();

}

} else if (action.equals(BluetoothAdapter.ACTION_STATE_CHANGED)) {//蓝牙开关状态

// BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);

int statue = mBluetoothAdapter.getState();

switch (statue) {

case BluetoothAdapter.STATE_OFF:

Log.e(TAG,"蓝牙状态：,蓝牙关闭");

ClsUtils.closeDiscoverableTimeout(mBluetoothAdapter);

break;

case BluetoothAdapter.STATE_ON:

Log.e(TAG,"蓝牙状态：,蓝牙打开");

ClsUtils.setDiscoverableTimeout(1000 * 60, mBluetoothAdapter);

scanBluetooth();

break;

case BluetoothAdapter.STATE_TURNING_OFF:

Log.e(TAG,"蓝牙状态：,蓝牙正在关闭");

mBluetoothAdapter.cancelDiscovery();

break;

case BluetoothAdapter.STATE_TURNING_ON:

Log.e(TAG,"蓝牙状态：,蓝牙正在打开");

break;

}

} catch (Exception e) {

e.printStackTrace();

}

};

public void showProgressDialog(String title, String message) {

if (progressDialog == null) {

progressDialog = ProgressDialog.show(this, title, message, true, false);

} else if (progressDialog.isShowing()) {

progressDialog.setTitle(title);

progressDialog.setMessage(message);

}

progressDialog.show();

}

public void hideProgressDialog() {

if (progressDialog != null && progressDialog.isShowing()) {

progressDialog.dismiss();

progressDialog = null;

}

/**

* 开启位置权限

private void checkGps() {

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {

if (ContextCompat.checkSelfPermission(this,

Manifest.permission.ACCESS_COARSE_LOCATION)

!= PackageManager.PERMISSION_GRANTED) {

ActivityCompat.requestPermissions(this,

new String[]{Manifest.permission.ACCESS_COARSE_LOCATION,

Manifest.permission.ACCESS_FINE_LOCATION},

REQUEST_CODE_ACCESS_COARSE_LOCATION);

}

@Override

public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {

super.onRequestPermissionsResult(requestCode, permissions, grantResults);

if (requestCode == REQUEST_CODE_ACCESS_COARSE_LOCATION) {

if (grantResults.length > 0

&& grantResults[0] == PackageManager.PERMISSION_GRANTED) {

//initData();

Toast.makeText(this, "位置权限已开启", Toast.LENGTH_SHORT).show();

} else {

Toast.makeText(this, "未开启位置权限", Toast.LENGTH_SHORT).show();

}

} else {

super.onRequestPermissionsResult(requestCode, permissions, grantResults);

}

最后加了个拍照和扫码的功能，这样可以扫描客户的信息连同血压数据一起上传，这也就实现了健康档案系统中的数据采集的工作了。具体怎么扩展，大家可以自已想象了。

本文地址：http://www.longkongtuishu.com/cab48BmsCAVcGCFE.html

标签： #java连接蓝牙通信协议

android通过蓝牙程序实现与血压计设备的通信

android通过蓝牙程序实现与血压计设备的通信

MTK安卓平板电脑以太网（内网）4G、5G手机流量（外网）共存方案