Android蓝牙扫描/连接/收发数据

最新推荐文章于 2024-05-08 23:51:25 发布
最新推荐文章于 2024-05-08 23:51:25 发布
阅读量4.7k 收藏 25
点赞数 5
分类专栏： Android 文章标签： BlueTooth
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40391500/article/details/88813349
版权 
/**
 * 蓝牙工具类
 */
public class BlueToothUtils {
    private final String TAG = this.getClass().getSimpleName();
    private static BlueToothUtils utils = null;

    private BluetoothAdapter bluetoothAdapter;
    private final UUID SPP_UUID = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");
    private Executor executor;
    //当前链接蓝牙
    private static BluetoothSocket mSocket;

    private ArrayList<BluetoothDevice> deviceList = new ArrayList<>();//扫描到的远程蓝牙设备

    private Handler handler;

    public static BluetoothDevice mDevice = null;

    private boolean enabled = false;//蓝牙是否可用
    private final int SCANTIME = 5*1000;//扫描时间
    private final int requestCode = 2002;//


    public static BlueToothUtils getInstance(){
        if (utils == null){
            synchronized (BlueToothUtils.class){
                if (utils == null){
                    utils = new BlueToothUtils();
                }
            }
        }
        return utils;
    }

    /**
     * 判断是否打开蓝牙
     * 没有就静默打开
     */
    public void isOpen(Handler mHandler){
        handler = mHandler;
        ReceiveUtils.getInstance().setListener(listener);
        BluetoothManager bluetoothManager = (BluetoothManager) MyApplication.context.getSystemService(Context.BLUETOOTH_SERVICE);
        bluetoothAdapter = bluetoothManager.getAdapter(); // null:表示不支持蓝牙
        if (bluetoothAdapter == null){
            return;
        }
        connetGatt();
    }

