ble通信工具

最新推荐文章于 2024-06-05 19:29:53 发布
最新推荐文章于 2024-06-05 19:29:53 发布
阅读量273 收藏
点赞数
分类专栏： 我的android之路 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qwildwolf/article/details/120226831
版权 
package com.nobo.bluetooth;

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.BluetoothProfile;
import android.os.Build;
import android.os.Handler;
import android.util.Log;

import androidx.annotation.RequiresApi;

import com.blankj.utilcode.util.LogUtils;

import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.UUID;

/**
 * Created by MISHAOSHUAI
 * on 2021/8/17.
 */
public class BLEConnect
{
    private static BluetoothGattCharacteristic mNotifyCharacteristic;
    private static com.nobo.bluetooth.BtBase.Listener mListener;
    private String serviceUuid = "";
    private String characterUuid = "";
    private static final String TAG = "BLEConnect";
    private static BluetoothGatt mBluetoothGatt;
    private boolean isConnected;
    private Handler mDiscoverServiceHandler = new Handler();
    private Runnable mDisvoverServiceRunnable = new Runnable()
    {
        @Override
        public void run()
        {
            LogUtils.d("重新获取服务");
            disConn();

            connect(mBTmodel);
        }
    };

    private BTmodel mBTmodel;
    private static BLEConnect sInstance;

    private BLEConnect()
    {
    }

    public static BLEConnect getInstance(BtBase.Listener listener)
    {
        if (sInstance == null)
        {
            synchronized (BLEConnect.class)
            {
                if (sInstance == null)
                {
                    sInstance = new BLEConnect();
                }
            }
        }

        setListener(listener);
        return sInstance;
    }

    // 与服务端连接的Callback
    public BluetoothGattCallback mBluetoothGattCallback = new BluetoothGattCallback()
    {
        @Override
        public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState)
        {
            BluetoothDevice dev = gatt.getDevice();
            Log.i(TAG, String.format("onConnectionStateChange:%s,%s,%s,%s", dev.getName(), dev.getAddress(), status, newState));
            if (status == BluetoothGatt.GATT_SUCCESS &&
                newState == BluetoothProfile.STATE_CONNECTED)
            {
                isConnected = true;
                gatt.discoverServices(); //启动服务发现
                mDiscoverServiceHandler.postDelayed(mDisvoverServiceRunnable, 2000);
            }
            else
            {
                isConnected = false;
                disConn();

                notifyUI(BtBase.Listener.DISCONNECTED, mBTmodel);
                LogUtils.d("连接失败");
            }

            LogUtils.d(String.format(
                    status == 0 ? (newState == 2 ? "与[%s]连接成功" : "与[%s]连接断开") : ("与[%s]连接出错,错误码:" +
                                                                                 status), dev));
        }

        @Override
        public void onServicesDiscovered(BluetoothGatt gatt, int status)
        {
            mDiscoverServiceHandler.removeCallbacksAndMessages(null);
            if (status == BluetoothGatt.GATT_SUCCESS)
            {
                LogUtils.d("发现服务成功，连接成功");
                notifyUI(BtBase.Listener.CONNECTED, mBTmodel);
                //BLE服务发现成功
                // 遍历获取BLE服务Services/Characteristics/Descriptors的全部UUID
                for (BluetoothGattService service : gatt.getServices())
                {
                    StringBuilder allUUIDs = new StringBuilder(
                            "UUIDs={\nS=" + service.getUuid().toString());
                    for (BluetoothGattCharacteristic characteristic : service.getCharacteristics())
                    {
                        allUUIDs.append(",\nC=").append(characteristic.getUuid());
                        for (BluetoothGattDescriptor descriptor : characteristic.getDescriptors())
                        {
                            allUUIDs.append(",\nD=").append(descriptor.getUuid());
                        }
                    }
                    allUUIDs.append("}");
                    LogUtils.d("发现服务" + allUUIDs);
                }

                //BLE服务发现成功
                serviceUuid = "your service uuid";
                characterUuid = "your character uuid";
                BluetoothGattService service = gatt.getService(UUID.fromString(serviceUuid));
                mNotifyCharacteristic = service.getCharacteristic(UUID.fromString(characterUuid));

                if (mNotifyCharacteristic != null)
                {
                    //使能Notify
                    setCharacteristicNotification(mNotifyCharacteristic, true);
                }

//                read();
            }
            else
            {
                LogUtils.d("发现服务失败，连接失败");
                disConn();
            }
        }

