devbox
小丑西瓜9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

android Ble4.0蓝牙开发之搜索慢、startLeScan()过时，6.0以上不需要定位权限也能快速搜索到蓝牙设备_startlescan搜秒速度比startscan快

作者：小丑西瓜9 | 2024-03-05 16:48:57

赞

踩

startlescan搜秒速度比startscan快
        项目中需要用到android Ble蓝牙4.0开发技术，于是开启了蓝牙填坑之旅，说实话，蓝牙开发坑真多，跳出一个又进入下一个，每次遇到 问题，就觉得不可能解决了，还好在自己的摸索中，都一一的化解了，以此来记录安卓蓝牙开发的心得。
     接手的蓝牙开发项目，原来的同事已经写好，不用再去写，开始也就大概看了看android蓝牙开发相关资料，对比项目中的蓝牙开发代码，发现发现搜索、连接蓝牙有一样的处理也有不一样的处理，想着项目不一样，代码处理肯定不一样，于是就没去深究，毕竟项目运行起来使用正常，然而，没过几天，客户提出蓝牙搜索太慢，然后就去调试，先看代码是搜索蓝牙8秒钟才显示搜索到的蓝牙设备列表，查看日志，其实不到8秒就搜索到外围设备，只是搜索8秒后停止扫描才显示蓝牙设备，那就把显示成3、4秒呗。
        正这样想，同事拿来一部荣耀8，装的APP怎么就是搜不到蓝牙设备，然后调试其他手机，都能搜索到，于是就纳闷了，荣耀8怎么就是搜索不到蓝牙设备呢，其他手机都能，再看一遍代码，也没有专门针对荣耀8处理的地方，再想，荣耀8是系统7.0的手机，是不是跟权限没开有关呢，对比其他华为手机，申请的蓝牙权限也都开着，荣耀8就是搜索不到，是不是荣耀8手机有问题，同事告知下载一个第三方蓝牙调试工具查查看，令人疑惑的是荣耀8用第三方蓝牙调试工具立刻就能扫描显示出来，试了几次都是立刻扫描出来，当时心想，我靠，什么鬼，这么迅速就能把蓝牙设备扫描显示出来，领导也说，别人的调试工具都能做这么快，你也得做这么快，想着目前的代码都是几秒后才能搜索到，目前的荣耀8还搜索不出来，客户那边还一个劲儿的给老板吐槽太慢，于是压力剧增，真正开始了蓝牙开发不归之旅。
     但是再考虑索慢时，领导说，得把荣耀8搜索不到的问题先解决，因为荣耀8是项目实施人员给客户安装硬件调试数据要用的，那就先把搜索慢暂时放一放，想着一边搜索慢没还没着落，荣耀8手机就是搜索不到，想想就头大，查找荣耀8为什么搜索不到蓝牙设备的资料，也没发现有效的办法，这时，用荣耀手机的人说，另一个公司的项目app（简称B吧，荣耀8搜索不到蓝牙设备的项目简称A吧）就能正常搜索到蓝牙设备，一打开调试还真是每次都能搜索到，看了一下两个项目的代码： 
  1. private BluetoothAdapter btAdapt;
  2.     private List<BluetoothDevice> listDevices = new ArrayList<BluetoothDevice>();
  3.     private List<TieBean> listDeviceName = new ArrayList<TieBean>();
  4.     private boolean bIsConnected;
  5.     private BluetoothDevice myBluetooth;
  6.     private public BluetoothGatt mBluetoothGatt;
  7.     private TextView tv_seacher_ble;
  8.  
  9.     @Override
  10.     protected void onCreate(Bundle savedInstanceState) {
  11.         super.onCreate(savedInstanceState);
  12.         requestWindowFeature(Window.FEATURE_NO_TITLE);//去掉标题栏
  13.         setContentView(R.layout.activity_main);
  14.         getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);//锁屏
  15.         tv_seacher_ble = (LinearLayout) findViewById(R.id.tv_seacher_ble);//linear Layout
  16.  
  17.         BluetoothAdapter btAdapt = BluetoothAdapter.getDefaultAdapter();// 初始化本机蓝牙功能 
  18.       
  19.         IntentFilter intent = new IntentFilter();
  20.         intent.addAction(BluetoothDevice.ACTION_FOUND);// 用BroadcastReceiver来取得搜索结果
  21.         intent.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED);
  22.         intent.addAction(BluetoothAdapter.ACTION_SCAN_MODE_CHANGED);
  23.         intent.addAction(BluetoothAdapter.ACTION_STATE_CHANGED);
  24.         mActivity.registerReceiver(searchDevicesBroadcast, intent);
  25.        
  26.  tv_seacher_ble.setOnClickListener(new View.OnClickListener() {
  27.             @Override
  28.             public void onClick(View v) {
  29.                 btAdapt.startDiscovery();
  30.             }
  31.         });
  32.     }
  33.  
  34.  
  35.     //搜索到的蓝牙设备在这里
  36.     private BroadcastReceiver searchDevicesBroadcast = new BroadcastReceiver() {
  37.         public void onReceive(Context context, Intent intent) {
  38.             BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
  39.             if (TextUtils.isEmpty(device.getName())) {
  40.                 return;
  41.             }
  42.             ToastUtil.showToast(mActivity, "蓝牙设备 " + device.getName());
  43.             String str = device.getName() + "|" + device.getAddress();
  44.             if (listDeviceName.indexOf(str) == -1) {// 防止重复添加
  45.                 listDevices.add(device); // 获取设备名称和mac地址
  46.                 listDeviceName.add(new TieBean(str));
  47.             }
  48.         }
  49.     };
  50.  
  51.  
  52.     Handler handler = new Handler() {
  53.         @Override
  54.         public void handleMessage(Message msg) {
  55.             //断开设备
  56.             if (msg.what == 1) {
  57.                 mBluetoothGatt.disconnect();
  58.                 //连接设备
  59.             } else if (msg.what == 2) {
  60.                 ToastUtil.showToast(mActivity, "开始搜索蓝牙设备");
  61.                 if (btAdapt.getState() == BluetoothAdapter.STATE_OFF) {// 如果蓝牙还没开启
  62.                     ToastUtil.showToast(mActivity, "请先打开蓝牙");
  63.                     return;
  64.                 }
  65.                 if (btAdapt.isDiscovering())
  66.                     btAdapt.cancelDiscovery();
  67.                 listDevices.clear();
  68.                 listDeviceName.clear();
  69.  
  70.                 btAdapt.startDiscovery();
  71.                 //定时器操作
  72.                 new Handler().postDelayed(new Runnable() {
  73.                     @Override
  74.                     public void run() {
  75.                         //ToastUtil.showToast(mActivity,"搜索蓝牙完毕");
  76.                         btAdapt.cancelDiscovery();
  77.                         closeProgressDialog();
  78.                         //其中BuildBean，TieAdapter是在app的build.gradle中dependencies {compile 'com.dou361.dialogui:jjdxm-dialogui:1.0.3'}；
  79.                         TieAdapter adapter = new TieAdapter(mContext, listDeviceName, true);
  80.                         BuildBean buildBean = DialogUIUtils.showMdBottomSheet(mActivity, true, "", listDeviceName, 0, new DialogUIItemListener() {
  81.                             @Override
  82.                             public void onItemClick(CharSequence text, int position) {
  83.                                 myBluetooth = listDevices.get(position);
  84.                                 //根据蓝牙地址获取远程蓝牙设备
  85.                                 final BluetoothDevice device = btAdapt.getRemoteDevice(myBluetooth.getAddress());
  86.                                 if (device == null) {
  87.                                     return;
  88.                                 }
  89.                                 mBluetoothGatt = device.connectGatt(mActivity, false, mGattCallback);
  90.  
  91.                             }
  92.                         });
  93.                         buildBean.mAdapter = adapter;
  94.                         buildBean.show();
  95.                     }
  96.                 }, 8000);    //延时8s执行
  97.             } else if (msg.what == 3) {
  98.                 tv_seacher_ble.setText("断开蓝牙");
  99.             } else if (msg.what == 4) {
  100.                 tv_seacher_ble.setText("连接蓝牙");
  101.                 mBluetoothGatt.close();
  102.             }
  103.             super.handleMessage(msg);
  104.         }
  105.     };
      两个项目中的蓝牙适配器的获取，去发现，动态注册广播、广播接收蓝牙搜索结果、蓝牙连接都一样，至于手机是否支持ble4.0,蓝牙是否开启的逻辑，连接上对数据的处理、断开mBluetoothGatt.disconnect()，关闭mBluetoothGatt.close() 的逻辑网上有很多，我这里就不在详说；
       经过2个项目对比，发现就蓝牙搜索多久停止不一样，荣耀8能搜索到蓝牙设备的时间项目代码设置是10秒，而搜索不到的项目是设置8秒，带着半信半疑把项目A的蓝牙搜索时间由8秒改成10秒，运行，奇迹还真是出现了，荣耀8可以正常搜索到蓝牙设备了，反复测了好多次都能正常搜索到蓝牙设备，我是不信邪的人，还改成8秒试试，果然还是搜索不到。
     于是和领导说，你看荣耀8必须10秒才能搜索 到蓝牙设备，搜索到的蓝牙设备列表不晚点展示不行啊，领导自然 是不同意，拿出第三方蓝牙提哦啊是工具说，那第三方就能很快搜索到，你想想其他法吧，想着有的手机快，有的手机慢，提出意见，能不能搜索到一个设备就展示到列表，不必等10秒后再展示，这样体验好些，反正领导说不行，既然领导说不行，那就回去研究吧。
    查了很多蓝牙搜索慢怎么办?看了半天，当然这期间调试过各种其他方法，都没用，功夫不负有心人，其中一个博客说：
