androidBLE蓝牙

最新推荐文章于 2024-05-02 08:50:21 发布
最新推荐文章于 2024-05-02 08:50:21 发布
阅读量2.3k 收藏 16
点赞数 7
分类专栏： android入门教学 工具类 android基础 文章标签： android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hdhhd/article/details/122195142
版权

参考资料：

Android BLE 蓝牙开发入门 - 简书     //  部分方法过时

android蓝牙BLE（一） —— 扫描 - 简书   //分四部讲解  比较详细  推荐

demo1下载链接：service后台读取数据通知广播更新界面

图：

 

 demo2下载链接：BlueTooth_Test.zip-Android文档类资源-CSDN下载

添加权限

    <!--    使用蓝牙所需要的权限-->
    <uses-permission android:name="android.permission.BLUETOOTH"/>
    <!--    使用扫描和设置蓝牙的权限（申明这一个权限必须申明上面一个权限）-->
    <uses-permission android:name="android.permission.BLUETOOTH_ADMIN"/>
    <!--    gps-->
    <uses-feature android:name="android.hardware.location.gps" />
    <!-- 模糊定位-->
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>
    <!-- 精准定位-->
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>

蓝牙扫描需要开启位置权限：

targetSdkVersion 28以前需要动态申请开启模糊定位，targetSdkVersion 大于28需要开启精准定位，否则扫描不到蓝牙设备。

main_layout:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context=".MainActivity">

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:gravity="center_vertical"
        android:orientation="horizontal">

        <LinearLayout
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:orientation="vertical">

            <Button
                android:id="@+id/btn_open_bluetooth"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="扫描蓝牙" />

            <Button
                android:id="@+id/btn_stop_LeScan_bluetooth"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="得到的数据" />
        </LinearLayout>

        <TextView
            android:id="@+id/btn_Riis"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:gravity="center" />

    </LinearLayout>


    <ListView
        android:id="@+id/lv_ble_table"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />

</LinearLayout>

MainActivity:

package youli.com.example.administrator.bluetooth_servise_bread;

import android.Manifest;
import android.app.Activity;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothManager;
import android.bluetooth.le.BluetoothLeScanner;
import android.bluetooth.le.ScanCallback;
import android.bluetooth.le.ScanResult;
import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.ServiceConnection;
import android.content.pm.PackageManager;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Looper;
import android.text.TextUtils;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
import android.widget.Toast;

import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;

import java.util.ArrayList;
import java.util.List;

public class MainActivity extends AppCompatActivity {

    private TextView text_data;
    private TextView text_rssi;

    private final int REQUEST_ENABLE_BT = 1;
    private BleService bleService;
    private BluetoothAdapter bluetoothAdapter;
    private BluetoothLeScanner bluetoothLeScanner;
    private BluetoothManager bluetoothManager; //蓝牙管理类

