明年就要毕业了，所以最近开始刷面试题，碰到了一个问题“蓝牙自动配对怎么实现的？”，刚开始有点懵逼了。于是学习一波，记录下来。

1 实现过程及原理

  配对是建立连接的基础，任何从未配对过的设备（或曾经配对但其中一方已删除配对关系）都无法建立连接，因此配对无法绕过。配对的方式有输入pin码、输入密码、免输入的随机验证码等多种。当前XX设备与控制端的配对方式为免输入的随机验证码，两端确认6位数密码一致，点击“确认配对”即可完成配对。但由于XX设备无法用户交互，所以只能由程序完成确认实现自动配对——当然，XX设备只针对确定来源的请求（如XX助手）才默认同意并接受配对。

2 查找设备的方式

  蓝牙开启后查找设备的方式有两种：搜索和指定mac，用搜索功能查找蓝牙设备涉及“可见性”的概念，蓝牙对外可见（即能被别的蓝牙设备搜索到）最多可设置为300s（5分钟），而指定的mac方式没有时间限制，只要蓝牙开启就可以找到设备，因为XX设备与控制端需要随时能（配对）连接，显然搜索查找的方式，不适用于XX设备。因此只能选择指定mac地址的方式。

3 相关代码实现

3.1 注册权限

  因为需要实现蓝牙配对，所以需要开启蓝牙相关的权限，在Android的清单文件中申请如下权限：

<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
<uses-permission android:name="android.permission.BLUETOOTH_PRIVILEGED" />
<uses-permission android:name="android.permission.ACCESS_BLUETOOTH_SHARE" />

3.2 注册广播

  BoradcastReceiver（想更了解百度）在Android中充当的是传递数据和消息的作用。所以这是实现蓝牙自动配置的关键。其注册方式分为静态注册和动态注册。

3.2.1 动态注册

  动态注册就是采用activity内部实现广播类，采用java代码的方式实现，相关代码如下：

// 注册Receiver来获取蓝牙设备相关的结果（主要逻辑是第一行和最后一行代码）
IntentFilter intent = new IntentFilter();
// 用BroadcastReceiver来取得搜索结果
intent.addAction(BluetoothDevice.ACTION_FOUND);
intent.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED);
intent.addAction(BluetoothAdapter.ACTION_SCAN_MODE_CHANGED);
intent.addAction(BluetoothAdapter.ACTION_STATE_CHANGED);
// searchDevices表示广播类，详细了解百度
registerReceiver(searchDevices, intent);

注：动态配置结尾必须在Activity中的生命周期函数onDestroy()中调用销毁广播逻辑，代码为：this.unregisterReceiver(searchDevices);

3.2.2 静态注册

  静态注册就是把广播类注册到清单文件中，写个广播类，之后在清单文件中填写相关代码，代码如下：

// 类地址
<receiver android:name=".broadcast.BluetoothReceiver" >
    <intent-filter android:priority="1000">
    	// 详细了解百度
        <action android:name="android.bluetooth.device.action.PAIRING_REQUEST"/>
        <action android:name="android.bluetooth.device.action.FOUND"/>
    </intent-filter>
</receiver>

注：idea中我一般直接可以新建一个广播类，也不用填写上面代码，但是你配置更详细一些需要添加action节点。

3.3 配对逻辑

  在广播中的广播接收回调函数onReceive()实现配对逻辑，这里建议跳转阅读一下BluetoothAdapter的API使用，文章时间可能有点老，但是非常全面，其相关代码如下：