btAdapt.startDiscovery();搜索返回的结果慢， 现在都用这个 btAdapt.startLeScan(getmLeScanCallback); 其他也没多说什么，喜出望外，这不是正是我要的吗，于是改蓝牙搜索,上代码: 
  1. package com.hand.hand16.activity;
  2. import android.app.Activity;
  3. import android.bluetooth.BluetoothAdapter;
  4. import android.bluetooth.BluetoothDevice;
  5. import android.bluetooth.BluetoothGatt;
  6. import android.bluetooth.BluetoothGattCallback;
  7. import android.bluetooth.BluetoothGattCharacteristic;
  8. import android.bluetooth.BluetoothGattService;
  9. import android.bluetooth.BluetoothManager;
  10. import android.bluetooth.BluetoothProfile;
  11. import android.content.Context;
  12. import android.content.DialogInterface;
  13. import android.content.Intent;
  14. import android.os.Bundle;
  15. import android.os.Handler;
  16. import android.os.Message;
  17. import android.os.Vibrator;
  18. import android.support.v7.app.AlertDialog;
  19. import android.support.v7.app.AppCompatActivity;
  20. import android.view.Gravity;
  21. import android.view.LayoutInflater;
  22. import android.view.View;
  23. import android.view.Window;
  24. import android.view.WindowManager;
  25. import android.widget.Button;
  26. import android.widget.TextView;
  27. import com.dou361.dialogui.DialogUIUtils;
  28. import com.dou361.dialogui.adapter.TieAdapter;
  29. import com.dou361.dialogui.bean.BuildBean;
  30. import com.dou361.dialogui.bean.TieBean;
  31. import com.dou361.dialogui.listener.DialogUIItemListener;
  32. import java.util.ArrayList;
  33. import java.util.Arrays;
  34. import java.util.Collections;
  35. import java.util.List;
  36.  
  37. public class MainActivity extends AppCompatActivity implements View.OnClickListener {
  38.         private TextView tv_seacher_ble;
  39.         public boolean bIsConnected;
  40.         private TieAdapter tieAdapter;
  41.         private Vibrator vibrator;
  42.         private BluetoothDevice mBluetoothDevice;
  43.         private  BluetoothAdapter btAdapt;
  44.         List<BluetoothDevice> listDevices = new ArrayList<BluetoothDevice>();
  45.         List<TieBean> listDeviceName = new ArrayList<TieBean>();
  46.  
  47.         private BluetoothDevice myBluetooth;
  48.         public BluetoothGatt mBluetoothGatt;//中央使用和处理数据
  49.         public BluetoothGattCharacteristic mNotifyCharacteristic;
  50.         private boolean mScanning;
  51.         //蓝牙服务
  52.         private String strDevice = "";
  53.         Handler handler = new Handler() {
  54.             @Override
  55.             public void handleMessage(Message msg) {
  56.                 super.handleMessage(msg);
  57.                 if (msg.what == 1) {
  58.                     //断开设备
  59.                     mBluetoothGatt.disconnect();
  60.                 } else if (msg.what == 2) {
  61.                     //连接设备
  62.                     if (btAdapt == null || !btAdapt.isEnabled() || btAdapt.getState() == BluetoothAdapter.STATE_OFF) {// 如果蓝牙还没开启
  63.                         Toast.makeText(MainActivity.this,"请先打开蓝牙",Toast.LENGTH_SHORT).show();
  64.                         Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
  65.                         startActivityForResult(enableBtIntent, 0);
  66.                         return;
  67.                     }
  68.  
  69.                     if (mScanning) {
  70.                         btAdapt.stopLeScan(getmLeScanCallback);
  71.                     }
  72.                     listDevices.clear();
  73.                     listDeviceName.clear();
  74.                     mScanning = true;
  75.                     btAdapt.startLeScan(getmLeScanCallback); //开始搜索
  76.                     //定时器操作
  77.                     new Handler().postDelayed(new Runnable() {
  78.                         @Override
  79.                         public void run() {
  80.                             mScanning = false;
  81.                             btAdapt.stopLeScan(getmLeScanCallback);
  82.  //其中BuildBean，TieAdapter是在build.gradle中dependencies {compile 'com.dou361.dialogui:jjdxm-dialogui:1.0.3'}；
  83.                             tieAdapter = new TieAdapter(mContext, listDeviceName, true);
  84.                             BuildBean buildBean = DialogUIUtils.showMdBottomSheet(mActivity, true, "", listDeviceName, 0, new DialogUIItemListener() {
  85.                                 @Override
  86.                                 public void onItemClick(CharSequence text, int position) {
  87.                                     mBluetoothDevice = btAdapt.getRemoteDevice(listDevices.get(position).getAddress());
  88.                                     if (mBluetoothDevice == null) {
  89.                                         return;
  90.                                     }
  91.                                     mBluetoothGatt = mBluetoothDevice.connectGatt(mActivity, false, mGattCallback);
  92.                                 }
  93.                             });
  94.                             if (listDevices.size() > 0) {
  95.                                 buildBean.mAdapter = tieAdapter;
  96.                                 buildBean.show();
  97.                             } else {
  98.                                 Toast.makeText(MainActivity.this,"未搜索到蓝牙设备",Toast.LENGTH_SHORT).show();
  99.                             }
  100.                         }
  101.                     }, 2000);    //延时2s执行
  102.                 } else if (msg.what == 3) {
  103.                     tv_seacher_ble.setText("断开蓝牙");
  104.                     bIsConnected = true;
  105.                     Toast.makeText(MainActivity.this,"蓝牙连接成功",Toast.LENGTH_SHORT).show();
  106.                 } else if (msg.what == 4) {
  107.                     tv_seacher_ble.setText("连接蓝牙");
  108.                     bIsConnected = false;
  109.                     mBluetoothGatt.close();
  110.                     mBluetoothGatt = null;
  111.                 }
  112.             }
  113.         };
  114.         @Override
  115.         protected void onCreate(Bundle savedInstanceState) {
  116.             super.onCreate(savedInstanceState);
  117.             supportRequestWindowFeature(Window.FEATURE_NO_TITLE);//去掉标题栏
  118.             setContentView(R.layout.activity_main);
  119.             getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);//锁屏
  120.             tv_seacher_ble = (TextView) findViewById(R.id.tv_main_id);
  121.             final BluetoothManager bluetoothManager = (BluetoothManager) getSystemService(Context.BLUETOOTH_SERVICE);
  122.             btAdapt = bluetoothManager.getAdapter();
  123.             //  btAdapt = BluetoothAdapter.getDefaultAdapter();// 初始化本机蓝牙功能,除了搜索方法欢了，获取蓝牙适配器的方法也换了
  124.             //添加了震动
  125.             vibrator = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE);
  126.             tv_seacher_ble.setOnClickListener(new View.OnClickListener() {
  127.                 @Override
  128.                 public void onClick(View v) {
  129.                     final AlertDialog.Builder myDialog = new AlertDialog.Builder(MainActivity.this);
  130.                     //nomalDialog.setIcon(R.drawable.icon_dialog);
  131.                     myDialog.setTitle("提示");
  132.                     myDialog.setMessage("是否断开蓝牙设备？");
  133.                     myDialog.setPositiveButton("是", new DialogInterface.OnClickListener() {
  134.                         @Override
  135.                         public void onClick(DialogInterface dialogInterface, int i) {
  136.                             Message message = new Message();
  137.                             message.what = 1;
  138.                             handler.sendMessage(message);
  139.                         }
  140.                     });
  141.                     myDialog.setNegativeButton("否", new DialogInterface.OnClickListener() {
  142.                         @Override
  143.                         public void onClick(DialogInterface dialogInterface, int i) {
  144.  
  145.                         }
  146.                     });
  147.                     myDialog.show();
  148.  
  149.                 } else {
  150.                     vibrator.vibrate(200);//震动指定时间
  151.                     //蓝牙搜索 
  152.                     Message message = new Message();
  153.                     message.what = 2;
  154.                     handler.sendMessage(message);
  155.                 }
  156.             }
  157.         });
  158.  
  159.  
  160.  BluetoothAdapter.LeScanCallback getmLeScanCallback = new BluetoothAdapter.LeScanCallback() {
  161.        @Override
  162.        public void onLeScan(final BluetoothDevice bluetoothDevice, int i, byte[] bytes) {
  163.                 runOnUiThread(new Runnable() {
  164.                     @Override
  165.                     public void run() {
  166.                         boolean isSame = true;
  167.                         if (bluetoothDevice != null && bluetoothDevice.getName() != null) {
  168.                             LogUtil.e("蓝牙设备==" + bluetoothDevice.getName() + "|" + bluetoothDevice.getAddress());
  169.                                 strDevice = bluetoothDevice.getName() + "|" + bluetoothDevice.getAddress();
  170. //去重
  171.                             for (BluetoothDevice bd : listDevices) {
  172.                                 if (bd.getAddress().equalsIgnoreCase(bluetoothDevice.getAddress())) {
  173.                                     isSame = false;
  174.                                 }
  175.                             }
  176.                             if (isSame) {
  177.                                 listDevices.add(bluetoothDevice);
  178.                                 listDeviceName.add(new TieBean(strDevice));
  179.                                 // tieAdapter.notifyDataSetChanged();
  180.                             }
  181.  
  182.                         }
  183.                     }
  184.                 });
  185.             }
  186.         };
  187. private final BluetoothGattCallback mGattCallback = new BluetoothGattCallback() {
  188.             @Override
  189.             public void onConnectionStateChange(BluetoothGatt gatt, final int status, final int newState) {
  190.                 LogUtil.e("StateChange,status=" + status + ",newState==" + newState + ",Services=" + mBluetoothGatt.discoverServices());
  191.                 if (status == BluetoothGatt.GATT_SUCCESS) {
  192.                     if (newState == BluetoothProfile.STATE_CONNECTED) {//2
  193.                         LogUtil.e("去连接GATT server");
  194.                     } else if (newState == BluetoothProfile.STATE_CONNECTING) {
  195.                         LogUtil.e("连接中");
  196.                     } else if (newState == BluetoothProfile.STATE_DISCONNECTED) {
  197.                         LogUtil.e("已断开断开蓝牙Disconnected");
  198.                         Message message = new Message();
  199.                         message.what = 4;
  200.                         handler.sendMessage(message);
  201.                     } else if (newState == BluetoothProfile.STATE_DISCONNECTING) {
  202.                         LogUtil.e("断开中");
  203.                     }
  204.                 } else if (status == 133) {
  205.                     //防止出现133，搜索到列表连接不上
  206.                     LogUtil.e("出现133");
  207.                     Message message = new Message();
  208.                     message.what = 5;
  209.                     handler.sendMessage(message);
  210.                 } else if (status == 8) {
  211.                     //自动断开
  212.                     LogUtil.e("自动断开了");
  213.                     Message message = new Message();
  214.                     message.what = 6;
  215.                     handler.sendMessage(message);
  216.                 } else if (status == 40) {
  217.                     //距离太远
  218.                     Message message = new Message();
  219.                     message.what = 7;
  220.                     handler.sendMessage(message);
  221.                 }else {
  222. //其他连接不到设备的情况
  223.                 }Message message = new Message();
  224.                 message.what = 8;
  225.                 handler.sendMessage(message);
  226.             }
  227.  
  228.             @Override
  229.             public void onServicesDiscovered(BluetoothGatt gatt, int status) {
  230.                 LogUtil.e("ServicesDiscovered状态status==" + status + ",Services==" + gatt.getServices());
  231.                 if (status == BluetoothGatt.GATT_SUCCESS) {
  232.                     Message message = new Message();
  233.                     message.what = 3;
  234.                     handler.sendMessage(message);
  235.                     //激活要开启的服务
  236.                     displayGattServices(gatt.getServices());
  237.                     LogUtil.e("Discovered获取GATT_SUCCESS");
  238.                 } else {
  239.                     LogUtil.e("onServicesDiscovered received: " + status);
  240.                     bIsConnected = false;
  241.                 }
  242.             }
  243.  
  244.             @Override
  245.             public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
  246.             }
  247.  
  248.             @Override
  249.             public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
  250.             }
  251.  
  252.             @Override
  253.             public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
  254.             }
  255.         };
  256.  
  257.         //打开服务
  258.         private void displayGattServices(List<BluetoothGattService> gattServices) {
  259.             if (gattServices == null)
  260.                 return;
  261.             String uuid = null;
  262.             for (BluetoothGattService gattService : gattServices) {
  263.                 uuid = gattService.getUuid().toString();
  264.                 List<BluetoothGattCharacteristic> gattCharacteristics = gattService.getCharacteristics();
  265.  
  266.                 for (BluetoothGattCharacteristic gattCharacteristic : gattCharacteristics) {
  267.                     uuid = gattCharacteristic.getUuid().toString();
  268.                     if (uuid.equals(SPP_UUID)) {
  269.                         final BluetoothGattCharacteristic characteristic = gattCharacteristic;
  270.                         final int charaProp = characteristic.getProperties();
//这里根据charaProp 去做读、写、通知，真正的连接成功是在这里做判断的
  1. // Message message = new Message();
  2.                     //message.what = 3;
  3.                   //  handler.sendMessage(message)
  4.       }
    }         

  }      

}       

