android 取消蓝牙配对框 实现自动配对

最新推荐文章于 2024-04-03 20:53:08 发布
最新推荐文章于 2024-04-03 20:53:08 发布
阅读量2k 收藏 2
点赞数
分类专栏： 蓝牙

我看了几个文章，主要是接受配对广播，然后设置pin，实现配对，但是网上的大部分手机是不可以的,android.bluetoothdevice 下 action_pair_request ,没有定义这个，开始困扰了我一点时间，实现难度：是否能进入那个广播响应

定义了一个类，这个是网上的可以直接用

// [java]
package zicox.esc; 
 
import java.lang.reflect.Method; 
import java.lang.reflect.Field; 
 
 
import android.bluetooth.BluetoothAdapter; 
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  www.2cto.com
    { 
        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(); 
        } 
    } 
         
     
    static public 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); 
//                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.createBond(device.getClass(), device); 
                ClsUtils.setPin(device.getClass(), device, strPsw); // 手机和蓝牙采集器配对 
                ClsUtils.createBond(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; 
    } 
} 

//================================================================================================================================

 

还有一部分 activity

//================================================================================================================================

 

[java] 
package zicox.esc; 
 
import java.io.IOException; 
import java.io.UnsupportedEncodingException; 
import java.lang.reflect.Method; 
import java.util.ArrayList; 
import java.util.List; 
import java.util.UUID; 
 
import android.app.Activity; 
import android.bluetooth.BluetoothAdapter; 
import android.bluetooth.BluetoothDevice; 
import android.bluetooth.BluetoothSocket; 
import android.content.BroadcastReceiver; 
import android.content.Context; 
import android.content.Intent; 
import android.content.IntentFilter; 
import android.os.Bundle; 
import android.util.Log; 
import android.view.View; 
import android.widget.AdapterView; 
import android.widget.ArrayAdapter; 
import android.widget.Button; 
import android.widget.ListView; 
import android.widget.Toast; 
import android.widget.ToggleButton; 
 
 
public class Demo_ad_escActivity extends Activity 
{ 
    //--------------------------------------------------- 
    public static String ErrorMessage; 
    Button btnSearch, btnDis, btnExit; 
    ToggleButton tbtnSwitch;   
    ListView lvBTDevices;   
    ArrayAdapter<String> adtDevices;   
    List<String> lstDevices = new ArrayList<String>();   
    BluetoothAdapter btAdapt;   
    public static BluetoothSocket btSocket;  
    //--------------------------------------------------- 
     
    public void onCreate(Bundle savedInstanceState) { 
        super.onCreate(savedInstanceState); 
        setContentView(R.layout.main); 
      //  if(!ListBluetoothDevice())finish(); 
        Button Button1 = (Button) findViewById(R.id.button1); 
        ErrorMessage = ""; 
 
        //--------------------------------------------------- 
        btnSearch = (Button) this.findViewById(R.id.btnSearch);   
        btnSearch.setOnClickListener(new ClickEvent());   
        btnExit = (Button) this.findViewById(R.id.btnExit);   
        btnExit.setOnClickListener(new ClickEvent());   
        btnDis = (Button) this.findViewById(R.id.btnDis);   
        btnDis.setOnClickListener(new ClickEvent());   
        // ToogleButton设置   
        tbtnSwitch = (ToggleButton) this.findViewById(R.id.toggleButton1);   
        tbtnSwitch.setOnClickListener(new ClickEvent()); 
        // ListView及其数据源 适配器   
        lvBTDevices = (ListView) this.findViewById(R.id.listView1);   
        adtDevices = new ArrayAdapter<String>(this,   
                android.R.layout.simple_list_item_1, lstDevices);   
        lvBTDevices.setAdapter(adtDevices);   
        lvBTDevices.setOnItemClickListener(new ItemClickEvent());   
         
        btAdapt = BluetoothAdapter.getDefaultAdapter();// 初始化本机蓝牙功能   
         
        if (btAdapt.isEnabled())  
            tbtnSwitch.setChecked(false);   
        else  
            tbtnSwitch.setChecked(true);     
        
          // 注册Receiver来获取蓝牙设备相关的结果  
        String ACTION_PAIRING_REQUEST = "android.bluetooth.device.action.PAIRING_REQUEST"; 
        IntentFilter intent = new IntentFilter();   
        intent.addAction(BluetoothDevice.ACTION_FOUND);// 用BroadcastReceiver来取得搜索结果   
        intent.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED);   
        intent.addAction(ACTION_PAIRING_REQUEST); 
        intent.addAction(BluetoothAdapter.ACTION_SCAN_MODE_CHANGED);   
        intent.addAction(BluetoothAdapter.ACTION_STATE_CHANGED);   
        registerReceiver(searchDevices, intent);   
         