// 我这里没有代码重构，我看一下，网上都把其操作逻辑封装在工具类中。
@Override
public void onReceive(Context context, Intent intent) {
    String action = intent.getAction();
    Bundle b = intent.getExtras();
    Object[] lstName = b.keySet().toArray();

    // 显示所有收到的消息及其细节
    for (int i = 0; i < lstName.length; i++) {
        String keyName = lstName[i].toString();
        Log.e(keyName, String.valueOf(b.get(keyName)));
    }
    BluetoothDevice device = null;
    // 搜索设备时，取得设备的MAC地址
    if (BluetoothDevice.ACTION_FOUND.equals(action)) {
        device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
        if (device.getBondState() == BluetoothDevice.BOND_NONE) {
            String str = "未配对|" + device.getName() + "|"
                    + device.getAddress();
            if (lstDevices.indexOf(str) == -1)// 防止重复添加
            {
                lstDevices.add(str);
            }
            // 获取设备名称和mac地址
            adtDevices.notifyDataSetChanged();
        }
    }else if(BluetoothDevice.ACTION_BOND_STATE_CHANGED.equals(action)){
        device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
        switch (device.getBondState()) {
            case BluetoothDevice.BOND_BONDING:
                Log.d("BlueToothTestActivity", "正在配对......");
                break;
            case BluetoothDevice.BOND_BONDED:
                Log.d("BlueToothTestActivity", "完成配对");
                connect(device);//连接设备
                break;
            case BluetoothDevice.BOND_NONE:
                Log.d("BlueToothTestActivity", "取消配对");
            default:
                break;
        }
    }
}

总结

  以上写的是蓝牙自动配对的整个过程，是一个思路以及主要代码，但作为程序猿的我们理论上掌握肯定不行的。所以我会上传两个demo（分别代表静态注册和动态注册）。有问题大家一起探头。@1797801363@qq.com，qq也是这个哦。（要代码直接@我不需要积分的哦）。

最近在开发一个手机连接蓝牙设备的APP，其中有个需求是自动连接，用户不用确认。我在网上找到了一个工具类，但是网上很

多文章对这个工具类的使用方法都不能实现我的需求，要么弹出框不能隐藏，要么是隐藏输入框却不能配对成功。经过我多次尝

试，发现他们的配对方法用错了。

工具类：ClsUtils.java

/**************** 蓝牙配对函数 ***************/

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import android.bluetooth.BluetoothDevice;
import android.util.Log;