    private List<BluetoothDevice> mBluetoothDeviceList;
    private List<String> mRssiList;
    private RecyclerView mRvDeviceList;
    private Button mBtnScan;
    private DeviceListAdapter mDeviceListAdapter;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        getLOCATION();
        initView();
        initBle();
    }


    private void initView() {
        text_data = findViewById(R.id.text_data);
        text_rssi = findViewById(R.id.text_rssi);

        mRvDeviceList = (RecyclerView) findViewById(R.id.rv_device_list);
        mBtnScan = (Button) findViewById(R.id.btn_scan);
        mBtnScan.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                scanBleDevice();
            }
        });

        // 蓝牙设备列表
        mBluetoothDeviceList = new ArrayList<>();
        // 蓝牙设备RSSI列表
        mRssiList = new ArrayList<>();
        mDeviceListAdapter = new DeviceListAdapter(mBluetoothDeviceList, mRssiList);
        mRvDeviceList.setLayoutManager(new LinearLayoutManager(this));
        mRvDeviceList.setAdapter(mDeviceListAdapter);

        // 连接蓝牙设备
        mDeviceListAdapter.setOnItemClickListener(new DeviceListAdapter.OnItemClickListener() {
            @Override
            public void onItemClick(View view, int position) {
                Toast.makeText(MainActivity.this, "开始连接", Toast.LENGTH_SHORT).show();
                bluetoothLeScanner.stopScan(scanCallback);

                bleService.connect(bluetoothAdapter, mBluetoothDeviceList.get(position).getAddress());
            }
        });

        // 绑定服务
        Intent intent = new Intent(MainActivity.this, BleService.class);
        bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE);


        //注册广播
        IntentFilter filter = new IntentFilter();
        filter.addAction(BleService.ACTION_GATT_CONNECTED);
        filter.addAction(BleService.ACTION_GATT_DISCONNECTED);
        filter.addAction(BleService.ACTION_GATT_SERVICES_DISCOVERED);
        filter.addAction(BleService.ACTION_DATA_AVAILABLE);
        filter.addAction(BleService.ACTION_CONNECTING_FAIL);
        filter.addAction(BleService.EXTRA_RSSI_DATA);
        BleReceiver bleReceiver = new BleReceiver();
        registerReceiver(bleReceiver, filter);

    }

    /**
     * 初始化数据
     */
    private void initBle() {
        bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
//        bluetoothManager = (BluetoothManager) getSystemService(Context.BLUETOOTH_SERVICE);
//        bluetoothAdapter = bluetoothManager.getAdapter();
        if (bluetoothAdapter == null) {
            Toast.makeText(this, "蓝牙不可用", Toast.LENGTH_LONG).show();
            return;
        }
        if (!bluetoothAdapter.isEnabled()) {
            Intent intent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
            startActivityForResult(intent, REQUEST_ENABLE_BT);
            return;
        }
        scanBleDevice();
    }

    /**
     * 搜索蓝牙设备
     */
    private void scanBleDevice() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) {

            bluetoothLeScanner = bluetoothAdapter.getBluetoothLeScanner();
            bluetoothLeScanner.stopScan(scanCallback);
            bluetoothLeScanner.startScan(scanCallback);

            new Handler(Looper.getMainLooper()).postDelayed(new Runnable() {
                @Override
                public void run() {
                    bluetoothLeScanner.stopScan(scanCallback);
                }
            }, 10000);
        }
    }

    /**
     * 搜索蓝牙设备回调
     */
    ScanCallback scanCallback = new ScanCallback() {
        @Override//扫描结果
        public void onScanResult(int callbackType, ScanResult result) {
            super.onScanResult(callbackType, result);

            BluetoothDevice bluetoothDevice = result.getDevice();
            int rssi = result.getRssi();

            if (!TextUtils.isEmpty(bluetoothDevice.getName())) {
                if (!mBluetoothDeviceList.contains(bluetoothDevice)) {
                    mBluetoothDeviceList.add(bluetoothDevice);
                    mRssiList.add(String.valueOf(rssi));
                    mDeviceListAdapter.notifyDataSetChanged();
                }
            }
        }

        @Override//批量返回扫描结果
        public void onBatchScanResults(List<ScanResult> results) {
            super.onBatchScanResults(results);
        }

        @Override //扫描失败
        public void onScanFailed(int errorCode) {
            super.onScanFailed(errorCode);
        }
    };


    ServiceConnection serviceConnection = new ServiceConnection() {

        @Override //在线服务连接
        public void onServiceConnected(ComponentName name, IBinder service) {
//            BleService.LocalBinder localBinder= (BleService.LocalBinder) service;
            bleService = ((BleService.LocalBinder) service).getService();

        }

        @Override//OnService断开连接
        public void onServiceDisconnected(ComponentName name) {
            bleService = null;
        }
    };


    private List<Object> mlist = new ArrayList<>();//存储蓝牙传递的最终数据值

    /**
     * 广播
     */
    private class BleReceiver extends BroadcastReceiver {

        @Override
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            if (TextUtils.isEmpty(action)) {
                return;
            }
            switch (action) {
                case BleService.ACTION_GATT_CONNECTED:
                    Toast.makeText(MainActivity.this, "蓝牙已连接", Toast.LENGTH_SHORT).show();
                    break;

                case BleService.ACTION_GATT_DISCONNECTED:
                    Toast.makeText(MainActivity.this, "蓝牙已断开", Toast.LENGTH_SHORT).show();
                    bleService.release();
                    break;

                case BleService.ACTION_CONNECTING_FAIL:
                    Toast.makeText(MainActivity.this, "蓝牙已断开", Toast.LENGTH_SHORT).show();
                    bleService.disconnect();
                    break;

                case BleService.ACTION_DATA_AVAILABLE:

                    Log.i("蓝牙", "收到的数据：");
                    byte[] characteristic = intent.getByteArrayExtra(BleService.ACTION_DATA_AVAILABLE);
                    if (characteristic[0] == -86) {
                        mlist.clear();
                        for (int i = 0; i < characteristic.length; i++) {
                            mlist.add(characteristic[i]);
                        }
                    } else if (characteristic[0] != -86 && mlist.size() > 0) {
                        for (int i = 0; i < characteristic.length; i++) {
                            mlist.add(characteristic[i]);
                        }
                    }

                    if (mlist.size() == 4) {
                        String values = ByteUtils.byte2HexStr(mlist);
                        values = values.substring(2, 6);
                        Integer ble_value = Integer.parseInt(values, 16);
                        Log.i("TAG", "最终值" + values + "：最终值转换16进制：" + ble_value + "毫米");
                        text_data.setText("距离障碍物：" + ble_value + "  毫米");
                        mlist.clear();
                    }

                    break;

                case BleService.EXTRA_RSSI_DATA:
                    int rssi = intent.getIntExtra(BleService.EXTRA_RSSI_DATA, 0);
                    Log.i("蓝牙", "收到的信号值：" + rssi);
                    text_rssi.setText("当前蓝牙RSSI：" + rssi);
                    break;
                default:
                    Log.i("TAG", "当前当前当前当前当前当前当前当前");
                    break;

            }
        }
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
        super.onActivityResult(requestCode, resultCode, data);

        if (resultCode != Activity.RESULT_OK) {
            return;
        }

        if (resultCode == REQUEST_ENABLE_BT) {
            // 搜索蓝牙设备
            scanBleDevice();
        }
    }


    /**
     * 6.0以上需要动态开启位置权限，否则无法扫描蓝牙设备
     */
    private void getLOCATION() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            if (this.checkSelfPermission(Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
                requestPermissions(new String[]{Manifest.permission.ACCESS_FINE_LOCATION}, 1);
            }
        }
    }
}