@Override       

public void onDestroy() {           

super.onDestroy();          

if (mScanning) {               

btAdapt.stopLeScan(getmLeScanCallback);          

}           

if (NotNull.isNotNull(mBluetoothGatt)) {              

mBluetoothGatt.disconnect();               

    mBluetoothGatt.close();           

}           

android.os.Process.killProcess(android.os.Process.myPid());       

    }  

 }   

            经过这样修改之后，奇迹又出现了，蓝牙搜索到确实快了很多，一秒左右甚至不到一秒就把蓝牙设备搜索出来了， 真是令人喜出望外，想起华为荣耀8那么奇葩，不知这个方法在华为荣耀8上测试如何，然而，2秒，4秒，8秒，10秒，20秒都在华为荣耀8搜索不出来，心又凉了半截，暗想这个方法看来还不适用，又白整了，于是又查各种资料，有的说android系统6.0以上的手机需要定位权限，低头一想，还真是，一直测试的手机是android系统6.0以下的，华为荣耀8是7.0以上的，抱着试试的态度，申请权限，还真是努力出奇迹，定位权限允许后，华为荣耀8确实也在不到一秒将蓝牙设备搜索出来，测试了其他6.0以上的手机，都正常很快搜出来。
        测试没有其他问题，打包发布，然而客户不给定位权限，问公司怎么一点搜索不出来，告知需要允许定位，才能搜索到，客户觉得一个蓝牙搜索你跟我要定位，很是不理解，老板也认为这样的体验也不好，客户不给权限，就无法使用，非常不友好。告知领导6.0以上必须给定位权限，否则搜不到， 这个没法啊，领导说你看第三方的蓝牙调试工具，在6.0以上的手机，不用打开定位，而且搜索的更快，第三方都能做到，你想办法吧， 我当然不苟同，下载了几个第三方蓝牙调试工具，有的确实要定位权限不允许定位就无法搜索到，有的确实禁止定位权限也能快速搜索到蓝牙设备，这么啪啪打脸，只能埋头去想办法了，同时，为了保证程序兼容性，公司又买了几部6.0以上的安卓手机，让我更惊心的是，魅族6和华为畅享7不仅要允许定位权限，GPS定位还要打开，GPS不打开，也是搜索不到蓝牙设备，想起以前开发的项目，由于安卓碎片化，不同的手机厂商对定位，GPS管理不一样，有的打开定位权限GPS权限也给了，有的打开GPS定位权限也给了，有的是他们两个独立，处理起来很麻烦，而蓝牙有的要GPS,有的不要GPS,6.0一下还不需要任何定位权限，想着这处理起来太麻烦，还是安心去找不要定位权限的方法吧，其实当时心里是没底的，虽然第三方已经实现这种不需要定位权限就能搜索到，心想，第三方也不知用的是什么黑科技，于是就查找android系统6.0一上的手机不需要定位权限就能把蓝牙设备搜索出来等相关资料，其中最有帮助的查到 btAdapt.startLeScan(getmLeScanCallback) 这个方法已过时，google已经在api里将其划掉，不推荐使用，推荐使用： 

  1.  BluetoothLeScanner scanner = btAdapt.getBluetoothLeScanner();
  2.   scanner.startScan(scanCallback);
