android手机同时连接多台ble设备

最新推荐文章于 2025-05-13 00:34:51 发布
最新推荐文章于 2025-05-13 00:34:51 发布
阅读量6.5k 收藏 21
点赞数 2
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/haoguangbei/article/details/107566427

连接多台设备并实现通信功能

蓝牙连接多台设备

工作有需求，需要android手机通过蓝牙同时连接多台设备，并实时传输数据，废话不多，直接上代码。

public class BluetoothActivity extends AppCompatActivity
        implements ConnectListener,MeasuringListener,DeviceListener{
    private String TAG = this.getClass().getSimpleName()+"---";
    public static final int PERMISSION_LOCATION = 100;
    private List<BluetoothDevice> deviceList = new ArrayList<BluetoothDevice>();
    private BluetoothDevice mBluetoothDevice;
    private BluetoothService2 mBluetoothService;
    private BluetoothAdapter mBluetoothAdapter;
    private String deviceName1 = "NAME1";//蓝牙名称以此开头
    private String deviceName2 = "NAME2";//蓝牙名称以此开头
    private String deviceAddress1 = "D8:1A:**:**:**:**";
    private String deviceAddress2 = "D8:2B:**:**:**:**";
    private int deviceCount = 2;
    private ServiceConnection mServiceConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            mBluetoothService = ((BluetoothService2.LocalBinder) service).getService(); 
            mBluetoothAdapter = mBluetoothService.initBluetoothAdapter(BluetoothActivity.this);
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            mBluetoothService = null;
        }
    };

    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (null != mBluetoothService){
            unbindService(mServiceConnection);
            Intent intent = new Intent();
            intent.setAction("com.zhg.bluetooth.service");
            intent.setPackage(getPackageName());
            stopService(intent);
        }
    }

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_bluetooth);
        initUI();
        initService();
        requestPermission();
    }

    private  void initUI(){
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        switch (requestCode) {
            case PERMISSION_LOCATION:
                if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    if (Build.VERSION.SDK_INT >= 23 && !isLocationOpen(BluetoothActivity.this)) {
                        Intent enableLocate = new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS);
                        startActivity(enableLocate);
                    }
                } else {
                    Toast.makeText(this,"读取位置权限被禁用", Toast.LENGTH_SHORT).show();
                }
                break;
        }
    }

    private void initService() {
        Intent gattServiceIntent = new Intent(this, BluetoothService2.class);
        gattServiceIntent.setAction("com.zhg.bluetooth.service");
        startService(gattServiceIntent);
        bindService(gattServiceIntent, mServiceConnection, BIND_AUTO_CREATE);
    }

    private void requestPermission() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            requestPermissions(new String[]{Manifest.permission.ACCESS_COARSE_LOCATION, Manifest.permission.ACCESS_FINE_LOCATION}, PERMISSION_LOCATION);
        }
    } 

    public void onBluetoothClick(View view){
        switch (view.getId()){

            case R.id.btn_disCover:
                //扫描
                if (null != mBluetoothAdapter){
                    mBluetoothAdapter.startDiscovery();
                }else {
                    Log.e(TAG,"134 bluetoothAdapter is null");
                }
                break;

            case R.id.btn_connect:
                //链接
//                mBluetoothService.connect(device);//连接单个蓝牙
                mBluetoothService.connect(deviceList);//连接多个蓝牙
                break;

            case R.id.btn_disConnect:
                //断开链接
                mBluetoothService.disConnect();
                break;
            case R.id.btn_sendCMD:
                mBluetoothService.writeCharacteristic(deviceAddress2);
                break;
            case R.id.btn_sendCMD1:
                mBluetoothService.writeCharacteristic(deviceAddress1);
                break;
            default:
                break;
        }
    }

    private boolean isLocationOpen(final Context context){
        LocationManager manager = (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);
        //gps定位
        boolean isGpsProvider = manager.isProviderEnabled(LocationManager.GPS_PROVIDER);
        //网络定位
        boolean isNetWorkProvider = manager.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
        return isGpsProvider|| isNetWorkProvider;
    }

    BluetoothDevice device;
    @Override
    public void onBluetoothDevice(BluetoothDevice device) {
        Log.i(TAG,"deviceName is "+device.getName()+"===="+device.getAddress());
        if (device.getName()!=null) {
            if (device.getName().startsWith(deviceName1) || device.getName().startsWith(deviceName2)){
                deviceList.add(device);
                if (deviceList.size()==deviceCount) {
                    mBluetoothAdapter.cancelDiscovery();
                }
//                this.device  =device;//连接一台蓝牙时
//                mBluetoothAdapter.cancelDiscovery();
            }
        }
    } 
}