daqiBluetoothGattCallback:
package youli.com.example.administrator.bluetooth_test;

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.util.Log;

import androidx.annotation.RequiresApi;

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

@RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN_MR2)
public class daqiBluetoothGattCallback extends BluetoothGattCallback {

    private BluetoothGatt   bluetoothGatt;

    private Refresh refresh;

    public daqiBluetoothGattCallback(Refresh refresh) {
        this.refresh = refresh;
    }

    interface Refresh {
        void OnClick_Connected(); //连接成功回调

        void OnClick_Disconnect();//断开连接回调

        void OnClick_Riis(int value);      //型号强度回调

        void OnClick_Refresh(int value);  //更新数据回调
    }

    //定义重连次数
    private int reConnectionNum = 0;
    //最多重连次数
    private int maxConnectionNum = 3;

    private List mlist_bleValue = new ArrayList();

    /**
     * UUID设置不对，不会调用onCharacteristicChanged
     */
    //定义需要进行通信的ServiceUUID
    private UUID mServiceUUID = UUID.fromString("0000fee0-0000-1000-8000-00805f9b34fb");
    //定义需要进行通信的CharacteristicUUID特征标识（读取数据）
    private UUID mCharacteristicUUID = UUID.fromString("0000fee1-0000-1000-8000-00805f9b34fb");
    //定义需要进行通信的ServiceUUID特征标识（发送数据时用到）
    private UUID CHARACTERISTIC_WRITE_UUID = UUID.fromString("0000fee1-0000-1000-8000-00805f9b34fb");
    //定义需要进行通信的DescriptorUUID
    private UUID mDescriptorUUID = UUID.fromString("00002902-0000-1000-8000-00805f9b34fb");
    //64:CF:D9:0A:F7:81