喜出过望，难道是用的方法过时了，所以需要定位权限，上代码： 
  1. ScanCallback scanCallback = new ScanCallback() {
  2.         @Override
  3.         public void onScanResult(int callbackType, ScanResult result) {
  4.             super.onScanResult(callbackType, result);
  5.             final BluetoothDevice bluetoothDevice = result.getDevice();
  6.             runOnUiThread(new Runnable() {
  7.                 @Override
  8.                 public void run() {
  9.                     boolean isSame = true;
  10.                     if (bluetoothDevice != null && bluetoothDevice.getName() != null) {
  11.                         LogUtil.e("蓝牙设备==" + bluetoothDevice.getName() + bluetoothDevice.getAddress());
  12.                             strDevice =bluetoothDevice.getName() + "|" + bluetoothDevice.getAddress();
  13.                             for (BluetoothDevice bd : listDevices) {
  14.                                 if (bd.getAddress().equalsIgnoreCase(bluetoothDevice.getAddress())) {
  15.                                     isSame = false;
  16.                                 }
  17.                             }
  18.                             if (isSame) {
  19.                                 listDevices.add(bluetoothDevice);
  20.                                 listDeviceName.add(new TieBean(strDevice));
  21.                                 if (bleDeviceAdapter != null) {
  22.                                     bleDeviceAdapter.notifyDataSetChanged();
  23.                                 }
  24.                             }
  25.  
  26.  
  27.                     }
  28.                 }
  29.             });
  30.         }
  31.  
  32.         @Override
  33.         public void onBatchScanResults(final List<ScanResult> results) {
  34.             super.onBatchScanResults(results);
  35.             runOnUiThread(new Runnable() {
  36.                 @Override
  37.                 public void run() {
  38.                     LogUtil.d("扫描onBatchScanResults==" + results.size());
  39.                 }
  40.             });
  41.  
  42.         }
  43.  
  44.         @Override
  45.         public void onScanFailed(int errorCode) {
  46.             super.onScanFailed(errorCode);
  47.             LogUtil.e("扫描失败onScanFailed， errorCode==" + errorCode);
  48.         }
  49.     };