        Button1.setOnClickListener(new Button.OnClickListener() 
        { 
            public void onClick(View arg0) 
            { 
    //          Print1(SelectedBDAddress); 
            } 
        }); 
    } 
 
//--------------------------------------------------- 
     
    private BroadcastReceiver searchDevices = new BroadcastReceiver() {   
           
        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();  
                     
                     
                    try { 
                        ClsUtils.setPin(device.getClass(),device,"0000"); 
                    } catch (Exception e) { 
                        // TODO Auto-generated catch block 
                        e.printStackTrace(); 
                    } 
                    try { 
                        ClsUtils.cancelPairingUserInput(device.getClass(), device); 
                    } catch (Exception e) { 
                        // TODO Auto-generated catch block 
                        e.printStackTrace(); 
                    } 
 
                }   
            }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;   
                }   
            }   
             
             
            if (intent.getAction().equals("android.bluetooth.device.action.PAIRING_REQUEST")) 
            { 
                 
                Log.e("tag11111111111111111111111", "ddd"); 
                BluetoothDevice btDevice = intent 
                        .getParcelableExtra(BluetoothDevice.EXTRA_DEVICE); 
      
                // byte[] pinBytes = BluetoothDevice.convertPinToBytes("1234"); 
                // device.setPin(pinBytes); 
             
                try 
                { 
                    ClsUtils.setPin(btDevice.getClass(), btDevice, "0000"); // 手机和蓝牙采集器配对 
                    ClsUtils.createBond(btDevice.getClass(), btDevice); 
                    ClsUtils.cancelPairingUserInput(btDevice.getClass(), btDevice); 
                } 
                catch (Exception e) 
                { 
                    // TODO Auto-generated catch block 
                    e.printStackTrace(); 
                } 
            } 
        } 
    }; 
     
    class ItemClickEvent implements AdapterView.OnItemClickListener {   
           
        @Override   
        public void onItemClick(AdapterView<?> arg0, View arg1, int arg2,   
                long arg3) {   
            if(btAdapt.isDiscovering())btAdapt.cancelDiscovery();   
            String str = lstDevices.get(arg2);   
            String[] values = str.split("\\|");   
            String address = values[2];   
            Log.e("address", values[2]);   
            BluetoothDevice btDev = btAdapt.getRemoteDevice(address);   
            try {   
                Boolean returnValue = false;   
                if (btDev.getBondState() == BluetoothDevice.BOND_NONE) {   
                    //利用反射方法调用BluetoothDevice.createBond(BluetoothDevice remoteDevice);   
//                    Method createBondMethod = BluetoothDevice.class.getMethod("createBond");   
//                    Log.d("BlueToothTestActivity", "开始配对");   
//                    returnValue = (Boolean) createBondMethod.invoke(btDev);   
                    ClsUtils.pair(address, "0000"); 
                    showMessage("here"); 
                }else if(btDev.getBondState() == BluetoothDevice.BOND_BONDED){   
                    connect(btDev);   
                }   
            } catch (Exception e) {   
                e.printStackTrace();   
            }   
        }   
    }   
       
    private void connect(BluetoothDevice btDev) {  
        final UUID SPP_UUID = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB"); 
        UUID uuid = SPP_UUID;   
        try {   
            btSocket = btDev.createRfcommSocketToServiceRecord(uuid);   
            Log.d("BlueToothTestActivity", "开始连接...");   
            btSocket.connect();   
        } catch (IOException e) {   
            // TODO Auto-generated catch block   
            e.printStackTrace();   
        }   
    }   
   
    class ClickEvent implements View.OnClickListener {   
        @Override   
        public void onClick(View v) {   
            if (v == btnSearch)// 搜索蓝牙设备，在BroadcastReceiver显示结果   
            {   
                if (btAdapt.getState() == BluetoothAdapter.STATE_OFF) {// 如果蓝牙还没开启   
                    Toast.makeText(Demo_ad_escActivity.this, "请先打开蓝牙", 1000).show();                    return;   
                }   
                if (btAdapt.isDiscovering())   
                    btAdapt.cancelDiscovery();   
                lstDevices.clear();   
                Object[] lstDevice = btAdapt.getBondedDevices().toArray();   
                for (int i = 0; i < lstDevice.length; i++) {   
                    BluetoothDevice device = (BluetoothDevice) lstDevice[i];   
                    String str = "已配对|" + device.getName() + "|"   
                            + device.getAddress();   
                    lstDevices.add(str); // 获取设备名称和mac地址   
                    adtDevices.notifyDataSetChanged();   
                }   
                setTitle("本机蓝牙地址：" + btAdapt.getAddress());   
                btAdapt.startDiscovery();   
            } else if (v == tbtnSwitch) {// 本机蓝牙启动/关闭   
                if (tbtnSwitch.isChecked() == false)   
                    btAdapt.enable();   
   
                else if (tbtnSwitch.isChecked() == true)   
                    btAdapt.disable();   
            } else if (v == btnDis)// 本机可以被搜索   
            {   
                Intent discoverableIntent = new Intent(   
                        BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);   
                discoverableIntent.putExtra(   
                        BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 300);   
                startActivity(discoverableIntent);   
            } else if (v == btnExit) {   
                try {   
                    if (btSocket != null)   
                        btSocket.close();   
                } catch (IOException e) {   
                    e.printStackTrace();   
                }   
                Demo_ad_escActivity.this.finish();   
            }   
        }   
    }  
   
    @Override   
    protected void onDestroy() {   
        this.unregisterReceiver(searchDevices);   
        super.onDestroy();   
        android.os.Process.killProcess(android.os.Process.myPid());   
    }   
    public void showMessage(String str) 
    { 
        Toast.makeText(this,str, Toast.LENGTH_LONG).show(); 
    } 
     
} 