    @Override//连接状态回调
    public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {

        if (status == BluetoothGatt.GATT_SUCCESS) {  //正在执行连接操作

            if (newState == BluetoothProfile.STATE_CONNECTED) {  //设备已连接
                //连接后的操作 发现蓝牙服务，也就是 Service
                Log.i("TAG", "设备已连接");
                gatt.discoverServices();  //发现服务成功后，会触发BluetoothGattCallback#onServicesDiscovered()回调
                if (refresh != null) {
                    refresh.OnClick_Connected();
                }
            } else if (newState == BluetoothProfile.STATE_DISCONNECTED) { //断开连接
                Log.i("TAG", "断开连接");

                if (refresh != null) {
                    refresh.OnClick_Disconnect();
                }
            }
        } else {//连接出错  执行重连
            /**
             * 异常码
             *  133 ：连接超时或未找到设备。
             *  8 ： 设备超出范围
             *  22 ：表示本地设备终止了连接
             */

            //重连次数不大于最大重连次数
            if (reConnectionNum < maxConnectionNum) {
                //重连次数自增
                reConnectionNum++;
                //重新连接设备
                boolean a = gatt.connect();
            } else {
                //断开连接，返回连接失败回调
                Log.i("TAG", "设备重连失败");
            }
        }
    }