        @Override
        public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status)
        {
            UUID uuid = characteristic.getUuid();
            String valueStr = new String(characteristic.getValue());
            notifyUI(BtBase.Listener.READ, valueStr);
            LogUtils.d("读取Characteristic[" + uuid + "]:\n" + valueStr);
        }

        @Override
        public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status)
        {
            UUID uuid = characteristic.getUuid();
            String valueStr = new String(characteristic.getValue());
            notifyUI(BtBase.Listener.MSG, valueStr);
        }

        @Override
        public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic)
        {
            UUID uuid = characteristic.getUuid();
            String valueStr = new String(characteristic.getValue());
            LogUtils.d("通知Characteristic[" + uuid + "]:\n" + valueStr);

            notifyUI(BtBase.Listener.READ, valueStr);
        }

        @Override
        public void onDescriptorRead(BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status)
        {
            UUID uuid = descriptor.getUuid();
            String valueStr = Arrays.toString(descriptor.getValue());
            LogUtils.d("读取Descriptor[" + uuid + "]:\n" + valueStr);
        }

        @Override
        public void onDescriptorWrite(BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status)
        {
            UUID uuid = descriptor.getUuid();
            String valueStr = Arrays.toString(descriptor.getValue());
            LogUtils.d("写入Descriptor[" + uuid + "]:\n" + valueStr);
            //询问状态
            write("A");
        }

        @Override
        public void onReadRemoteRssi(BluetoothGatt gatt, int rssi, int status)
        {
            super.onReadRemoteRssi(gatt, rssi, status);
            LogUtils.d("RSSI:" + rssi);
        }
    };

    /**
     * BLE中心设备连接外围设备的数量有限(大概2~7个)，
     * 在建立新连接之前必须释放旧连接资源，否则容易出现连接错误133
     */
    public void disConn()
    {
        if (mBluetoothGatt != null)
        {
            mBluetoothGatt.disconnect();
            mBluetoothGatt.close();

            mBluetoothGatt = null;
            mNotifyCharacteristic = null;
        }
    }

    // 注意：连续频繁读写数据容易失败，读写操作间隔最好200ms以上，或等待上次回调完成后再进行下次读写操作！
    // 读取数据成功会回调->onCharacteristicChanged()
    public void read()
    {
        BluetoothGattService service = getGattService(UUID.fromString(serviceUuid));
        if (service != null)
        {
            BluetoothGattCharacteristic characteristic = service.getCharacteristic(UUID.fromString(characterUuid));//通过UUID获取可读的Characteristic
            mBluetoothGatt.readCharacteristic(characteristic);
        }
    }

    // 注意：连续频繁读写数据容易失败，读写操作间隔最好200ms以上，或等待上次回调完成后再进行下次读写操作！
    // 写入数据成功会回调->onCharacteristicWrite()
    public void write(String data)
    {
        BluetoothGattService service = getGattService(UUID.fromString(serviceUuid));
        if (service != null)
        {
            BluetoothGattCharacteristic characteristic = service.getCharacteristic(UUID.fromString(characterUuid));//通过UUID获取可写的Characteristic
            characteristic.setValue(data.getBytes(StandardCharsets.UTF_8)); //单次最多20个字节
            mBluetoothGatt.writeCharacteristic(characteristic);
        }
    }

    // 获取Gatt服务
    private BluetoothGattService getGattService(UUID uuid)
    {
        if (!isConnected)
        {
            ToastyUtils.toastWarn("没有连接", true);
            return null;
        }
        BluetoothGattService service = mBluetoothGatt.getService(uuid);
        if (service == null)
        {
            ToastyUtils.toastWarn(
                    NoboApplication.getContext().getString(R.string.cant_find_service_uuid) +
                    uuid, true);
        }
        return service;
    }

    @RequiresApi(api = Build.VERSION_CODES.O)
    public void connect(BTmodel dev)
    {
        LogUtils.d("BLE connect");
        mBTmodel = dev;
        mBluetoothGatt = dev.getDevice()
                .connectGatt(NoboApplication.getContext(),
                             false,
                             mBluetoothGattCallback,
                             2,
                             BluetoothDevice.PHY_LE_1M_MASK); // 连接蓝牙设备
    }

    public void notifyUI(final int state, final BTmodel obj)
    {
        NoboApplication.runUi(() -> {
            try
            {
                if (mListener != null)
                {
                    mListener.socketNotify(state, obj);
                }
                else
                {
                    LogUtils.d("mListener == null");
                }
            }
            catch (Throwable e)
            {
                LogUtils.d("回调异常");
                e.printStackTrace();
            }
        });
    }

    public void notifyUI(final int state, final String obj)
    {
        NoboApplication.runUi(() -> {
            try
            {
                if (mListener != null)
                {
                    mListener.socketNotify(state, obj);
                }
                else
                {
                    LogUtils.d("mListener == null");
                }
            }
            catch (Throwable e)
            {
                LogUtils.d("回调异常");
                e.printStackTrace();
            }
        });
    }

    /**
     * 释放监听引用(例如释放对Activity引用，避免内存泄漏)
     */
    public void unListener()
    {
        mListener = null;
        LogUtils.d("mListener置空");
    }

    public boolean isConnected()
    {
        return isConnected;
    }

    public void setConnected(boolean connected)
    {
        isConnected = connected;
    }

    public BtBase.Listener getListener()
    {
        return mListener;
    }

    public static void setListener(BtBase.Listener listener)
    {
        mListener = listener;
    }

    public static String CLIENT_CHARACTERISTIC_CONFIG = "00002902-0000-1000-8000-00805f9b34fb";

    public void setCharacteristicNotification(BluetoothGattCharacteristic characteristic,
            boolean enabled)
    {
        mBluetoothGatt.setCharacteristicNotification(characteristic, enabled);

        // This is specific to BLE SPP Notify.
//        if (characterUuid.equals(characteristic.getUuid()))
        {
            BluetoothGattDescriptor descriptor = characteristic.getDescriptor(
                    UUID.fromString(CLIENT_CHARACTERISTIC_CONFIG));
            descriptor.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
            mBluetoothGatt.writeDescriptor(descriptor);
        }
    }
}