public class ClsUtils {
    /**
     * 与设备配对 参考源码：platform/packages/apps/Settings.git
     * /Settings/src/com/android/settings/bluetooth/CachedBluetoothDevice.java
     */
    static public boolean createBond(Class btClass, BluetoothDevice btDevice) throws Exception {
        Method createBondMethod = btClass.getMethod("createBond");
        Boolean returnValue = (Boolean) createBondMethod.invoke(btDevice);
        return returnValue.booleanValue();
    }
    /**
     * 与设备解除配对 参考源码：platform/packages/apps/Settings.git
     * /Settings/src/com/android/settings/bluetooth/CachedBluetoothDevice.java
     */
    static public boolean removeBond(Class<?> btClass, BluetoothDevice btDevice) throws Exception {
        Method removeBondMethod = btClass.getMethod("removeBond");
        Boolean returnValue = (Boolean) removeBondMethod.invoke(btDevice);
        return returnValue.booleanValue();
    }
    static public boolean setPin(Class<? extends BluetoothDevice> btClass, BluetoothDevice btDevice, String str) throws Exception {
        try {
            Method removeBondMethod = btClass.getDeclaredMethod("setPin", new Class[]{byte[].class});
            Boolean returnValue = (Boolean) removeBondMethod.invoke(btDevice, new Object[]{str.getBytes()});
            Log.e("returnValue", "" + returnValue);
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return true;
    }
    // 取消用户输入
    static public boolean cancelPairingUserInput(Class<?> btClass, BluetoothDevice device) throws Exception {
        Method createBondMethod = btClass.getMethod("cancelPairingUserInput");
        Boolean returnValue = (Boolean) createBondMethod.invoke(device);
        return returnValue.booleanValue();
    }
    // 取消配对
    static public boolean cancelBondProcess(Class<?> btClass, BluetoothDevice device) throws Exception {
        Method createBondMethod = btClass.getMethod("cancelBondProcess");
        Boolean returnValue = (Boolean) createBondMethod.invoke(device);
        return returnValue.booleanValue();
    }
    //确认配对
    static public void setPairingConfirmation(Class<?> btClass, BluetoothDevice device, boolean isConfirm) throws Exception {
        Method setPairingConfirmation = btClass.getDeclaredMethod("setPairingConfirmation", boolean.class);
        setPairingConfirmation.invoke(device, isConfirm);
    }
    /**
     *
     * @param clsShow
     */
    static public void printAllInform(Class clsShow) {
        try {
            // 取得所有方法
            Method[] hideMethod = clsShow.getMethods();
            int i = 0;
            for (; i < hideMethod.length; i++) {
                Log.e("method name", hideMethod[i].getName() + ";and the i is:"+ i);
            }
            // 取得所有常量
            Field[] allFields = clsShow.getFields();
            for (i = 0; i < allFields.length; i++) {
                Log.e("Field name", allFields[i].getName());
            }
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 实现的界面，没有采用在Manifest文件里配置receiver的方法，因为发现那样配置结果还是会闪出配对密码输入框，附配对代码

本方法是根据蓝牙名称进行配对的，如需求不同可以自己该代码，不适用配对手机蓝牙设备，只适用于硬件开发中蓝牙模块中需

要输入密码的配对，（layout文件里只有一个按钮，这里就不给代码了）：

import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;

public class MainActivity extends AppCompatActivity {
    private BluetoothAdapter bluetoothAdapter;
    private BluetoothDevice bluetoothDevice;
    private Button search;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //开始配对按钮
        search = findViewById(R.id.search_bluetooth);
        bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
        //检查蓝牙
        if(bluetoothAdapter != null){
            if(!bluetoothAdapter.isEnabled()){
                Intent intent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
                //设置蓝牙可见性
                intent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION,3000);
                this.startActivity(intent);
                //打开蓝牙
                bluetoothAdapter.enable();
            }
        }else {
            Toast.makeText(this,"本地设备驱动异常",Toast.LENGTH_LONG).show();
        }
        search.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                //扫描设备
                bluetoothAdapter.startDiscovery();
                //注册广播
                RegisterBluetoothReceiver();
            }
        });
    }
    //注册广播
    public void RegisterBluetoothReceiver(){
        // 设置广播信息过滤
        IntentFilter intentFilter = new IntentFilter();
        intentFilter.addAction(BluetoothDevice.ACTION_FOUND);
        intentFilter.addAction(BluetoothDevice.ACTION_PAIRING_REQUEST);
        // 注册广播接收器，接收并处理搜索结果
        registerReceiver(BTReceive, intentFilter);
    }
    //处理蓝夜绑定的广播
    private BroadcastReceiver BTReceive = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            if(BluetoothDevice.ACTION_FOUND.equals(action)){
                bluetoothDevice = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
                String bluetoothName;
                if((bluetoothName = bluetoothDevice.getName()) != null){
                    // 如果查找到的设备符合要连接的设备，处理
                    if (bluetoothName.equalsIgnoreCase("HC-05")) {
                        //搜索蓝牙占用资源，搜索到后要及时关闭
                        bluetoothAdapter.cancelDiscovery();
                        //获取蓝牙的连接状态
                        int connectState = bluetoothDevice.getBondState();
                        switch (connectState){
                            //未配对
                            case BluetoothDevice.BOND_NONE:
                                //开始配对
                                try{
                                    ClsUtils.createBond(bluetoothDevice.getClass(),bluetoothDevice);
                                }catch (Exception e){
                                    e.printStackTrace();
                                }
                                break;
                        }
                    }
                }
            }else if(BluetoothDevice.ACTION_PAIRING_REQUEST.equals(action)){
                try {
                    //如果不结束广播接收，配对界面会闪出
                    abortBroadcast();
                    //顺序一定要这样，否则会出问题
                    ClsUtils.setPin(bluetoothDevice.getClass(), bluetoothDevice, "1234");
                    //这行代码会在控制台报错
                    //ClsUtils.setPairingConfirmation(bluetoothDevice.getClass(), bluetoothDevice,true);
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        }
    };

    @Override
    protected void onDestroy() {
        super.onDestroy();
        //注销广播
        unregisterReceiver(BTReceive);
    }

}

参考文章：https://blog.csdn.net/qq_30297763/article/details/79621137

BluetoothConnectActivityReceiver.java:监听蓝牙配对的广播
 
代码：
 
package com.imte.Broadcast;
 
import com.imte.utils.ClsUtils;
 import com.itme.ActivityClass.R;
 
import android.bluetooth.BluetoothDevice;
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.os.Handler;
 import android.util.Log;
 import android.widget.Toast;
 