    @Override  //服务发现回调
    public void onServicesDiscovered(BluetoothGatt gatt, int status) {


        if (status == BluetoothGatt.GATT_SUCCESS) { // 发现蓝牙服务成功

//            //        获取UUID
//            List<BluetoothGattService> gattServicesList = gatt.getServices();  //全部服务
//            for (int i = 0; i < gattServicesList.size(); i++) {
//                Log.d("TAG1", " 服务  UUID=" + gattServicesList.get(i).getUuid());
//                List<BluetoothGattCharacteristic> characteristics = gattServicesList.get(i).getCharacteristics();//全部特征
//                for (int j = 0; j < characteristics.size(); j++) {
//                    Log.d("TAG1", " 特征  UUID=" + characteristics.get(j).getUuid());
//
//                    List<BluetoothGattDescriptor> descriptors = characteristics.get(j).getDescriptors();//全部描述符
//                    for (int a = 0; a < descriptors.size(); a++) {
//                        Log.d("TAG1", " 描述符  UUID=" + descriptors.get(a).getUuid());
//                    }
//                }
//            }
//            //上面代码得到的全部uuid   至于用那个需要试过才知道
//            服务  UUID=00001800-0000-1000-8000-00805f9b34fb
//            特征  UUID=00002a00-0000-1000-8000-00805f9b34fb
//            特征  UUID=00002a01-0000-1000-8000-00805f9b34fb
//            特征  UUID=00002a02-0000-1000-8000-00805f9b34fb
//            特征  UUID=00002a03-0000-1000-8000-00805f9b34fb
//            特征  UUID=00002a04-0000-1000-8000-00805f9b34fb
//            服务  UUID=00001801-0000-1000-8000-00805f9b34fb
//            特征  UUID=00002a05-0000-1000-8000-00805f9b34fb
//            描述符  UUID=00002902-0000-1000-8000-00805f9b34fb  使用
//            服务  UUID=0000fee0-0000-1000-8000-00805f9b34fb    使用
//            特征  UUID=0000fee1-0000-1000-8000-00805f9b34fb    使用
//            描述符  UUID=00002902-0000-1000-8000-00805f9b34fb
//            服务  UUID=0000180a-0000-1000-8000-00805f9b34fb
//            特征  UUID=00002a23-0000-1000-8000-00805f9b34fb
//            特征  UUID=00002a24-0000-1000-8000-00805f9b34fb
//            特征  UUID=00002a25-0000-1000-8000-00805f9b34fb
//            特征  UUID=00002a26-0000-1000-8000-00805f9b34fb
//            特征  UUID=00002a27-0000-1000-8000-00805f9b34fb
//            特征  UUID=00002a28-0000-1000-8000-00805f9b34fb
//            特征  UUID=00002a29-0000-1000-8000-00805f9b34fb
//            特征  UUID=00002a2a-0000-1000-8000-00805f9b34fb
//            特征  UUID=00002a50-0000-1000-8000-00805f9b34fb


            BluetoothGattService gattServicesList = gatt.getService(mServiceUUID);
            if (gattServicesList != null) {
                BluetoothGattCharacteristic gattCharacteristic = gattServicesList.getCharacteristic(mCharacteristicUUID);
                if (gattCharacteristic != null) {


                    //获取其对应的通知Descriptor
                    BluetoothGattDescriptor descriptor = gattCharacteristic.getDescriptor(mDescriptorUUID);
                    if (descriptor != null) {
                        //开启 Android 端接收通知的开关，还需要往 Characteristic 的 Descriptor 属性写入开启通知的数据开关使得当硬件的数据改变时，主动往手机发送数据。
                        descriptor.setValue(BluetoothGattDescriptor.ENABLE_INDICATION_VALUE);//开启 Android 端接收通知
                        boolean descriptorResult = gatt.writeDescriptor(descriptor);

                        /**
                         * readCharacteristic单向通讯
                         * setCharacteristicNotification双向通讯
                         */
//                    boolean a = gatt.readCharacteristic(gattCharacteristic);   //当成功读取特征值时，会触发BluetoothGattCallback#onCharacteristicRead()回调。
                        boolean b = gatt.setCharacteristicNotification(gattCharacteristic, true);//当成功读取特征值时，会触发BluetoothGattCallback#onCharacteristicRead()回调。


                    }
                }
            } else {
                Log.e("onServicesDiscovered", "获取服务失败:" + status);
            }
        }
    }