要交互，就要像上面那样setCharacteristicNotification才能收到消息

扬帆！起航！
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android:BLE（Bluetooth Low Energy）开发
BAOLIANG196的博客
11-09 2178
Demo下载demo下载BLE介绍最近穿戴设备发展得很火，其大多数所用的技术是BLE（Bluetooth Low Energy）。BLE是蓝牙4.0的核心Profile，BLE前身是NOKIA开发的Wibree技术，主要用于实现移动智能终端与周边配件之间的持续连接，是功耗极低的短距离无线通信技术，并且有效传输距离被提升到了100米以上，同时只需要一颗纽扣电池就可以工作数年之久。 BLE主打功能是快
Android BLE 官方DEMO
09-23
本人是在AndroidStuido上导入的，此代码提供源码及本人运行后的代码。注意源码导入容易出现错误不过很容易处理。代码支持android系统4.3以上，手机支持蓝牙4.0，搜索，配对，连接，发现服务及特征值，断开连接等功能。
Android BLE
05-12
Android BLE开发实例，创建-->搜索-->连接-->数据传输-->断开后自动重连
android BLE
热门推荐
lgdlchshg的专栏
12-21 3万+
android4.3 nei内置了ble并为上层app提供相应的接口来使用BLE功能。 BLE主要涉及的协议及术语： GenericAttribute Profile (GATT) BLE上层的协议都是基于GATT，它是一个通用的规范，通过BLE连接发送/接收属性值。 bluetoothSIG定义了很多的ble协议。 AttributeProtocol (
低功耗蓝牙中ATT/GATT/Profile/Service/Characteristic详解
最新发布
weixin_40543589的博客
06-05 1059
蓝牙协议栈架构
android ble
倒骑驴走着瞧的博客
04-08 345
扫描设备-发现设备-连接设备-蓝牙通信-断开连接-释放资源 Android BLE 蓝牙开发入门
android Ble通信
小男孩
12-18 636
你好
Android Ble 轻量级框架
11-20
该框架是Android蓝牙4.0通信框架，轻量级，可输入serverUUID跟charUUID即可通信，包含权限，蓝牙开关检测。
Android：使用BLE蓝牙
new_Aiden的博客
02-24 530
Android手机支持BLE（蓝牙4.0）通信。笔者遇到了不少问题，供大家分享下。1、开启蓝牙BlueAdapter adapter = BluetoothAdapter.getDefaultAdapter(); if (!adapter.isEnabled()) { ToastUtil.showToast("请打开蓝牙服务"); Intent intent = new Intent
【Android】蓝牙开发——BLE（低功耗蓝牙）（附完整Demo）
一个IT人的技术成长历程。创造未来的行为就发生在今天，没有明天的目标，今天的行动就是重复昨天的事情。
10-30 2778
之前的几篇文章，主要介绍了经典蓝牙开发相关的知识，今天我们就来看看低功耗蓝牙的开发。如果小伙伴们对之前的文章感兴趣兴趣，也可以看看，欢迎提出不足或者建议。【Android】蓝牙开发——经典蓝牙（附Demo源码）【Android】蓝牙开发——经典蓝牙配对介绍（通过手机系统蓝牙演示）【Android】蓝牙开发—— 经典蓝牙配对介绍（Java代码实现演示）附Demo源码BLE，全称 Bluetooth Low Energy，即低功耗蓝牙。
Android Ble蓝牙App（三）特性和属性
晨曦
08-07 2756
在上一篇中我们完成了连接和发现服务两个动作，那么再发现服务之后要做什么呢？发现服务只是让你知道设备有什么服务，可以做什么事情。
Android BLE基础操作框架（源码及使用介绍）
09-10
Android BLE基础操作框架，基于回调，操作简单。其中包含扫描、连接、广播包解析、服务读写及通知等功能。
Android BLE蓝牙与硬件通信(原生API)
11-07
源码包含内容介绍: 1.Android手机通过蓝牙(BLE)与硬件进行通信(包括扫描,连接,发送,接收,注册服务等等) 2.控制手机音量 3. 实现控制第三方音乐播放器暂停、播放 4.使用AudioRecord和AudioTrack边录边播 详情请查看:https://blog.csdn.net/dengshunhao/article/details/82222296
蓝牙BLE数据通讯调试工具
08-24
没有iOS/Android app如何开发蓝牙BLE设备？使用一个HID BLE Dongle加上本APP就可实现数据通讯了，类似串口调试工具，简单实用还有实用说明.
Android BLE 知识点
ItsFated的博客
12-11 244
android蓝牙BLE 简书总结： android蓝牙BLE（一） —— 扫描 android蓝牙BLE（二） —— 通信 android蓝牙BLE（三） —— 广播 android蓝牙BLE（四） —— 实战 android蓝牙BLE 问题总结： Android BLE4.+ 蓝牙开发国产手机兼容性解决方案 android蓝牙BLE 知识点总结： Bluetooth BR/EDR和BLE的区别 ...
Android BLE开发
Melissa_htt的博客
05-16 806
蓝牙ble(Bluetooth Low Energy):蓝牙低能耗技术蓝牙4.0 适用范围:Android4.3之后才支持BLE;iOS7.0开始支持BLE,Swift语言需要iOS8.0以上,硬件要求iPhone4s以上(包含4s) 蓝牙通信关系:主从关系,每一对设备进行蓝牙通讯时,必须一个为中心设备central,另一个为从设备peripheral.通信时必须central进行查找,发起配
Android Ble蓝牙App（五）数据操作
晨曦
08-14 4829
关于低功耗蓝牙的服务、特性、属性、描述符都已经讲清楚了，而下面就是使用这些知识进行数据的读取、写入、通知等操作。
Android BLE学习
屁屁岚
08-01 204
Five Essential Tools for Every Bluetooth Low Energy Developer 里面介绍了开发蓝牙BLE最常用的工具。 安卓可以下载谷歌的demo https://github.com/googlesamples/android-BluetoothLeGatt 也可以学习大神写的开源框架，可以实现一连多，在学习中。 https://github...
Android之BLE编程
墨家剑客的专栏
07-26 1972
写在前面： 作为一个程序员，各种苦逼啊，作为一个Android程序员，苦逼死了。 Android手机可以使用WIFI、蓝牙和数据网络进行网络通信，那作为Android程序员，就必须得会这些了。如果不会，都不好意思给别人说你是21世纪的屌丝程序员。 通过WIFI和数据网络通信的Socket编程（基于IP的TCP、UDP、HTTP通信 ）相信大家都是驾轻就熟了。而现阶段，随着物联网的发展和蓝牙的
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值