停止扫描的方法是： 
scanner.stopScan(scanCallback);
        然而，虽然使用了新方法，速度也是一样快，但是还是需要定位权限，魅族6和华为畅享7还得打开GPS,看来这个也不是正解，当然项目中的扫描外围蓝牙设备的方法也都换成了scanner.startScan(scanCallback);
第一天毫无结果，灰头土脸，昏天暗地，焦头烂额地回家。
第二天继续查找相关资料，在一个偶然的机会，看到一篇博客说，把app中的build.gradle中的： 
  1.  defaultConfig {
  2.         applicationId "com.demo.ble"
  3.         minSdkVersion 18
  4.         targetSdkVersion 25
  5.         versionCode 1
  6.         versionName "1.0"
  7.         testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
  8.     }
中的  targetSdkVersion 25改成 targetSdkVersion 22，就不需要定位权限也可以搜索道蓝牙设备了，看到网上很少有人这样说的，搜了那么多资料，就一篇这样说的，带着半信半疑将targetSdkVersion改成 22， 编译，也没报任何错，运行，还真是又出奇迹，测试了手上的所有手机，都不需要定位，不要GPS就可以搜索到蓝牙设备。
       至于为什么会这样，可以查找 android compileSdkVersion、buildToolsVersion，targetSdkVersion之间的区别，网上有很多解释，保证能解答你的疑惑，下面附上一些简单的解释
     targetSDKVersion
    简单来说就代表着你的App能够适配的系统版本，意味着你的App在这个版本的手机上做了充分的 前向 兼容性处理和实际测试。其实我们写代码时都是经常干这么一件事，就是 if(Build.VERSION.SDK_INT >= 23) { ... } ，这就是兼容性处理最典型的一个例子。如果你的target设置得越高，其实调用系统提供的API时，所得到的处理也是不一样的，甚至有些新的API是只有新的系统才有的Android6.0普通权限normal permission 和 危险权限dangerous permission 。
 Normal Permission：写在xml文件里，那么App安装时就会默认获得这些权限，即使是在Android6.0系统的手机上，用户也无法在安装后动态取消这些normal权限，这和以前的权限系统是一样的，不变。