    @Override  //读取到特征值回调
    public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
        if (status == BluetoothGatt.GATT_SUCCESS) {
            byte[] _b = characteristic.getValue();
            Log.i("TAG", "6: " + _b);
            Log.i("TAG", "7: " + byte2HexStr(_b));
            //获取写入到外设的特征值
            byte[] value = characteristic.getValue();
            String a = byte2HexStr(value);
            Log.i("TAG", "5:" + gatt.getDevice().getName() + " 读取成功 " + characteristic.getValue() + ":转换16进制：" + a);
        }
    }


    @Override//特征写入回调
    public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
        super.onCharacteristicWrite(gatt, characteristic, status);
    }


    @Override //外设特征值改变回调
    public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
        byte[] value = characteristic.getValue();
        String a = byte2HexStr(value);
        Log.i("TAG", a + "：值");


        if (value[0] == -86) {   //此处-86  打印出-86  转换后得到 AA   ，获取到完整数据 AA001FBB，取中间四位 转换16 进制
            mlist_bleValue.clear();
            for (int i = 0; i < value.length; i++) {
                mlist_bleValue.add(value[i]);
            }
        } else if (value[0] != -86 && mlist_bleValue.size() > 0) {
            for (int i = 0; i < value.length; i++) {
                mlist_bleValue.add(value[i]);
            }
        }

        if (mlist_bleValue.size() == 4) {
            String values = byte2HexStr(mlist_bleValue);
            values = values.substring(2, 6);
            Integer ble_value = Integer.parseInt(values, 16);
            Log.i("TAG", "最终值" + values + "：最终值转换16进制：" + ble_value + "毫米");

            if (refresh != null) {
                refresh.OnClick_Refresh(ble_value);
            }

            mlist_bleValue.clear();

            //实时显示信号强度
            gatt.readRemoteRssi();    //信号强弱回调触发BluetoothGattCallback. onReadRemoteRssi（）回调

        }
    }


    @Override //描述写入回调
    public void onDescriptorWrite(BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status) {
        super.onDescriptorWrite(gatt, descriptor, status);
    }

    @Override  //设备信号强度回调
    public void onReadRemoteRssi(BluetoothGatt gatt, int rssi, int status) {

//        Log.i("TAG", "信号强度"+rssi);

        if (refresh != null) {
            refresh.OnClick_Riis(rssi);
        }
    }


    /**
     * 转换成16进制大写字符串
     *
     * @param b
     * @return
     */
    public static String byte2HexStr(byte[] b) {
        String stmp;
        StringBuilder sb = new StringBuilder();
        for (int n = 0; n < b.length; n++) {
            stmp = Integer.toHexString(b[n] & 0xFF);
            sb.append((stmp.length() == 1) ? "0" + stmp : stmp);
        }
        return sb.toString().toUpperCase().trim();
    }

    /**
     * List集合转换成16进制大写字符串
     *
     * @param b
     * @return
     */
    public static String byte2HexStr(List b) {
        String stmp = "";
        StringBuilder sb = new StringBuilder();
        for (int n = 0; n < b.size(); n++) {
            byte bb = (byte) b.get(n);
            stmp = Integer.toHexString(bb & 0xFF);
            sb.append((stmp.length() == 1) ? "0" + stmp : stmp);
        }
        return sb.toString().toUpperCase().trim();
    }


}

继承

extends BluetoothGattCallback：

BluetoothGattCallback是连接后进行的一系列操作的回调，例如连接和断开连接的回调，发现服务的回调，成功写入数据，成功读取数据，信号值的回调等等。

注释都比较详细

