Android 蓝牙配对、连接和通信

最新推荐文章于 2024-03-28 16:14:28 发布
最新推荐文章于 2024-03-28 16:14:28 发布
阅读量396 收藏
点赞数
文章标签： Android 蓝牙
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41122667/article/details/102977057
版权

效果
在这里插入图片描述

权限

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

动态申请权限

public class ApplyPermission {

    public static void ApplyPermission(Context context) {
        ActivityCompat.requestPermissions((Activity) context, new String[]{
                Manifest.permission.BLUETOOTH,
                Manifest.permission.BLUETOOTH_ADMIN,
        }, 1);
    }
}

连接工具类

/**
 * @anthor GrainRain
 * @funcation 蓝牙连接工具类
 * @date 2019/11/7
 */
public class Util {

    //存放蓝牙设备名列表
    private static ArrayList<String> deviceNameList = new ArrayList<>();
    //存放蓝牙设备mac地址列表
    private static ArrayList<String> deviceMacList = new ArrayList<>();
    //存放蓝牙设备名和地址 用于显示
    private static ArrayList<String> deviceMsgList = new ArrayList<>();
    //存放已配对蓝牙列表
    private static ArrayList<String> pairedDeviceNameList = new ArrayList<>();

    private static Context context;
    private static BluetoothDevice btDevice;
    private static ArrayList<BluetoothDevice> btDeviceList = new ArrayList<>();
    private static OnConnectListener onConnectListener;

    private static final String[] items = new String[100];
    private static ArrayAdapter<String> adapter = null;
    private static BluetoothAdapter blueadapter;

    //这条是蓝牙串口通用的UUID，不要更改
    private static final UUID MY_UUID = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");

    private static BluetoothSocket btSocket = null;
    private static OutputStream outStream = null;
    private static InputStream inStream = null;
    private static int deviceMatchingNum = 0;
    private static boolean deviceMatching = false;

    private static ReceiveThread rThread = null;  //数据接收线程

    public Util() {
        for(int i = 0; i < items.length; i++) {
            items[i] = "";
        }
    }

    public void get(Context context, OnConnectListener listener) {
        setContext(context);
        showListDialog();
        blueadapter = BluetoothAdapter.getDefaultAdapter();

        //判断蓝牙是否打开
        if(!blueadapter.isEnabled()) {
//            blueadapter.enable();
        } else {
            getContext().registerReceiver(bluetoothReceiver, intentFilter);//用BroadcastReceiver 来取得结果
            doDiscovry();
        }

        setOnConnectListener(listener);
        listener.onConnectSuccess(null);
        listener.onConnectFailed(null);
    }