public class BluetoothService2 extends Service {

    private final String TAG = this.getClass().getName() + ">>>";
    private IBinder mBinder = new LocalBinder();
    private BluetoothAdapter mBluetoothAdapter; 
    Map<String,BluetoothGattCharacteristic> map = new HashMap<>();
    private ConnectListener mConnectListener;
    private MeasuringListener mMeasuringListener;
    private DeviceListener mDeviceListener;
    MeasuringModel measuringModel = new MeasuringModel();
    ConnectModel connectModel = new ConnectModel();
    private ArrayMap<String, BluetoothGatt> connMap = new ArrayMap<String, BluetoothGatt>();
    @Override
    public void onDestroy() {
        super.onDestroy();

        if (null != mBinder) {
            mBinder = null;
        }

    }

    public class LocalBinder extends Binder {
        public BluetoothService2 getService() {
            return BluetoothService2.this;
        }
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return mBinder;
    }

    @Override
    public boolean onUnbind(Intent intent) {
        close();
        mBinder = null;
        return super.onUnbind(intent);
    }

    /**
     * 关闭
     */
    public void close() {
        if (null != mReceiver) {
            unregisterReceiver(mReceiver);
        }
        disConnect();
    }

    public BluetoothAdapter initBluetoothAdapter(Context context) {
        BluetoothManager mBluetoothManager;
        mBluetoothManager = (BluetoothManager) getSystemService(BLUETOOTH_SERVICE);
        if (null != mBluetoothManager) {
            mBluetoothAdapter = mBluetoothManager.getAdapter();
        }

        if (null == mBluetoothAdapter) {
            mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
            if (null == mBluetoothAdapter) {
                return null;
            }
        }
        if (!mBluetoothAdapter.isEnabled()) {
            if (!mBluetoothAdapter.isEnabled()) {
                Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
                context.startActivity(enableBtIntent);
            }
        }
        registerBroadcast();
        return mBluetoothAdapter;
    }

    private void registerBroadcast(){
        IntentFilter intentFilter = new IntentFilter();
        intentFilter.addAction(BluetoothDevice.ACTION_FOUND);
        registerReceiver(mReceiver, intentFilter);
    }

    public void discoveryBluetooth() {
        if (null == mBluetoothAdapter) {
            Log.e(TAG,"method discoveryBluetooth \n mBluetoothAdapter is null");
            return;
        }
        mBluetoothAdapter.startDiscovery();
    }

    /**
     * 连接蓝牙
     * @param deviceList
     */
    public boolean connect(List<BluetoothDevice> deviceList) {
        if (deviceList!=null && deviceList.size()>0) {
            for (int i = 0; i < deviceList.size(); i++) {
                BluetoothDevice bluetoothDevice = deviceList.get(i);
                if (null == bluetoothDevice || null==bluetoothDevice.getAddress() || null == mBluetoothAdapter) {
                    Log.e(TAG, "method connect \n connect Bluetooth bluetoothDevice, address or BluetoothAdapter is null : that not initial");
                    return false;
                }
                BluetoothGatt gatt = connMap.get(bluetoothDevice.getAddress());
                if (gatt != null) {
                    gatt.disconnect();
                    gatt.close();
                    connMap.remove(bluetoothDevice.getAddress());
                }
                bluetoothDevice.connectGatt(this, false, mGattCallback);
            }
        }
        return true;
    }

    /**
     * 断开蓝牙链接
     */
    public void disConnect() {
        if (connMap!=null && connMap.size()>0) {
            for(BluetoothGatt mBluetoothGatt : connMap.values()){
                if (null == mBluetoothAdapter || null == mBluetoothGatt) {
                    continue;
                }
                mBluetoothGatt.disconnect();
                mBluetoothGatt.close();
            }
        }
    }