    /**
     * 链接已配对蓝牙设备
     */
    public void connetGatt(){
        if (bluetoothAdapter != null){
            // true:处于打开状态, false:处于关闭状态
            enabled = bluetoothAdapter.isEnabled();
            if (!enabled){
                MyApplication.activity.startActivityForResult(new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE),
                        requestCode);
            }else {//获取已配对蓝牙
                Set<BluetoothDevice> devicesSet = bluetoothAdapter.getBondedDevices();
                deviceList.clear();
                for (BluetoothDevice device : devicesSet) {
                    deviceList.add(device);
                    if (handler != null){
                        handler.sendEmptyMessage(BluetoothActivity.SCAN_SUCC);
                    }
//                    LogUtils.log(TAG,"已配对蓝牙" + device.getName());
                    String connetAddress = (String) SPUtils.get(MyApplication.context, SPUtils.BLUETOOTH_ADDRESS, "");
                    if (device.getAddress().equals(connetAddress)){
                        if (bluetoothAdapter.isDiscovering()){
                            scanning(false);
                        }
                        LogUtils.log(TAG,"已配对蓝牙" + device.getName());
                        connet(device);
                    }
                }
            }
        }
    }

    /**
     * 扫描设备
     */
    public void scanning(boolean enable){
        if (bluetoothAdapter == null || !bluetoothAdapter.isEnabled()){
            if (handler != null){
                handler.sendEmptyMessage(BluetoothActivity.SCAN_OPEN);
            }
            return;
        }
        if (bluetoothAdapter != null){
            if (enable){
                if (handler != null){
                    handler.postDelayed(new Runnable() {
                        @Override
                        public void run() {
                            bluetoothAdapter.cancelDiscovery();
                            handler.sendEmptyMessage(BluetoothActivity.SCAN_CLOSE);
                            LogUtils.log("BlueToothUtils", "停止扫描设备");
                        }
                    }, SCANTIME);
                }
                deviceList.clear();
                connetGatt();
                // 寻找蓝牙设备，android会将查找到的设备以广播形式发出去
                this.bluetoothAdapter.startDiscovery();
                LogUtils.log("BlueToothUtils", "开始扫描设备");
            }else {
                if (handler != null){
                    handler.removeCallbacksAndMessages(null);
                    handler.sendEmptyMessage(BluetoothActivity.SCAN_CLOSE);
                }
                bluetoothAdapter.cancelDiscovery();
                LogUtils.log("BlueToothUtils", "停止扫描设备");
            }
        }
    }

    /**
     * 注册广播
     */
    public void initIntentFilter() {
        // 设置广播信息过滤
        IntentFilter intentFilter = new IntentFilter();
        intentFilter.addAction(BluetoothDevice.ACTION_FOUND);
        intentFilter.addAction(BluetoothAdapter.ACTION_DISCOVERY_STARTED);
        intentFilter.addAction(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
        intentFilter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED);
        // 注册广播接收器，接收并处理搜索结果
        MyApplication.context.registerReceiver(receiver, intentFilter);

    }

    /**
     * 销毁广播
     */
    public void unregisterReceiver() {
        MyApplication.context.unregisterReceiver(receiver);
    }

    /**
     * 蓝牙广播接收器
     */
    private BroadcastReceiver receiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            if (BluetoothDevice.ACTION_FOUND.equals(action)) {
                BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
//                LogUtils.log(TAG,"搜索到蓝牙设备名称:" + device.getName());
//                LogUtils.log(TAG,"搜索到蓝牙设备地址:" + device.getAddress());
                if (device.getBondState() != BluetoothDevice.BOND_BONDED) {
                    deviceList.add(device);
                    if (handler != null){
                        handler.sendEmptyMessage(BluetoothActivity.SCAN_SUCC);
                    }
                }
            } else if (BluetoothAdapter.ACTION_DISCOVERY_STARTED.equals(action)) {
                LogUtils.log(TAG,"搜索蓝牙设备中...");

            } else if (BluetoothAdapter.ACTION_DISCOVERY_FINISHED.equals(action)) {
                LogUtils.log(TAG,"设备搜索完毕");
                if (handler != null){
                    handler.sendEmptyMessage(BluetoothActivity.SCAN_SUCC);
                }
                // bluetoothAdapter.cancelDiscovery();
            }
            if (BluetoothAdapter.ACTION_STATE_CHANGED.equals(action)) {
                if (bluetoothAdapter == null) return;
                if (bluetoothAdapter.getState() == BluetoothAdapter.STATE_ON) {
                    LogUtils.log(TAG,"打开蓝牙");
                    enabled = bluetoothAdapter.isEnabled();
                    connetGatt();
                } else if (bluetoothAdapter.getState() == BluetoothAdapter.STATE_OFF) {
                    LogUtils.log(TAG,"关闭蓝牙");
                }
            }
        }

    };

    /**
     * 选择链接蓝牙设备
     */
    public void connet(BluetoothDevice device){
        if (bluetoothAdapter != null && device != null){
            close();
            LogUtils.log(TAG,"开始连接蓝牙--" + device.getName());
            try {
//             final BluetoothSocket socket = dev.createRfcommSocketToServiceRecord(SPP_UUID); //加密传输，Android系统强制配对，弹窗显示配对码
                final BluetoothSocket socket = device.createInsecureRfcommSocketToServiceRecord(SPP_UUID); //明文传输(不安全)，无需配对
                executor = Executors.newCachedThreadPool();
                // 开启子线程
                executor.execute(new Runnable() {
                    @Override
                    public void run() {
                        mSocket = socket;
                        mDevice = mSocket.getRemoteDevice();
                        receiveDate(mSocket); //循环读取
                    }
                });
            } catch (Throwable e) {
                close();
            }
        }
    }

    /**
     * 发送数据
     * 
     */
    public void sendData(byte[] by) {
        if (!isConnected(null)){
//            LogUtils.log(TAG, "请先打开蓝牙");
            return;
        }
       if (null != outputStream) {
                outputStream.write(by, 0, by.len);
                LogUtils.log( "SerialPortThread--发送数据");
	    } else {
	         LogUtils.log("SerialPortUtils", "蓝牙通讯失败");
		}
    }

    /**
     * 当前设备与指定设备是否连接
     */
    public boolean isConnected(BluetoothDevice dev) {
        boolean connected = (mSocket != null && mSocket.isConnected());
        if (dev == null)
            return connected;
        return connected && mSocket.getRemoteDevice().equals(dev);
    }

    /**
     * 关闭链接蓝牙设备
     */
    public void cancle(){
        try {
            if (bluetoothAdapter != null){
                bluetoothAdapter.cancelDiscovery();
                bluetoothAdapter.disable();
                bluetoothAdapter = null;
            }
            if (mSocket != null){
                mSocket.close();
            }
            ReceiveUtils.getInstance().close();
//            unregisterReceiver();
            utils = null;
        }catch (Exception e){
            e.printStackTrace();
        }
    }


	public void receiveDate(BluetoothSocket socket){
        try {
            mSocket = socket;
            if (!mSocket.isConnected()){
                mSocket.connect();
            }
            LogUtils.log(TAG, "连接蓝牙成功--" + mSocket.getRemoteDevice().getName());
            outputStream = new DataOutputStream(mSocket.getOutputStream());
            DataInputStream in = new DataInputStream(mSocket.getInputStream());
            int size = 0;
            byte[] buffer;
            isExit = false;
            while (!isExit){
                buffer = new byte[DATA_MAX_LEN];
                if (in != null) {
                    size = in.read(buffer);
                    if (size > 0) {
                        checkData(buffer, size);//处理数据
                    }
                }
                Thread.sleep(10);
            }
        }catch (Exception e){
            LogUtils.log(TAG, "蓝牙连接失败" + e.getMessage());
            close();
            e.printStackTrace();
        }
    }
	 
	 /**
     * 关闭Socket连接
     */
    public void close() {
        try {
            Log.e("-----------", "关闭Socket连接：");
            isExit = true;
            if (mSocket != null){
                mSocket.close();
            }
        } catch (Throwable e) {
            e.printStackTrace();
        }
    }
}