caobai
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
android蓝牙连接过程分析(四.2)--配对流程
手机-手表蓝牙开发工程师的博客
01-28 232
这个函数首先创建一个tBTM_SEC_DEV_REC结构体p_dev_rec，也就是安全管理设备记录表，将对端蓝牙设备加入到这个record记录中，并且保存获取到的远端设备的名字到p_dev_rec的sec_bd_name这个成员中，同时将p_dev_rec的标志位设置为BTM_SEC_NAME_KNOWN。btm_sec_execute_procedure这个函数表示我们连接流程的第八，九步，表示以后需要做的事情，因为我们现在还在第六步授权阶段，即将要做的是授权。
Android 11.0 12.0系统设置蓝牙配对时去掉配对框实现直接配对功能
安卓兼职framework和app工程师的博客
11-01 1582
在系统产品开发中，对于系统设置的蓝牙连接配对功能，在实现连接蓝牙设备的时候，在点击配对的时候，会首选弹出配对窗口然后点击确定，才开始配对，为了简化配对流程，产品需求要求去掉配对弹窗，直接配对，这就需要分析配对流程，然后去掉配对弹窗，实现直接配对功能。
Android 取消蓝牙配对框实现自动配对功能
08-31
主要介绍了Android 取消蓝牙配对框实现自动配对功能,非常不错，具有参考借鉴价值，需要的朋友可以参考下
【Android】蓝牙开发——经典蓝牙：配对与解除配对 & 实现配对或连接时不弹出配对框
好记性不如烂笔头，用文档记录技术，方便自己和他人。
12-03 7169
目录 一、配对方法 二、解除配对方法 三、配对/解除配对结果 四、justwork配对模式下，不弹出配对框 五、pincode配对模式下，不弹出配对框 六、小结 在之前的文章【Android】蓝牙开发—— 经典蓝牙配对介绍（Java代码实现演示）附Demo源码中，简单介绍和演示了经典蓝牙的配对方式，今天就在之前的基础上继续讲讲，蓝牙的配对、解除配对以及如何实现不弹出配对框。 关...
Android 蓝牙开发（扫描设备、绑定、解绑，腾讯T2大佬手把手教你
最新发布
2401_83620865的博客
04-03 522
Android架构学习进阶是一条漫长而艰苦的道路，不能靠一时激情，更不是熬几天几夜就能学好的，必须养成平时努力学习的习惯。所以：贵在坚持！上面分享的字节跳动公司2020年的面试真题解析大全，笔者还把一线互联网企业主流面试技术要点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节。就先写到这，码字不易，写的很片面不好之处敬请指出，如果觉得有参考价值的朋友也可以关注一下我。
android bluetooth——蓝牙的开启、搜索、配对与连接
热门推荐
boolean的博客
09-30 8万+
android 的blt仅仅支持api 18 android4.3以上，有的功能甚至需要api 19 android4.4； 所以我们在做blt项目之前一定要清楚可用的版本范围。我要讲述的是打开blt大门的操作。这些操作就是如何打开blt、如何搜索到其他设备、如何配对选中设备、如何通过mac地址连接之前已经配对过的设备以及连接成功的两个（或一对多个）设备如何通讯。在学习blt知识前要先搞清楚，bl
安卓去掉已配对的蓝牙
01-16 1690
可以把手机蓝牙的已配对设备全部清除掉，代码如下，已验证，是把所有已配对的蓝牙都一起清空的。
android 取消蓝牙配对框,android - 蓝牙配对 - 如何显示简单的取消/配对对话框？ - 堆栈内存溢出...
weixin_42509396的博客
05-30 719
我在GitHub为这个问题准备了一个简单的测试项目 。我正在尝试创建一个Android应用程序，它将从计算机屏幕扫描QR代码，然后使用数据(MAC地址和PIN或哈希)与蓝牙设备轻松配对(绑定)。类似于流行的InstaWifi应用程序 - 但对于经典蓝牙。出于测试目的，我还没有进行任何条形码扫描，只是显示设备列表： 用户触摸其中一个设备后，在MainActivity.java中尝试配对：privat...
Android蓝牙搜索自动配对通信Demo下载
02-18
在android蓝牙自动配对的基础上增加了其通信代码，主要实现与Arduino端的通信。 详见我的博客： http://blog.csdn.net/qq_25827845/article/details/52997523
android 蓝牙自动配对
11-15
亲测调试可用，没有扫描，主要是自动配对功能，无配对提示框
蓝牙_搜索_配对_取消配对—demo
08-02
此demo中包含一些简单操作，如：搜索附近设备，进行配对，取消配对等。
android 蓝牙自动配对 无需手动输入
01-26
这个demo 是用来 自动配对蓝牙打印机 无需手动输入配对码，隐藏配对框，因为打印机配对码是已知“0000”，我在代码写死了，要自动配对要写入相对应的配对码。 这个demo 是 sdk android 2.1 上做的。 下载的朋友可以...
Android 蓝牙BluetoothAdapter 相关(一)
赵航的博客
12-12 822
本文主要讲述android 蓝牙的简单使用.
Android车机系统-蓝牙自动连接，关闭蓝牙配对对话框解决方案
lzz214的博客
07-27 873
在特定页面中开启车机蓝牙，手机端会弹出配对对话框，但车机端不弹出对话框，直接执行点击确定后的逻辑。具体解决方案如下：
android蓝牙开启和关闭
Yw的博客
11-04 2712
android蓝牙开启和关闭
android 取消蓝牙配对
06-09
在 Android 上取消蓝牙配对，可以按照以下步骤进行操作： 1. 打开 Android 设备的蓝牙设置，找到已经配对的蓝牙设备。 2. 点击需要取消配对的蓝牙设备，进入设备详情页面。 3. 在设备详情页面中，找到取消配对的选项，一般为“取消配对”或“忘记设备”。 4. 点击取消配对按钮，等待一段时间后，设备的配对信息就会被删除。 注意：取消配对后，设备之间的连接也会断开，如果需要重新连接，需要重新进行配对操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值