    public void writeCharacteristic(String address) {
        BluetoothGatt bluetoothGatt = connMap.get(address);
        BluetoothGattCharacteristic bluetoothGattCharacteristic = map.get(address);
//        hex = hex.replaceAll(" ","");
        if (null == bluetoothGattCharacteristic || null == bluetoothGatt){
            Log.e(TAG, "method writeCharacteristic \n write fail : characteristic or bluetoothGatt is null");

            return;
        }

        bluetoothGatt.setCharacteristicNotification(bluetoothGattCharacteristic, true);
        bluetoothGattCharacteristic.setValue("11111".getBytes());
        bluetoothGatt.writeCharacteristic(bluetoothGattCharacteristic);

    }
    /**
     * 蓝牙链接回调
     */
    private BluetoothGattCallback mGattCallback = new BluetoothGattCallback() {
        @Override
        public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
            String address = gatt.getDevice().getAddress();
            switch (newState) {
                case BluetoothProfile.STATE_CONNECTED:
                    System.out.println("连接成功: "+address);
                    connMap.put(address, gatt);
                    gatt.discoverServices();
                    break;
                case BluetoothProfile.STATE_DISCONNECTED:
                    if (null != mConnectListener){
                        connectModel.setConnectStatus(BluetoothProfile.STATE_DISCONNECTED);
                        connectModel.setConnectMessage("disConnected");
                        mConnectListener.onBluetoothConnect(connectModel);
                    }
                    break;
                default:
                    Log.e(TAG,"method : onConnectionStateChange \n newState is fail : newstate = "+newState);
                    break;
            }

        }

        @Override
        public void onServicesDiscovered(BluetoothGatt gatt, int status) {
            if (BluetoothGatt.GATT_SUCCESS == status) {
                displayGattServices(gatt.getServices(),gatt.getDevice().getAddress());
            }
        }

        @Override
        public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
            super.onCharacteristicRead(gatt, characteristic, status);
        }

        @Override
        public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
            super.onCharacteristicWrite(gatt, characteristic, status);
            Log.i(TAG,"write is successful");
        }

        @Override
        public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
            Log.i(TAG, gatt.getDevice().getName()+"： --receive Data is successful = "+new String(characteristic.getValue()));
            measuringModel.setMeasuringData(BluetoothValueUtil.getInstance().bytesToDemicals(characteristic.getValue()));
            mMeasuringListener.onCharacteristicChanged(measuringModel);
        }
        @Override
        public void onDescriptorWrite(BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status) {
            super.onDescriptorWrite(gatt, descriptor, status);
        }
    };
    /**
     * 获取特征值（特征UUID） 用来做与蓝牙通讯的唯一通道
     *
     * @param gattServices BluetoothGattService
     */
    private void displayGattServices(List<BluetoothGattService> gattServices, String address) {
        if (gattServices == null) {
            Log.e(TAG,"BluetoothGattService list is null");

            return;
        }
        for (BluetoothGattService gattService : gattServices) {

            List<BluetoothGattCharacteristic> gattCharacteristics = gattService.getCharacteristics();
            for (BluetoothGattCharacteristic characteristic : gattCharacteristics) {
                int property = characteristic.getProperties();
                if ((property & BluetoothGattCharacteristic.PROPERTY_WRITE) > 0 || (property & BluetoothGattCharacteristic.PROPERTY_WRITE_NO_RESPONSE) > 0 ){
                    if (characteristic.getUuid().toString().equals("0003cdd2-0000-1000-8000-00805f9b0131")) {
                        map.put(address,characteristic);
                        notification(characteristic,address);
                    }
                }
                if ((property & BluetoothGattCharacteristic.PROPERTY_READ) > 0) {
                    notification(characteristic,address);
                }
                if ((property & BluetoothGattCharacteristic.PROPERTY_NOTIFY) > 0) {
                    notification(characteristic,address);
                }

            }
        }
        SystemClock.sleep(2000);
        connectModel.setConnectStatus(BluetoothProfile.STATE_CONNECTED);
        connectModel.setConnectMessage("已链接");
        mConnectListener.onBluetoothConnect(connectModel);

    }

    private void notification(BluetoothGattCharacteristic gattCharacteristic,String address) {
        boolean success = connMap.get(address).setCharacteristicNotification(gattCharacteristic, true);

        if (!success) {
            Log.e(TAG, "BluetoothGatt setCharacteristicNotification is fail : bluetoothGattCharacteristicUUID = " + gattCharacteristic.getUuid());
            return;
        }
        for (BluetoothGattDescriptor dp : gattCharacteristic.getDescriptors()) {
            if (dp == null) {
                continue;
            }
            if ((gattCharacteristic.getProperties() & BluetoothGattCharacteristic.PROPERTY_NOTIFY) != 0) {
                dp.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
            }
            connMap.get(address).writeDescriptor(dp);
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private BroadcastReceiver mReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            switch (intent.getAction()) {
                case BluetoothDevice.ACTION_FOUND:
                    break;
            }
        }
    };
}