/**
 * 蓝牙接收/发送数据
 */
public class ReceiveUtils {
    private final String TAG = this.getClass().getSimpleName();
    private static ReceiveUtils utils = null;

    private BluetoothSocket mSocket;
    private DataOutputStream outputStream;
    //是否退出
    private boolean isExit = false;

    private BlueToothUtils.Listener listener;

    /**** 最大长度*/
    private static int DATA_MAX_LEN = 10;
    /**** 校验和长度*/
    private static int checkSumLen = 8;
    /***** 初始化*/
    private static byte[] b = new byte[DATA_MAX_LEN];
    /***** 初始化字节长度*/
    private static int unDisposeLen = 0;
    /**** 报头：一个字节，暂定0x35*/
    private static byte head = (byte) 0xA5;
    /**** 报尾：一个字节，暂定0xAA*/
    private static byte end = (byte) 0x45;

    public static ReceiveUtils getInstance(){
        if (utils == null){
            synchronized (ReceiveUtils.class){
                if (utils == null){
                    utils = new ReceiveUtils();
                }
            }
        }
        return utils;
    }

    public void setListener(BlueToothUtils.Listener listener){
        this.listener = listener;
    }

    public void receiveDate(BluetoothSocket socket){
        try {
            mSocket = socket;
            if (!mSocket.isConnected()){
                mSocket.connect();
            }
            LogUtils.log(TAG, "连接蓝牙成功--" + mSocket.getRemoteDevice().getName());
            if (listener != null){
                listener.socketNotify(BlueToothUtils.Listener.CONNECTED, mSocket.getRemoteDevice());
                SPUtils.set(MyApplication.context, SPUtils.BLUETOOTH_ADDRESS, mSocket.getRemoteDevice().getAddress());
            }
            outputStream = new DataOutputStream(mSocket.getOutputStream());
            DataInputStream in = new DataInputStream(mSocket.getInputStream());
            int size = 0;
            byte[] buffer;
            isExit = false;
            while (!isExit){
                buffer = new byte[DATA_MAX_LEN];
                if (in != null) {
                    size = in.read(buffer);
                    if (size > 0) {
                        //接收数据
                    }
                }
                Thread.sleep(10);
            }
        }catch (Exception e){
            LogUtils.log(TAG, "蓝牙连接失败" + e.getMessage());
            close();
            e.printStackTrace();
        }
    }
    