    static IntentFilter intentFilter = new IntentFilter(BluetoothDevice.ACTION_FOUND);//注册广播接收信号
    private static final BroadcastReceiver bluetoothReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {

            String action = intent.getAction(); //得到action

            //创建一个蓝牙device对象 从Intent中获取设备对象
            btDevice = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
            btDeviceList.add(btDevice);

            //获取已配对蓝牙列表
//            Set<BluetoothDevice> devices = blueadapter.getBondedDevices();
//            for (BluetoothDevice bluetoothDevice : devices) {
//                pairedDeviceNameList.add(bluetoothDevice.getName());
//            }

            //发现设备
            if(BluetoothDevice.ACTION_FOUND.equals(action)){

                BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
                deviceMsgList.add(device.getName() + " " + device.getAddress());//将搜索到的蓝牙名称和地址添加到列表
                deviceNameList.add(device.getName());       //将搜索到的蓝牙名称添加到列表
                deviceMacList.add(device.getAddress());     //将搜索到的蓝牙地址添加到列表

                Log.w("-----------------", deviceMsgList.get(deviceMsgList.size()-1));
                items[deviceMsgList.size()-1] = deviceMsgList.get(deviceMsgList.size()-1);
                adapter.notifyDataSetChanged();
            }
        }
    };

    private static void doDiscovry() {
        if (blueadapter.isDiscovering()) {
            //判断蓝牙是否正在扫描，如果是调用取消扫描方法；如果不是，则开始扫描
            blueadapter.cancelDiscovery();
        } else
            blueadapter.startDiscovery();
    }

    //搜索到的蓝牙列表
    private void showListDialog() {
        final AlertDialog.Builder listDialog = new AlertDialog.Builder(context);
        adapter = new ArrayAdapter<String>(getContext(), android.R.layout.simple_list_item_1, items);

        listDialog.setAdapter(adapter, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialogInterface, int i) {

                for(int j = 0; j < btDeviceList.size(); j++) {
                    if(btDeviceList.get(j).getAddress().equals(btDeviceList.get(i).getAddress())) {
                        deviceMatching = true;
                        deviceMatchingNum = j;
                    }
                }

                //连接配对
                if(deviceMatching) {
                    //HC-05设备如果有多个，第一个搜到的那个会被尝试。
                    if (btDeviceList.get(deviceMatchingNum).getBondState() == BluetoothDevice.BOND_NONE) {
                        //未配对 进行配对
                        try {
                            //通过工具类ClsUtils,调用createBond方法
                            PairUtils.createBond(btDeviceList.get(deviceMatchingNum).getClass(), btDeviceList.get(deviceMatchingNum));
                        } catch (Exception e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    } else {
                        //已配对 进行连接
                        //mac 要连接的目标蓝牙设备MAC地址
                        new ConnectTask().execute(deviceMacList.get(deviceMatchingNum));
                    }
                }
            }
        });

        listDialog.setPositiveButton("返回", new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface paramAnonymousDialogInterface, int paramAnonymousInt) {
                listDialog.create();
            }
        });
        listDialog.show();
    }

    //连接蓝牙设备的异步任务
    static class ConnectTask extends AsyncTask<String,String,String> {
        @Override
        protected String doInBackground(String... params) {
            // TODO Auto-generated method stub
            BluetoothDevice device = blueadapter.getRemoteDevice(params[0]);
            try {
                btSocket = device.createRfcommSocketToServiceRecord(MY_UUID);
                btSocket.connect();
                Log.e("error", "ON RESUME: BT connection established, data transfer link open.");
            } catch (IOException e) {
                try {

                    //将异常信息传递给回调接口
                    if(getOnConnectListener() != null) {
                        getOnConnectListener().onConnectFailed(e);
                    }
                    btSocket.close();
                    return "Socket 创建失败";
                } catch (IOException e2) {

                    //将异常信息传递给回调接口
                    if(getOnConnectListener() != null) {
                        getOnConnectListener().onConnectFailed(e2);
                    }
                    Log .e("error","ON RESUME: Unable to close socket during connection failure", e2);
                    return "Socket 关闭失败";
                }
            }
            //取消搜索
            blueadapter.cancelDiscovery();
            try {
                outStream = btSocket.getOutputStream();
            } catch (IOException e) {

                //将异常信息传递给回调接口
                if(getOnConnectListener() != null) {
                    getOnConnectListener().onConnectFailed(e);
                }
                Log.e("error", "ON RESUME: Output stream creation failed.", e);
                return "Socket 流创建失败";
            }
            return "蓝牙连接正常,Socket 创建成功";
        }

        @Override    //这个方法是在主线程中运行的，所以可以更新界面
        protected void onPostExecute(String result) {
            // TODO Auto-generated method stub
            //连接成功则启动监听
            rThread = new ReceiveThread();
            rThread.start();
            Log.e("Bluetooth", "连接状态:" + result);

            super.onPostExecute(result);
        }
    }

    //从蓝牙接收信息的线程
    static class ReceiveThread extends Thread {
        @Override
        public void run() {
            while(btSocket != null ) {

                //定义一个存储空间buff
                byte[] buff = new byte[1024];
                try {
                    inStream = btSocket.getInputStream();
                    System.out.println("waitting for instream");

                    if(inStream != null) {
                        inStream.read(buff); //读取数据存储在buff数组中
                    }
                    processBuffer(buff,1024);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        public void processBuffer(byte[] buff,int size) {
            int length = 0;
            for(int i = 0; i < size; i++) {
                if(buff[i] > '\0') {
                    length++;
                } else {
                    break;
                }
            }

            //newbuff字节数组，用于存放真正接收到的数据
            byte[] newbuff = new byte[length];
            int[] receiveData = new int[length];

            for(int j = 0; j < length; j++) {
                newbuff[j] = buff[j];
                receiveData[j] = buff[j] & 0xff;
            }

            Log.w("收到数据: ", Arrays.toString(receiveData));
            //回调
            if(getOnConnectListener() != null) {
                getOnConnectListener().onConnectSuccess(receiveData);
            }
        }
    }

    //发送String数据到蓝牙设备的异步任务
    static class SendInfoTask extends AsyncTask<String,String,String> {

        @Override
        protected void onPostExecute(String result) {
            // TODO Auto-generated method stub
            super.onPostExecute(result);
            Log.e("Bluetooth", "连接状态:" + result);
        }

        @Override
        protected String doInBackground(String... arg0) {

            // TODO Auto-generated method stub
            if(btSocket == null) {

                new ConnectTask().execute(deviceMacList.get(deviceMatchingNum));

                return "还没有创建连接";
            }

            if(arg0[0].length()>0) {
                //不是空白串
                //String target=arg0[0];
                byte[] msgBuffer = arg0[0].getBytes();
                try {
                    if(outStream != null) {
                        //  将msgBuffer中的数据写到outStream对象中
                        outStream.write(msgBuffer);
                    }
                } catch (IOException e) {
                    Log.e("error", "ON RESUME: Exception during write.", e);
                    return "发送失败";
                }
            }
            return "发送成功";
        }
    }

    //发送byte数据到蓝牙设备的异步任务
       /*
     static class SendInfoTask extends AsyncTask<byte[], String, String> {
        @Override
        protected String doInBackground(byte[]... bytes) {

            try {
                outStream.write(bytes[0]);
            } catch (IOException e) {
                e.printStackTrace();
            }
        return null;
    }

    @Override
    protected void onPostExecute(String result) {
        // TODO Auto-generated method stub
        super.onPostExecute(result);
    }
}
*/


    //回调接口
    public interface OnConnectListener{
        //连接成功
        void onConnectSuccess(int[] msg);
        //连接异常信息
        void onConnectFailed(Exception e);
    }

    public static OnConnectListener getOnConnectListener() {
        return onConnectListener;
    }

    public void setOnConnectListener(OnConnectListener onConnectListener) {
        this.onConnectListener = onConnectListener;
    }

    public static Context getContext() {
        return context;
    }

    public void setContext(Context context) {
        this.context = context;
    }
}

配对工具类

/**
 * @anthor GrainRain
 * @funcation 配对工具类
 * @date 2019/10/25
 */
public class PairUtils {

    /**
     * 与设备配对 参考源码：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", 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(btClass, device);
        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) {

            // 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();
        }
    }
}

使用 activity

	//打开蓝牙
	if(!BluetoothAdapter.getDefaultAdapter().isEnabled()) {
       BluetoothAdapter.getDefaultAdapter().enable();
    }

通过回调接收信息

    new Util().get(BlueAct.this, new Util.OnConnectListener() {
        @Override
        public void onConnectSuccess(int[] msg) {

        }

        @Override
        public void onConnectFailed(Exception e) {

        }
    });
GrainRain_x
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
蓝牙自动配对连接通信
09-24
Android蓝牙自动配对demo，如果需要手动配对修改一下socket获取方式，代码中是不用配对就可连接通信
android BlueToothDemo （蓝牙搜索，配对，连接，传输）详细讲解见博客
09-30
详细讲解见博客地址：http://blog.csdn.net/yehui928186846/article/details/52710112
Android蓝牙开发（二）之蓝牙配对和蓝牙连接
最新发布
erghtt的博客
03-28 608
希望本文对你有所启发，有任何面试上的建议也欢迎留言分享给大家。好了，今天的分享就到这里，如果你对在面试中遇到的问题，或者刚毕业及工作几年迷茫不知道该如何准备面试并突破现状提升自己，对于自己的未来还不够了解不知道给如何规划，来看看同行们都是如何突破现状，怎么学习的，来吸收他们的面试以及工作经验完善自己的之后的面试计划及职业规划。好了~如果你看到了这里，觉得文章写得不错就给个赞呗？如果你觉得那里值得改进的，请给我留言。一定会认真查询，修正不足。
Android中如何实现蓝牙的配对与连接
funkidd的博客
03-11 2289
https://blog.csdn.net/u012910985/article/details/50387551 绑定(配对)和连接是两个不同的过程，绑定是指两个设备发现了对方的存在，可以获取到对方的名称、地址等信息，有能力建立起连接；连接是指两个设备共享了一个RFCOMM通道，有能力进行数据互传。确认绑定上了之后，才能开始连接。可以试试蓝牙音箱的连接过程，就是先点击一次，开始配对...
Android 蓝牙连接与通讯，BLE蓝牙和经典蓝牙一起的蓝牙连接与通讯案例
进击的Ace
07-28 484
Android 蓝牙有两种，一种是BLE蓝牙，另外一种是经典蓝牙。 BLE蓝牙连接与通讯使用的是BluetoothKit 框架，BluetoothKit 框架源码地址与说明： https://gitee.com/www163/Android-BluetoothKit BluetoothKit 的弊端是经典蓝牙连接失败。 所以经典蓝牙，自己写了连接和通讯方式。 对于通讯来讲，分为服务端BtSer...
java实现蓝牙通信程序_Android蓝牙通信聊天实现发送和接受功能
weixin_30101051的博客
02-28 2668
很不错的蓝牙通信demo实现发送和接受功能,就用了两个类就实现了，具体内容如下说下思路把 主要有两个类主界面类和 蓝牙聊天服务类。 首先创建线程 实际上就是创建BluetoothChatService()(蓝牙聊天服务类) 这个时候把handler 传过去 这样就可以操作UI 界面了，在线程中不断轮询读取蓝牙消息，当主界面点击发送按钮时 调用BluetoothChatService的发送方法wri...
【Android -- 蓝牙】蓝牙配对和蓝牙连接
Kevin Learn Android
12-09 4065
本篇文章主要介绍 蓝牙配对和蓝牙连接
android bluetooth——蓝牙的开启、搜索、配对与连接
热门推荐
boolean的博客
09-30 8万+
android 的blt仅仅支持api 18 android4.3以上，有的功能甚至需要api 19 android4.4； 所以我们在做blt项目之前一定要清楚可用的版本范围。我要讲述的是打开blt大门的操作。这些操作就是如何打开blt、如何搜索到其他设备、如何配对选中设备、如何通过mac地址连接之前已经配对过的设备以及连接成功的两个（或一对多个）设备如何通讯。在学习blt知识前要先搞清楚，bl
Android 蓝牙开发之搜索、配对、连接、通信大全
weixin_33686714的博客
11-01 5353
蓝牙（ Bluetooth®）：是一种无线技术标准，可实现固定设备、移动设备和楼宇个人域网之间的短距离数据交换（使用2.4—2.485GHz的ISM波段的UHF无线电波）。蓝牙设备最多可以同时和7个其它蓝牙设备建立连接，进行通信，当然并不是每一个蓝牙都可以达到最大值。下面，我们从蓝牙的基本概念开始，一步一步开始了解蓝牙。（尊重劳动成果，转载请注明出处http://blog....
Android开发蓝牙篇之蓝牙配对、连接与接收数据
D_inosaur的博客
08-23 7406
在android端通过蓝牙地址获得蓝牙设备对象，实现android设备的蓝牙配对、连接与接收数据
Android蓝牙搜索自动配对通信Demo下载
02-18
在android蓝牙自动配对的基础上增加了其通信代码，主要实现与Arduino端的通信。 详见我的博客： http://blog.csdn.net/qq_25827845/article/details/52997523
Android蓝牙，配对，搜索，连接，通信，断开的Demo
09-15
这是一个Android AppDemo项目，用Kotlin语言编写，实现了经典蓝牙的搜索，配对，取消配对，连接，通信，断开连接的功能
androidstudio app连接蓝牙模块进行通信
08-01
app连接蓝牙模块2.0进行互相通讯，使用androidstudio编写，页面相对简单，但是功能完善，蓝牙必须先配对再在app中连接
Android 12 蓝牙适配 Java版
晨曦
01-06 5340
  本身已经写过一篇关于蓝牙适配的文章了，不过因为是Kotlin，很多读者看不懂，对此我深感无奈，一开始也没有想过再写Java版本的，但是后面发现看不懂的越来越多了，我意识到不对劲了，因此我觉得再写一个Java版本的。   在Android系统版本中，蓝牙的变化有，但是不多，这里简要说明一下。  在Android12.0中新增加了三个运行时权限，我们依次来说明一下，这里我们依然创建一个项目来说明，新建一个Android12Bluetooth-Java项目，如下图所示： 点击Finish，完成项目的创建。然后
android开发之蓝牙配对连接的方法
Jenney_TEN的博客
06-04 872
新年第一篇。 最近在做蓝牙开锁的小项目，手机去连接单片机总是出现问题，和手机的连接也不稳定，看了不少蓝牙方面的文档，做了个关于蓝牙连接的小结。 在做Android蓝牙串口连接的时候一般会使用 [java] view plain copy  print? BluetoothSocket tmp = null;   // Get a Blueto
Android通过蓝牙发送数据到Windows PC电脑：Java实现
Zhang Phil
10-18 6916
Android通过蓝牙发送数据到Windows PC电脑：Java实现 Android手机设备之间通过蓝牙连接然后发送数据，这在我之前的蓝牙专栏里面有介绍，详情见专栏：https://blog.csdn.net/column/details/17325.html 但是通常还有一种功能需求是Android手机如何通过蓝牙把数据传输到Windows PC上呢？这在需求还很常见，比如用户通过Andro...
java 安卓 蓝牙_Android 串口蓝牙通信开发Java版本
weixin_39574708的博客
02-13 881
Android串口BLE蓝牙通信Java版0. 导语我们都知道，在物联网中，BLE蓝牙是通信设备的关键设备。在传统的物联网应用中，无线WIFI、蓝牙和Zigbee，还有一些其他的2.4GHz的无线网卡等。对于一个面向物联网的嵌入式工程师来讲，不单单是要学会底层硬件嵌入式或者是嵌入式Linux驱动的开发，还要掌握上层应用，以理解开发流程，方便未来和软件应用工程师协作开发。“也只有穿别人的鞋子，才知道...
android 蓝牙广播协议,Android蓝牙协议-蓝牙配对与连接
weixin_28761455的博客
05-25 707
蓝牙设备在连接前，会先检查设备是否已经配对过，如果没有则先配对，配对完成后，再开始连接。onPreferenceTreeClick蓝牙连接开始于设备列表 DeviceListPreferenceFragment的onPreferenceTreeClick方法。DeviceListPreferenceFragment是蓝牙设备列表，点击其中一个蓝牙设备，开始蓝牙的连接过程。@Overridepubl...
android蓝牙搜索自动配对通信demo
04-27
Android操作系统具有本身具有蓝牙功能，并且提供蓝牙API，方便开发人员进行蓝牙开发。本文将介绍如何创建一...总之，这是一个简单但完整的Android蓝牙搜索、自动配对和通信的Demo，用于学习蓝牙开发的基本思想和方法。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值