本项目csdn下载地址：https://download.youkuaiyun.com/download/haoguangbei/12658068
github地址：https://github.com/haogb123456/BluetoothDemo1

注：本项目在他人原有项目上进行的功能上新增，详情见github链接。

Android BLE 的扫描配对、连接流程梳理
[byte轻骑兵] 的技术小窝！
08-31 5671
Android BLE（Bluetooth Low Energy，低功耗蓝牙）连接流程涉及多个步骤，主要包括扫描、配对、连接三个阶段。
Android蓝牙高级操作（多连接）
Eric的专栏
04-14 8029
最近一直在搞蓝牙
连接多个BLE设备（Android）
04-15
用于连接多个BLE设备的小Demo，不过只有收数据的功能，没有发数据的功能。注意：请用Android studio打开
android 蓝牙BLE多连接
mikejaps的博客
11-09 6106
最近做蓝牙BLE的开发，此项目和网上别人的稍微有点不同，手机需要连接多个BLE设备，此部分网上的资料很少，所以拿出来和大家分享一下 //初始化private void initBt() { manager = BluetoothManager.getInstance(); manager.setContext(this); if (!getPackageManager().h
多个BLE设备连接示例：Android平台BLE连接利器
最新发布
gitblog_06741的博客
05-13 982
多个BLE设备连接示例：Android平台BLE连接利器 【下载地址】多个BLE设备连接示例 这是一个专为Android平台设计的开源示例项目，旨在展示如何同时连接多个BLE设备并实现数据接收功能。项目基于Android Studio开发，适合对蓝牙低功耗技术感兴趣的开发者学习和参考。通过简单的配置，您可以快速上手并探索...
Andorid BLE的连接多个设备的实现
美丽心情
05-31 2283
最近回头一看，还有很多公司是在做智能家居的项目，当然 ， 这必修回使用到BLE的通讯协议。目前关于BLE的帖子的千千万万，但是多连接的却是很少的，所以，这篇就来分析下BLE的多连接 1，BLE设备得我扫描。这个直接调用btAdapter的startLeScan即可。 相对应得，停止扫描调用stopLeScan(). // 开始扫描 public void startLeScan() { if (mBluetoothAdapter != null) { mBluetoothAdapter.
android 连接多个ble,Android BLE多个连接
weixin_39878247的博客
05-26 1321
小编典典我想知道如何实现要实现多个BLE连接，您必须存储多个BluetoothGatt对象并将这些对象用于不同的设备。要存储多个连接对象，BluetoothGatt可以使用Map<>private Map connectedDeviceMap;在服务上onCreate初始化MapconnectedDeviceMap = new HashMap();然后，在呼叫device.connec...
Android手机与多个BLE设备通信
Mark_sssss的专栏
04-15 5699
BLE是蓝牙4.0的核心Profile，主打功能是快速搜索，快速连接，超低功耗保持连接和传输数据，弱点是数据传输速率低，由于BLE的低功耗特点，因此普遍用于穿戴设备。Android 4.3才开始支持BLE API。本文改自Android Sample： BluetoothLeGatt，支持连接多个设备的功能
Android ble连接过程,Android开发之ble蓝牙
weixin_39521520的博客
05-25 1485
前言由于自己工作中需要开发ble的项目,于是在折腾了一段时间后也有所了解,便想写下来分享给大家,同时对自己的知识也是一种巩固1.BLE介绍BLE是Bluetooth Low Energy的缩写，又叫蓝牙4.0，区别于蓝牙3.0和之前的技术。BLE前身是NOKIA开发的Wibree技术，主要用于实现移动智能终端与周边配件之间的持续连接，是功耗极低的短距离无线通信技术，并且有效传输距离被提升到了100...
手机模拟BLE设备发送广播App
03-21
其中一台Android手机T模拟发出广播，作为BLE设备（周边设备），这个BLE设备在生产环境中就是我们用到的气体检测传感器、智能手环、体重秤、血压计等等； 另一台Android手机B，作为中央设备，搜索手机T发出的广播并...
Android实现一个apk连接两个ble设备
feelinghappy的专栏
10-04 840
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。 本文链接：https://blog.youkuaiyun.com/csdn_kike/article/details/69793362 声明：代码基于网上某个小工程改的，如果涉及侵权，请联系本人，立马删除。 曾经做过一个小玩意，尝试把两个ble单片机设备都连在一个apk上，同时通信。网上可以找到类似的，...
android ble多连接,GitHub - q735510971/AndroidBle: 蓝牙连接库，支持同时连接多个设备...
weixin_42306083的博客
05-27 730
AndroidBle蓝牙2017/03/15项目发布到 JitPack构建方式：在根目录： build.gradle 文件中添加：allprojects {repositories {...maven { url 'https://jitpack.io' }}}在app的 build.gradle 文件中添加：dependencies {compile 'com.github.eson-yunfe...
Android 经典蓝牙连接，多台蓝牙设备同时连接，全站仪连接
01-15
1.安卓平台实现蓝牙连接，可以与全站仪蓝牙直接连接 2.支持同时连接多个蓝牙设备，自定义最大连接数 3.支持同时做蓝牙主机和从机，发起连接或者等待连接
Android Ble 一连多笔记
delin11的专栏
08-13 2923
BLE Android 同时多设备连接。
ESP8266 WiFi模块如何联网？
wy122222222的博客
11-18 4990
一、ESP8266系列模块是什么？ ESP8266系列无线模块是一个经济高效的WIFI SOC模块，支持标准IEEE802.11b/g/n协议，内置完整的TCP/IP协议栈。 用户可以使用此系列模块向现有设备添加网络功能，也可以构建独立的网络控制器。 二、ESP8266系列模块有什么特点？ 支持STA、AP、STA+AP动作模式 体积非常小的802.11b/g/n WiFi SOC模块 内置10bit高精度ADC 采用低功率32位CPU，兼作应用程序处理器 支持USART、GPIO、IIC、PWM、ADC、
安卓蓝牙4.0以上连接多台设备并接收蓝牙设备数据
a1989214的博客
05-09 1万+
前沿: 在我之前写的代码中都没有实现蓝牙连接多个设备，由于时间的原因没有进行更改。iOS端实现 蓝牙多个连接确实比安卓的方便，本身利用官方的Demo就可以实现多台连接，只不过自己利用view加以区分就可以。到此蓝牙4.0之前是通过scoket连接多台设备，不过感觉传输的稳定性没有 BluetoothGatt稳定所以本次我利用BluetoothGatt来连接 蓝牙多台设备1.由于连接多台设备 我只讲
Android开发——蓝牙多设备连接（四）
热门推荐
Mr_Four
09-20 1万+
讲述蓝牙多设备连接的方法，设备的自动连接，怎么区分蓝牙设备返回的数据，实现蓝牙信息和返回结果进行持久化等。
利用Android手机模拟BLE设备与中央设备交互
另一台Android手机（中央设备）需要使用BluetoothLeScanner开始搜索周边的BLE广播设备。扫描过程是异步的，需要提供一个ScanCallback来处理搜索到的结果。一旦中央设备搜索到广播设备，就可以发起连接请求。 5. ...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值