谈情不如逗狗.
关注
  • 7
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android BLE设备蓝牙通信框架BluetoothKit
风语的专栏
08-29 2万+
这个框架源于目前一个智能家居APP项目，是蓝牙部分基础模块，用于蓝牙设备扫描、连接、通知等。由于目前接入的蓝牙设备大多为低功耗蓝牙设备，所以本框架暂不支持经典蓝牙的连接。项目地址： https://github.com/dingjikerbo/BluetoothKit先介绍本框架的特点： 一、支持经典蓝牙和BLE蓝牙混合扫描，支持自定义扫描策略 作为智能家居平台，接入的设备包括经典蓝牙和BLE，
（Android）低功耗蓝牙（BLE）开发一文全（详）解
zl4302647的博客
08-25 9030
蓝牙ble android
Android BLE蓝牙4.0开发详解
mengzhengjie的专栏
08-05 3926
http://blog.csdn.net/chenliqiang12345678/article/details/50504406           这篇博客主要讲解 蓝牙 BLE 的用法。在讲解之前先讲一些概念性的东西，对于之前没接触过蓝牙开发，现在手上又有个蓝牙BLE项目需要做的人，先看下这些概念还是很重要的。因为我之前就是这样，之前没有接触过蓝牙方面的开发，然后来了个
安卓基于BLE的蓝牙开发入门
最新发布
2401_84545747的博客
05-02 921
分享一份工作1到5年以上的Android程序员架构进阶学习路线体系，希望能对那些还在从事Android开发却还不知道如何去提升自己的，还处于迷茫的朋友！阿里P7级Android架构师技术脑图；查漏补缺，体系化深入学习提升**全套体系化高级架构视频；**七大主流技术模块，视频+源码+笔记有任何问题，欢迎广大网友一起来交流网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化学习资料的朋友，可以戳这里获取。
Ble低功耗蓝牙开发基础与实践
sgf012112130的博客
02-24 1451
通过定义不同的服务和特征值，设备可以提供不同的功能和操作，如传感器数据、控制命令等。通过BLE广播，设备可以宣布自身的存在、提供基本的信息和服务，以便其他设备发现和与之进行进一步的通信。通过广播，BLE设备可以以一种无连接的方式向周围的设备发送信息，以便其他设备能够发现它们并建立连接。需要注意的是，同一个设备在不同的场景下可能同时扮演中央设备和外围设备的角色，例如智能手机可以作为中央设备连接传感器设备，但也可以作为外围设备提供服务给其他设备连接。描述符是可选的，并提供关于特征值的元数据，如单位、权限等。
Android蓝牙开发系列文章-玩转BLE开发（一）
马小橙的专栏
03-25 2410
我们在《Android蓝牙开发系列文章-策划篇》中计划讲解一下蓝牙BLE，现在开始第一篇：Android蓝牙开发系列文章-玩转BLE开发（一）。计划要写的BLE文章至少分四篇，其他三篇分别讲解：BLE Server端编码（用手机模拟外围设备），BLE Beacon功能，BLE设备通信（利用自有协议实现Client和Server端通信，在Server端信息改变时，自动上报给Client）。 本文主...
Android BLE蓝牙例子（包括android版Lightblue）实例源码
01-14
Android_Lightblue.apk是Android版的lightblue，在进行ble开发的时候用该app作为辅助工具还是非常不错的，功能较Bluetooth4_3 BLEDemo 这两个demo都强大。不过Android_Lightblue.apk在android5.0以上的版本手机上...
Android ble 蓝牙库
03-13
本Android BLE蓝牙库是为了简化开发者对BLE设备的操作而设计的，它提供了一个方便、高效的接口，使开发者能够快速集成到自己的应用程序中。 一、BLE简介 Bluetooth Low Energy，通常称为BLE或Bluetooth Smart，是...
Android BLE蓝牙开发示例.rar
04-14
**Android BLE蓝牙开发详解** Android Bluetooth Low Energy (BLE)，也称为Bluetooth Smart，是蓝牙技术的一种新标准，旨在降低功耗并提高设备之间的通信效率。它特别适用于那些需要长时间运行且电池寿命有限的...
Android BLE 蓝牙快速开发框架
04-05
作者Jasonchenlijian，源码FastBle，Android BLE 蓝牙快速开发框架，使用回调方式处理：scan、connect、notify、indicate、write、read等一系列蓝牙操作。每一个characteristic会与一个callback形成一一对应的监听...
android ble 蓝牙低功耗 demo
04-10
在Android平台上，蓝牙低功耗（Bluetooth Low Energy, BLE）技术是一种广泛应用于物联网(IoT)设备通信的技术，它提供了一种高效、节能的方式来进行设备间的短距离通信。本"android ble 蓝牙低功耗 demo"是针对这一...
Android 蓝牙BLE开发从官方源码demo开始（二）
ChessLuo
12-26 5315
一、前言 在上一篇文章Android 蓝牙BLE开发从官方源码demo开始（一）我们已经看了官方的demo，知道了怎么开始配置Android蓝牙4.0，并且也成功地进行扫描并获取回调的蓝牙设备参数，然后对参数进行处理展示，其中第一个参数device，表示一个远程蓝牙设备，里面有它独有的蓝牙地址Address和Name；我们要拿到这个设备Address进行蓝牙连接和读写操作。 谷歌给我们提供了官...
Android BLE教程(和单片机通信)
a353183177的专栏
11-22 2768
Android BLE教程 前言：若你你一个电子爱好者，若你酷爱编程，那我分享一个Android BLE application的开发方法，让你可以使用手机和单片机结合，使用手机控制单片机，做一些更有趣的东西，下面开始讲解如何开发一个Android BLE application，参考谷歌官方教程: https://developer.android.com/guide/topics/conne
android蓝牙ble发送广播,安卓源码中低功耗蓝牙BLE传统广播避坑指南
weixin_30019895的博客
05-25 2167
BLE广播避坑指南前几天和同事一起讨论基于蓝牙BLE实现的current time profile功能，发现不少安卓源码问题。那这篇文章我们就来扒一扒安卓源码中涉及BLE广播的那些坑，为蓝牙开发者少走些弯路尽点绵薄之力。对BLE传统广播还不了解的小伙伴建议提前了解相关知识，可以查看我前一篇文章《低功耗蓝牙BLE传统广播总结》。使能一个传统BLE广播，需要设置参数、数据，使能广播这几个流程，每个流程...
Android面试刨根问底之常用源码篇（二）：OkHttp, Retrofit,自定义View源码分析总结
weixin_44339238的博客
01-14 422
本着针对面试负责任的态度，记录面试过程中各个知识点，而不是入门系列，如果有不懂的自行学习。 目前总结了以下几个方面： Android优化 HashMap分析 Handler源码分析 OkHttp分析 Retrofit分析 自定义View 由于篇幅原因拆分成两个部分分享，上一篇讲解了前面三个方面，今天讲剩下的三个部分，之后的还会持续更新。 OkHttp分析 Okhttp是对Socket的封装。有三个主要的类，Request，Response，Call默认使用new OkHttpCli...
【Android】BLE:蓝牙低功耗基础
北冥有渔的博客
10-31 932
蓝牙是一种短距离通信的无线电技术。特点：1.分散式网络结构2.点对点或多点通信3.快跳频和短包技术4.工作在2.4GHz ISM（工业，科学，医学缩写）频段5.时分全双工传输蓝牙4.0规范（2012年）开始支持低功耗蓝牙（Bluetooth Low Energy，BLE），低功耗运行和待机可以使得一颗纽扣电池运行一年。
Android蓝牙BLE的详细讲解
edmond999的专栏
09-05 1231
我今天分享的主题是 Android 上低功耗蓝牙的实践。这个主题比较小众。我在过去的一年多的时间里，主要是在做低功耗蓝牙相关的开发。接触过程中发现，BLE 的开发和通常的 Android APP 的开发有点不一样，这里需要访问硬件资源，而且涉及到一些协议相关的内容，而且这方面的资料也比较少。今天我从 Android 开发者的角度，来分享一下低功耗蓝牙开发实践。 Slide 02今天分享的内容，主...
Android 8.0 蓝牙唤醒 Ble 锁屏 保活 后台 持续扫描 进程拉活 自动唤醒
TracyEminem的博客
12-26 1万+
主要是api的说明，嫌啰嗦的可以直接看demo，demo中有个检测锁屏时间重复开启扫描的代码，主要是如果APP没有获得电量或者后台运行的权限，只能持续后台运行几小时。 这个demo的作用是实现8.0以后的后台监测到特定蓝牙信号自动唤醒APP的功能，首先需要另外一个装了可以发射蓝牙信号软件的手机，我这边是选取的ios平台上的lightblue，然后在这个软件里面新建一个虚拟设备名称是要demo搜索...
nmap扫描常用命令详解
热门推荐
鹿鸣天涯
09-12 2万+
常用命令：-vv是详细信息 nmap -vv -sT -sV -Pn 192.168.200.14 -p 1433 nmap -sT -sV -Pn 192.168.200.14 -p 1433 -sT TCP connect()扫描，这种方式会在目标主机的日志中记录大批连接请求和错误信息。 -sS 半开扫描，很少有系统能把它记入系统日志。不过，需要Root权限。 -sF -sN 秘密FIN数据包扫描、Xmas Tree、Null扫描模式 -s...
android ble蓝牙调试工具代码
01-17
下面是关于Android BLE蓝牙调试工具代码的一些说明： 首先，我们可以使用Android提供的Log工具来打印调试信息。通过在代码中插入Log语句，我们可以在Logcat工具中查看和分析输出的日志信息，以了解BLE连接和通信的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值