public class BluetoothConnectActivityReceiver extends BroadcastReceiver {
 
 String strPsw = "123456";
 
 @Override
  public void onReceive(Context context, Intent intent) {
   // TODO Auto-generated method stub
   if (intent.getAction().equals(
     "android.bluetooth.device.action.PAIRING_REQUEST")) {
    BluetoothDevice btDevice = intent
      .getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
    try {
     ClsUtils.setPin(btDevice.getClass(), btDevice, strPsw); // 手机和蓝牙采集的装置配对
     ClsUtils.createBond(btDevice.getClass(), btDevice);
     ClsUtils.cancelPairingUserInput(btDevice.getClass(), btDevice);
     Toast.makeText(
       context,
       context.getResources().getString(
         R.string.bluetooth_connect_success),
       Toast.LENGTH_SHORT);
    } catch (Exception e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
 //    Thread thread=new Thread(strPsw);
 //    thread.
    }
   }
 
 }
 }
 

ClsUtils.java?
 
package com.imte.utils;
 
/************************************ 蓝牙配对函数 * **************/
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 
import android.bluetooth.BluetoothDevice;
 import android.util.Log;
 public class ClsUtils
 {
 
 /**
   * 与设备配对 参考源码：platform/packages/apps/Settings.git
   * /Settings/src/com/android/settings/bluetooth/CachedBluetoothDevice.java
   */
  static public boolean createBond(Class btClass, BluetoothDevice btDevice)
    throws Exception
  {
   Method createBondMethod = btClass.getMethod("createBond");
   Boolean returnValue = (Boolean) createBondMethod.invoke(btDevice);
   return returnValue.booleanValue();
  }
 
 /**
   * 与设备解除配对 参考源码：platform/packages/apps/Settings.git
   * /Settings/src/com/android/settings/bluetooth/CachedBluetoothDevice.java
   */
  static public boolean removeBond(Class btClass, BluetoothDevice btDevice)
    throws Exception
  {
   Method removeBondMethod = btClass.getMethod("removeBond");
   Boolean returnValue = (Boolean) removeBondMethod.invoke(btDevice);
   return returnValue.booleanValue();
  }
 
 static public boolean setPin(Class btClass, BluetoothDevice btDevice,
    String str) throws Exception
  {
   try
   {
    Method removeBondMethod = btClass.getDeclaredMethod("setPin",
      new Class[]
      {byte[].class});
    Boolean returnValue = (Boolean) removeBondMethod.invoke(btDevice,
      new Object[]
      {str.getBytes()});
    Log.e("returnValue", "" + returnValue);
   }
   catch (SecurityException e)
   {
    // throw new RuntimeException(e.getMessage());
    e.printStackTrace();
   }
   catch (IllegalArgumentException e)
   {
    // throw new RuntimeException(e.getMessage());
    e.printStackTrace();
   }
   catch (Exception e)
   {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
   return true;
 
 }
 
 // 取消用户输入
  static public boolean cancelPairingUserInput(Class btClass,
    BluetoothDevice device)
 
 throws Exception
  {
   Method createBondMethod = btClass.getMethod("cancelPairingUserInput");
   // cancelBondProcess()
   Boolean returnValue = (Boolean) createBondMethod.invoke(device);
   return returnValue.booleanValue();
  }
 
 // 取消配对
  static public boolean cancelBondProcess(Class btClass,
    BluetoothDevice device)
 
 throws Exception
  {
   Method createBondMethod = btClass.getMethod("cancelBondProcess");
   Boolean returnValue = (Boolean) createBondMethod.invoke(device);
   return returnValue.booleanValue();
  }
 
 /**
   * 
  * @param clsShow
   */
  static public void printAllInform(Class clsShow)
  {
   try
   {
    // 取得所有方法
    Method[] hideMethod = clsShow.getMethods();
    int i = 0;
    for (; i < hideMethod.length; i++)
    {
     Log.e("method name", hideMethod[i].getName() + ";and the i is:"
       + i);
    }
    // 取得所有常量
    Field[] allFields = clsShow.getFields();
    for (i = 0; i < allFields.length; i++)
    {
     Log.e("Field name", allFields[i].getName());
    }
   }
   catch (SecurityException e)
   {
    // throw new RuntimeException(e.getMessage());
    e.printStackTrace();
   }
   catch (IllegalArgumentException e)
   {
    // throw new RuntimeException(e.getMessage());
    e.printStackTrace();
   }
   catch (Exception e)
   {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
  }
 }
 
最后就是MainActivity,用一个按钮来实现自动配对，代码如下：
 
package com.itme.ActivityClass;
 
import android.app.Activity;
 import android.bluetooth.BluetoothAdapter;
 import android.bluetooth.BluetoothDevice;
 import android.os.Bundle;
 import android.util.Log;
 import android.view.View;
 import android.view.View.OnClickListener;
 import android.widget.Button;
 
import com.imte.utils.ClsUtils;
 
public class MainActivity extends Activity implements OnClickListener{
     /** Called when the activity is first created. */
  private static BluetoothDevice remoteDevice=null;
  private Button btn_autopair=null;
  final static String ACTION_BLUETOOTHBC="android.bluetooth.device.action.PAIRING_REQUEST";
     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.main);
         btn_autopair=(Button)findViewById(R.id.btn_autopair);
         btn_autopair.setOnClickListener(this);
     }
     public static boolean pair(String strAddr, String strPsw)
  {
   boolean result = false;
   //蓝牙设备适配器
   BluetoothAdapter bluetoothAdapter = BluetoothAdapter
     .getDefaultAdapter();
   //取消发现当前设备的过程
   bluetoothAdapter.cancelDiscovery();
   if (!bluetoothAdapter.isEnabled())
   {
    bluetoothAdapter.enable();
   }
   if (!BluetoothAdapter.checkBluetoothAddress(strAddr))
   { // 检查蓝牙地址是否有效
    Log.d("mylog", "devAdd un effient!");
   }
   //由蓝牙设备地址获得另一蓝牙设备对象
   BluetoothDevice device = bluetoothAdapter.getRemoteDevice(strAddr);
   if (device.getBondState() != BluetoothDevice.BOND_BONDED)
   {
    try
    {
     Log.d("mylog", "NOT BOND_BONDED");
     ClsUtils.setPin(device.getClass(), device, strPsw); // 手机和蓝牙采集的装置配对
     ClsUtils.createBond(device.getClass(), device);
 //    ClsUtils.cancelPairingUserInput(device.getClass(), device);
     remoteDevice = device; // 配对完毕就把这个设备对象传给全局的remoteDevice
     result = true;
    }
    catch (Exception e)
    {
     // TODO Auto-generated catch block
     Log.d("mylog", "setPiN failed!");
     e.printStackTrace();
    } //
 
  }
   else
   {
    Log.d("mylog", "HAS BOND_BONDED");
    try
    {
     //ClsUtils这个类的的以下静态方法都是通过反射机制得到需要的方法
     ClsUtils.createBond(device.getClass(), device);//创建绑定
     ClsUtils.setPin(device.getClass(), device, strPsw); // 手机和蓝牙的装置配对
     ClsUtils.createBond(device.getClass(), device);
 //    ClsUtils.cancelPairingUserInput(device.getClass(), device);
     remoteDevice = device; // 如果绑定成功，就直接把这个设备对象传给全局的remoteDevice
     result = true;
    }
    catch (Exception e)
    {
     // TODO Auto-generated catch block
     Log.d("mylog", "setPiN failed!");
     e.printStackTrace();
    }
   }
   return result;
  }
  @Override
  public void onClick(View v) {
   // TODO Auto-generated method stub
   switch (v.getId()) {
   case R.id.btn_autopair:
    if (pair("94:DB:46:2B:A1:82", "123456")) {//pair的第一个参数是要配对的蓝牙地址，第二个参数是配对时预先设置的密钥
 
    Log.i("aaron", remoteDevice.getAddress());
    }
    break;
 
  default:
    break;
   }
  }
 }
 
叮咚..如题的功能就实现了。。。
 
 
 
 
 
  项目源代码下载地址： http://download.csdn.net/detail/huangrangg12/4578242    

转载于:https://my.oschina.net/u/920274/blog/2999998