    /***
     * 串口写入数据
     */
    public void send(byte by) {
        try {
            if (null != outputStream) {
                outputStream.write(by, 0, DATA_MAX_LEN);
//                LogWSUtils.logData(by, DATA_MAX_LEN, TAG + "--发送数据");
//                LogUtils.log(TAG, "发送数据--" + Arrays.toString(by));
            } else {
                LogUtils.log(TAG, "蓝牙通讯失败");
            }
        } catch (IOException e) {
            close();
            e.printStackTrace();
        }
    }
    /**
     * 关闭Socket连接
     */
    public void close() {
        try {
            Log.e("-----------", "关闭Socket连接：");
            isExit = true;
            if (mSocket != null){
                mSocket.close();
                mSocket = null;
            }
            if (listener != null){
                listener.socketNotify(BlueToothUtils.Listener.DISCONNECTED, null);
            }
        } catch (Throwable e) {
            e.printStackTrace();
        }
    }
金胖
关注
  • 5
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
Android 蓝牙 BLE扫描、广播、连接、数据收发源码分析（3）- inquiry扫描结果处理
手机-手表蓝牙开发工程师的博客
04-19 2278
android-蓝牙A2dp-avrcp-hfp-opp-配对流程-ble-rfcomm源码流程 Android 蓝牙低功耗ble 广播、扫描、连接、数据读写源码流程分析大全 - 点击下载 首先提前注册扫描结果回调函数。bta_dm_search_cb回调赋值 在我们开始设备Inquiry的时候，先前已经提到过，调用btif_dm_start_discover函数，在这个函数中，调用了BTA_DmSearch函数，用它来搜寻附近可被发现的蓝牙设备，在这个函数中，传入了bte_search_device
Android 蓝牙 BLE扫描、广播、连接、数据收发源码分析（1）-ble observe
手机-手表蓝牙开发工程师的博客
04-14 1224
packages/apps/bluetooth/jni/Com_android_bluetooth_gatt.cpp中的onScanResult函数，最终回到了我们调用ble扫描的类中，至此完成了整个ble扫描的过程，在onScanResult中，继续调用callback.onScanResult函数将扫描结果设备信息传递到更上一层应用，整个扫描结束.......
Android BLE简介及连接、收发数据
迷彩狼的博客
07-02 2755
知识点： 经典蓝牙（Classic Bluetooth）& 低功耗蓝牙（Bluetooth Low Energy） 经典蓝牙可以用与数据量比较大的传输，如语音，音乐，较高数据量传输等。 BLE 特点就如其名，功耗更低的同时，对数据包做出了限制。所以适用于实时性要求比较高，但是数据速率比较低的产品，如鼠标，键盘，传感设备的数据发送等。 蓝牙 4.0 支持单模和双模两种部署方式，其中单模即是我们说的 BLE，而双模指的是 Classic Bluetooth + BLE 。 实际上，
Android最全Android 蓝牙开发（扫描设备、绑定、解绑）Kotlin版，2024年最新跳槽时面试官会问哪些问题
最新发布
2401_84520026的博客
05-08 690
这么一看是不是觉得Kotlin的语法很简单，它允许你的返回值一致的判断进行直接赋值，比如这里判断设备名称为空则显示无名二字，不为空则显示设备名，这两个返回都是String类型，而tvName.text设置的就是String类型，所以就有了上面的简洁代码，有点像三目运算符。一切准备工作都已经就绪了，下面就进入编码环节，前面的内容其实和Kotlin的关系都不大，下面上正菜，Kotlin相比于Java来说的优势就是简洁，这一点会在下面的编码过程中体现。好了，以上便是今天的分享，希望为各位朋友后续的学习提供方便。
Android蓝牙bt/ble开发
juzi_zg的博客
04-16 2302
参看文档： 蓝牙开发：https://www.jianshu.com/p/4ecc99679451 蓝牙bt/ble区别：https://zhuanlan.zhihu.com/p/59907996 安卓BLE蓝牙开发详解：https://www.jianshu.com/p/a27f3ca027e3 安卓蓝牙开发之坑：https://www.jianshu.com/p/71116665fd08 目录 1：经典蓝牙开发 1.1：经典蓝牙简介 1.2：基础知识 1.3：经典蓝牙模块 2：.
Android Ble蓝牙App（五）数据操作
晨曦
08-14 4747
关于低功耗蓝牙的服务、特性、属性、描述符都已经讲清楚了，而下面就是使用这些知识进行数据的读取、写入、通知等操作。
Android 9.0 蓝牙扫描流程
一个Android菜鸟的博客
04-23 4448
昨天梳理了蓝牙的开启流程，今天梳理一遍扫描流程： 1、UI /packages/apps/Settings/src/com/android/settings/bluetooth/BluetoothPairingDetail.java void enableScanning() { // Clear all device states before first scan if (!m...
Android 蓝牙 BLE扫描、广播、连接、数据收发源码分析（2）- inquiry扫描周围设备
手机-手表蓝牙开发工程师的博客
04-19 845
android-蓝牙A2dp-avrcp-hfp-opp-配对流程-ble-rfcomm源码流程 Android 蓝牙低功耗ble 广播、扫描、连接、数据读写源码流程分析大全 - 点击下载 扫描的开始还是从start_discover开始，手机界面开启扫描，调用start_discovery函数，在里面又调用了btif_dm_start_discovery方法 btif_dm_start_discovery方法首先清除索引0，重新设置索引0，然后设置相关的搜索参数，设置交叉扫描模式等等 设...
Android之蓝牙收发数据接口封装流程
KingOTG的博客
04-20 1069
本文的主要记录一下其中的蓝牙开发流程，留作以后整理备用； 文章主要讲述的是如何在第三方提供的蓝牙接口，根据自身定义的通讯协议（即收发数据封装）提供给用户进行二次开发的接口封装思路； 环境：第三方提供的蓝牙回调接口包括：蓝牙扫描、蓝牙连接等； 目标：根据自身定义的通讯协议，如获取版本信息、按键信息、控制亮灯等功能；封装成用户直接调用，而不需要了解自定义协议指定内容，从而获取到相应的数据即可； ...
Android BLE最完整的工具类(扫描/连接/读写/通知设备)
热门推荐
无论何时都不要停止学习，这是改变自己的必要条件
07-04 1万+
这里只要是Android设备与BLE设备的通讯都可以共用，只需要该的就是uuid的值，还有就是ble设备提供商要出文档协议，看看是如何发命令跟接收命令的。 bleUtil工具中，有些地方我感觉还是要提示下 1、characterUUID1 、characterUUID2 、descriptorUUID 这三个是对应的收发命令的，跟找到要操作的BluetoothGattDescriptor（特性...
android蓝牙搜索，连接，数据收发实现demo，亲测好用，诚信做人，绝不忽悠
09-24
本教程将基于提供的"android蓝牙搜索，连接，数据收发实现demo"进行深入解析，帮助开发者理解如何在Android应用中实现蓝牙搜索、连接以及数据传输。 首先，让我们了解蓝牙在Android系统中的基本框架。Android提供了...
qt编写的低功耗蓝牙demo，可实现蓝牙检测连接与数据收发
08-16
**BLE连接与数据收发** 在`Qt BLE Tester`项目中，主要涉及以下关键步骤： 1. **设备发现**：使用`QBluetoothDeviceDiscoveryAgent`来扫描周围可用的BLE设备，获取设备的UUIDs、名称和信号强度等信息。 2. **连接...
蓝牙4.0连接收发数据
05-30
在Android Studio中开发蓝牙4.0连接收发数据的应用，你需要理解以下几个核心概念和技术： 1. **BluetoothAdapter**: Android系统中的`BluetoothAdapter`类是蓝牙功能的主要接口，它负责管理蓝牙设备的连接状态、...
Android 蓝牙低功耗ble 广播、扫描、连接、数据读写源码流程图，非常详细的从btif-bta-btm-hci 数据流程走
04-14
Android 蓝牙低功耗ble 广播、扫描、连接、数据读写源码流程图，非常详细的从btif-bta-btm-hci 数据流程走向，以及从controller收到数据到btm层，将Android 源码使用流程图的形式画了出来，使Android 蓝牙开发者更...
Android蓝牙连接配对通讯.zip
06-27
总结起来，这个压缩包提供的资源展示了Android蓝牙通信的基本流程，包括设备扫描、连接建立、数据收发等核心步骤。通过学习和分析这些代码，开发者可以掌握如何在Android应用中实现蓝牙设备的连接和通信功能。
Android微信生成支付二维码URL
11-27 1万+
/*微信二维码支付/ public class WXPayUtils {private static String strResponse = null; private static String url = ""; public static String nonceStr = ""; public static String outTradeNo = ""; /** * 微信生成签名 *
Android连接WiFi
05-21 1万+
WiFi打开、连接、关闭 /** * WiFi连接管理 * 申请权限 * <uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/> * <uses-permission android:name="android.permission.CHANGE_WIFI_STATE"/> * ...
Android连接WiFi设置IP为静态IP
09-03 8180
设置静态IP需要先忘记WiFi密码再重新连接，会记住是哪个APP连接WiFi public class WifiConnet { private static WifiConnet utils = null; private WifiManager wifiManager; public static int Num = 0; public static Stri...
android实现了蓝牙连接怎样实现收发信息
04-11
你可以使用 Android 的 Bluetooth API 来实现蓝牙连接和数据收发。首先，你需要获取 BluetoothAdapter 对象并检查设备是否支持蓝牙功能。然后，你可以搜索和配对其他蓝牙设备，并使用 BluetoothSocket 在设备之间...
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值