Dangerous Permission：还是得写在xml文件里，但是App安装时具体如果执行授权分以下几种情况：
1、targetSDKVersion < 23 & API(手机系统) < 6.0 ：安装时默认获得权限，且用户无法在安装App之后取消权限。
 2、targetSDKVersion < 23 & API(手机系统) >= 6.0 ：安装时默认获得权限，但是用户可以在安装App完成后动态取消授权（ 取消时手机会弹出提醒，告诉用户这个是为旧版手机打造的应用，让用户谨慎操作 ）。
3、targetSDKVersion >= 23 & API(手机系统) < 6.0 ：安装时默认获得权限，且用户无法在安装App之后取消权限。
 4、targetSDKVersion >= 23 & API(手机系统) >= 6.0 ：安装时不会获得权限，可以在运行时向用户申请权限。用户授权以后仍然可以在设置界面中取消授权，用户主动在设置界面取消后，在app运行过程中可能会出现crash。
其他：
        1.虽然解决了大问题，但是目前项目中发现，连续扫描-断开-扫描四五次，就无法再搜索道外围蓝牙设备，尤其是在每次搜索1-2秒内扫描断开，4、5次无论如何也是搜索不到，需要重新进入界面才能扫描到，每次扫描花费在4、5秒以上的，出现4、5次扫不到的几率就很低了，当然，4、5秒是老板和客户无法忍受的。
2.蓝牙连接成功自动断开；
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小丑西瓜9/article/detail/192471
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号