devbox
运维做开发
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

基于Android Studio实现蓝牙组网_androidstudio蓝牙开发

作者：运维做开发 | 2024-08-10 01:25:45

赞

踩

androidstudio蓝牙开发

参考文章：http://t.csdnimg.cn/hVDdT

Android-蓝牙开发：解决搜索不到蓝牙设备_android项目中无法搜索到蓝牙-CSDN博客

第一篇是参考代码来源，第二篇是解决第一篇出现的搜索不到设备的问题。

演示视频：【第三步：成功啦！】 https://www.bilibili.com/video/BV1KJ4m1A7LQ/?share_source=copy_web&vd_source=feda4a3e701cae91ddc70f622b5b48d6

纠正视频里面的话，原帖主肯定是明白原理，但是我本人是照抄代码，没有搞清楚原理，因此是我自己的问题，如果有明白为什么会出现我视频里面问题的朋友可以留言告知我，我一定改正！！ 

根据第一篇文章提供的源码链接下载后复制到自己的项目中，解决各种报错，并在主代码中添加第二篇文章提供的代码并调用getPermission()后，即可运行。

activity

bluet.java

  1. package com.example.yueduqi;
  2.  
  3. import android.annotation.SuppressLint;
  4. import android.bluetooth.BluetoothAdapter;
  5. import android.bluetooth.BluetoothDevice;
  6. import android.bluetooth.BluetoothSocket;
  7. import android.content.BroadcastReceiver;
  8. import android.content.Context;
  9. import android.content.Intent;
  10. import android.content.IntentFilter;
  11. import android.content.pm.PackageManager;
  12. import android.os.Build;
  13. import android.os.Bundle;
  14. import android.os.Handler;
  15. import android.os.Message;
  16. import android.text.TextUtils;
  17. import android.util.Log;
  18. import android.view.View;
  19. import android.widget.AdapterView;
  20. import android.widget.Button;
  21. import android.widget.EditText;
  22. import android.widget.LinearLayout;
  23. import android.widget.ListView;
  24. import android.widget.TextView;
  25. import android.widget.Toast;
  26. import com.example.yueduqi.util.ClsUtils;
  27. import androidx.appcompat.app.AppCompatActivity;
  28. import androidx.core.app.ActivityCompat;
  29.  
  30.  
  31. public class bluet extends AppCompatActivity implements View.OnClickListener {
  32.  
  33.     private static final String TAG = "BtMain";
  34.  
  35.     private static final int CONNECT_SUCCESS = 0x01;
  36.     private static final int CONNECT_FAILURE = 0x02;
  37.     private static final int DISCONNECT_SUCCESS = 0x03;
  38.     private static final int SEND_SUCCESS = 0x04;
  39.     private static final int SEND_FAILURE = 0x05;
  40.     private static final int RECEIVE_SUCCESS = 0x06;
  41.     private static final int RECEIVE_FAILURE = 0x07;
  42.     private static final int START_DISCOVERY = 0x08;
  43.     private static final int STOP_DISCOVERY = 0x09;
  44.     private static final int DISCOVERY_DEVICE = 0x0A;
  45.     private static final int DEVICE_BOND_NONE = 0x0B;
  46.     private static final int DEVICE_BONDING = 0x0C;
  47.     private static final int DEVICE_BONDED = 0x0D;
  48.  
  49.     private Button btSearch;
  50.     private TextView tvCurConState;
  51.     private TextView tvCurBondState;
  52.     private TextView tvName;
  53.     private TextView tvAddress;
  54.     private Button btConnect;
  55.     private Button btDisconnect;
  56.     private Button btBound;
  57.     private Button btDisBound;
  58.     private EditText etSendMsg;
  59.     private Button btSend;
  60.     private TextView tvSendResult;
  61.     private TextView tvReceive;
  62.     private LinearLayout llDeviceList;
  63.     private LinearLayout llDataSendReceive;
  64.     private ListView lvDevices;
  65.     private LVDevicesAdapter lvDevicesAdapter;
  66.  
  67.     //蓝牙
  68.     private BluetoothAdapter bluetoothAdapter;
  69.     private BtBroadcastReceiver btBroadcastReceiver;
  70.     //连接设备的UUID
  71.     public static final String MY_BLUETOOTH_UUID = "00001101-0000-1000-8000-00805F9B34FB";  //蓝牙通讯
  72.     //当前要连接的设备
  73.     private BluetoothDevice curBluetoothDevice;
  74.     //发起连接的线程
  75.     private ConnectThread connectThread;
  76.     //管理连接的线程
  77.     private ConnectedThread connectedThread;
  78.     //当前设备连接状态
  79.     private boolean curConnState = false;
  80.     //当前设备与系统配对状态
  81.     private boolean curBondState = false;
  82.  
  83.  
  84.     @SuppressLint("HandlerLeak")
  85.     private Handler mHandler = new Handler() {
  86.         @Override
  87.         public void handleMessage(Message msg) {
  88.             super.handleMessage(msg);
  89.  
  90.             switch (msg.what) {
  91.                 case START_DISCOVERY:
  92.                     Log.d(TAG, "开始搜索设备...");
  93.                     break;
  94.  
  95.                 case STOP_DISCOVERY:
  96.                     Log.d(TAG, "停止搜索设备...");
  97.                     break;
  98.  
  99.                 case DISCOVERY_DEVICE:  //扫描到设备
  100.                     BluetoothDevice bluetoothDevice = (BluetoothDevice) msg.obj;
  101.                     lvDevicesAdapter.addDevice(bluetoothDevice);
  102.  
  103.                     break;
  104.  
  105.                 case CONNECT_FAILURE: //连接失败
  106.                     Log.d(TAG, "连接失败");
  107.                     tvCurConState.setText("连接失败");
  108.                     curConnState = false;
  109.                     break;
  110.  
  111.                 case CONNECT_SUCCESS:  //连接成功
  112.                     Log.d(TAG, "连接成功");
  113.                     tvCurConState.setText("连接成功");
  114.                     curConnState = true;
  115.                     llDataSendReceive.setVisibility(View.VISIBLE);
  116.                     llDeviceList.setVisibility(View.GONE);
  117.                     break;
  118.  
  119.                 case DISCONNECT_SUCCESS:
  120.                     tvCurConState.setText("断开成功");
  121.                     curConnState = false;
  122.  
  123.                     break;
  124.  
  125.                 case SEND_FAILURE: //发送失败
  126.                     Toast.makeText(bluet.this, "发送失败", Toast.LENGTH_SHORT).show();
  127.                     break;
  128.  
  129.                 case SEND_SUCCESS:  //发送成功
  130.                     String sendResult = (String) msg.obj;
  131.                     tvSendResult.setText(sendResult);
  132.                     break;
  133.  
  134.                 case RECEIVE_FAILURE: //接收失败
  135.                     String receiveError = (String) msg.obj;
  136.                     tvReceive.setText(receiveError);
  137.                     break;
  138.  
  139.                 case RECEIVE_SUCCESS:  //接收成功
  140.                     String receiveResult = (String) msg.obj;
  141.                     tvReceive.setText(receiveResult);
  142.                     break;
  143.  
  144.                 case DEVICE_BOND_NONE:  //已解除配对
  145.                     tvCurBondState.setText("解除配对成功");
  146.                     curBondState = false;
  147.  
  148.                     break;
  149.  
  150.                 case DEVICE_BONDING:   //正在配对
  151.                     tvCurBondState.setText("正在配对...");
  152.                     break;
  153.  
  154.                 case DEVICE_BONDED:   //已配对
  155.                     tvCurBondState.setText("配对成功");
  156.                     curBondState = true;
  157.                     break;
  158.             }
  159.         }
  160.     };
  161.  
  162.  
  163.     @Override
  164.     protected void onCreate(Bundle savedInstanceState) {
  165.         super.onCreate(savedInstanceState);
  166.         setContentView(R.layout.bluetooth);
  167.  
  168.         //初始化视图
  169.         initView();
  170.         //初始化监听
  171.         iniListener();
  172.         //初始化数据
  173.         initData();
  174.         //初始化蓝牙
  175.         initBluetooth();
  176.         //初始化蓝牙广播
  177.         initBtBroadcast();
  178.         //安卓版本升级蓝牙连接需要获取位置
  179.         getPermission();
  180.     }
  181.  
  182.     private void initData() {
  183.         lvDevicesAdapter = new LVDevicesAdapter(bluet.this);
  184.         lvDevices.setAdapter(lvDevicesAdapter);
  185.     }
  186.  
  187.     private void initView() {
  188.         btSearch = findViewById(R.id.bt_search);
  189.         tvCurConState = findViewById(R.id.tv_cur_con_state);
  190.         tvCurBondState = findViewById(R.id.tv_cur_bond_state);
  191.         btConnect = findViewById(R.id.bt_connect);
  192.         btDisconnect = findViewById(R.id.bt_disconnect);
  193.         btBound = findViewById(R.id.bt_bound);
  194.         btDisBound = findViewById(R.id.bt_disBound);
  195.         tvName = findViewById(R.id.tv_name);
  196.         tvAddress = findViewById(R.id.tv_address);
  197.         etSendMsg = findViewById(R.id.et_send_msg);
  198.         btSend = findViewById(R.id.bt_to_send);
  199.         tvSendResult = findViewById(R.id.tv_send_result);
  200.         tvReceive = findViewById(R.id.tv_receive_result);
  201.         llDeviceList = findViewById(R.id.ll_device_list);
  202.         llDataSendReceive = findViewById(R.id.ll_data_send_receive);
  203.         lvDevices = findViewById(R.id.lv_devices);
  204.     }
  205.  
  206.     private void iniListener() {
  207.         btSearch.setOnClickListener(this);
  208.         btConnect.setOnClickListener(this);
  209.         btDisconnect.setOnClickListener(this);
  210.         btBound.setOnClickListener(this);
  211.         btDisBound.setOnClickListener(this);
  212.         btSend.setOnClickListener(this);
  213.  
  214.         lvDevices.setOnItemClickListener(new AdapterView.OnItemClickListener() {
  215.             @Override
  216.             public void onItemClick(AdapterView<?> adapterView, View view, int i, long l) {
  217.                 BluetoothDevice bluetoothDevice = (BluetoothDevice) lvDevicesAdapter.getItem(i);
  218.                 if (ActivityCompat.checkSelfPermission(bluet.this, android.Manifest.permission.BLUETOOTH_CONNECT) != PackageManager.PERMISSION_GRANTED) {
  219.                     // TODO: Consider calling
  220.                     //    ActivityCompat#requestPermissions
  221.                     // here to request the missing permissions, and then overriding
  222.                     //   public void onRequestPermissionsResult(int requestCode, String[] permissions,
  223.                     //                                          int[] grantResults)
  224.                     // to handle the case where the user grants the permission. See the documentation
  225.                     // for ActivityCompat#requestPermissions for more details.
  226.                     return;
  227.                 }
  228.                 tvName.setText(bluetoothDevice.getName());
  229.                 tvAddress.setText(bluetoothDevice.getAddress());
  230.                 curBluetoothDevice = bluetoothDevice;
  231.             }
  232.         });
  233.     }
  234.  
  235.  
  236.     @Override
  237.     public void onClick(View view) {
  238.         if (view.getId() == R.id.bt_search) { // 搜索蓝牙
  239.             llDataSendReceive.setVisibility(View.GONE);
  240.             llDeviceList.setVisibility(View.VISIBLE);
  241.             searchBtDevice();
  242.         } else if (view.getId() == R.id.bt_connect) { // 连接蓝牙
  243.             if (!curConnState) {
  244.                 startConnectDevice(curBluetoothDevice, MY_BLUETOOTH_UUID, 10000);
  245.             } else {
  246.                 Toast.makeText(this, "当前设备已连接", Toast.LENGTH_SHORT).show();
  247.             }
  248.         } else if (view.getId() == R.id.bt_disconnect) { // 断开连接
  249.             if (curConnState) {
  250.                 clearConnectedThread();
  251.             } else {
  252.                 Toast.makeText(this, "当前设备未连接", Toast.LENGTH_SHORT).show();
  253.             }
  254.         } else if (view.getId() == R.id.bt_bound) { // 配对设备
  255.             if (!curBondState) {
  256.                 boundDevice(curBluetoothDevice);
  257.             } else {
  258.                 Toast.makeText(this, "当前设备已经与系统蓝牙建立配对", Toast.LENGTH_SHORT).show();
  259.             }
  260.         } else if (view.getId() == R.id.bt_disBound) { // 解除配对
  261.             if (curBondState) {
  262.                 disBoundDevice(curBluetoothDevice);
  263.             } else {
  264.                 Toast.makeText(this, "当前设备尚未与系统蓝牙建立配对", Toast.LENGTH_SHORT).show();
  265.             }
  266.         } else if (view.getId() == R.id.bt_to_send) { // 发送数据
  267.             if (curConnState) {
  268.                 String sendMsg = etSendMsg.getText().toString();
  269.                 if (sendMsg.isEmpty()) {
  270.                     Toast.makeText(this, "发送数据为空！", Toast.LENGTH_SHORT).show();
  271.                     return;
  272.                 }
  273.                 sendData(sendMsg, true); // 以16进制字符串形式发送数据
  274.             } else {
  275.                 Toast.makeText(this, "请先连接当前设备", Toast.LENGTH_SHORT).show();
  276.             }
  277.         }
  278.         // 注意：这里没有else块，因为如果没有匹配到任何ID，则不执行任何操作
  279.     }
  280.  
  281.     /**
  282.      * 解决：无法发现蓝牙设备的问题
  283.      *
  284.      * 对于发现新设备这个功能, 还需另外两个权限(Android M 以上版本需要显式获取授权,附授权代码):
  285.      */
  286.     private final int ACCESS_LOCATION=1;
  287.     @SuppressLint("WrongConstant")
  288.     private void getPermission() {
  289.         if (Build.VERSION.SDK_INT > Build.VERSION_CODES.M) {
  290.             int permissionCheck = 0;
  291.             permissionCheck = this.checkSelfPermission(android.Manifest.permission.ACCESS_FINE_LOCATION);
  292.             permissionCheck += this.checkSelfPermission(android.Manifest.permission.ACCESS_COARSE_LOCATION);
  293.  
  294.             if (permissionCheck != PackageManager.PERMISSION_GRANTED) {
  295.                 //未获得权限
  296.                 this.requestPermissions( // 请求授权
  297.                         new String[]{android.Manifest.permission.ACCESS_FINE_LOCATION,
  298.                                 android.Manifest.permission.ACCESS_COARSE_LOCATION},
  299.                         ACCESS_LOCATION);// 自定义常量,任意整型
  300.             }
  301.         }
  302.     }
  303.  
  304.     /**
  305.      * 请求权限的结果回调。每次调用 requestpermissions（string[]，int）时都会调用此方法。
  306.      * @param requestCode 传入的请求代码
  307.      * @param permissions 传入permissions的要求
  308.      * @param grantResults 相应权限的授予结果:PERMISSION_GRANTED 或 PERMISSION_DENIED
  309.      */
  310.     @Override
  311.     public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
  312.         super.onRequestPermissionsResult(requestCode, permissions, grantResults);
  313.         switch (requestCode) {
  314.             case ACCESS_LOCATION:
  315.                 if (hasAllPermissionGranted(grantResults)) {
  316.                     Log.i(TAG, "onRequestPermissionsResult: 用户允许权限");
  317.                 } else {
  318.                     Log.i(TAG, "onRequestPermissionsResult: 拒绝搜索设备权限");
  319.                 }
  320.                 break;
  321.         }
  322.     }
  323.  
  324.     private boolean hasAllPermissionGranted(int[] grantResults) {
  325.         for (int grantResult : grantResults) {
  326.             if (grantResult == PackageManager.PERMISSION_DENIED) {
  327.                 return false;
  328.             }
  329.         }
  330.         return true;
  331.     }
  332.     //  搜索设备  /
  333.     private void searchBtDevice() {
  334.         if (ActivityCompat.checkSelfPermission(this, android.Manifest.permission.BLUETOOTH_SCAN) != PackageManager.PERMISSION_GRANTED) {
  335.             // TODO: Consider calling
  336.             //    ActivityCompat#requestPermissions
  337.             // here to request the missing permissions, and then overriding
  338.             //   public void onRequestPermissionsResult(int requestCode, String[] permissions,
  339.             //                                          int[] grantResults)
  340.             // to handle the case where the user grants the permission. See the documentation
  341.             // for ActivityCompat#requestPermissions for more details.
  342.             return;
  343.         }
  344.         if (bluetoothAdapter.isDiscovering()) { //当前正在搜索设备...
  345.             return;
  346.         }
  347.         //开始搜索
  348.         bluetoothAdapter.startDiscovery();
  349.     }
  350.  
  351.     //  配对/接触配对设备  
  352.  
  353.     /**
  354.      * 执行绑定 反射
  355.      * @param bluetoothDevice 蓝牙设备
  356.      * @return true 执行绑定 false 未执行绑定
  357.      */
  358.     public boolean boundDevice(BluetoothDevice bluetoothDevice) {
  359.         if (bluetoothDevice == null) {
  360.             Log.e(TAG, "boundDevice-->bluetoothDevice == null");
  361.             return false;
  362.         }
  363.  
  364.         try {
  365.             return ClsUtils.createBond(BluetoothDevice.class, bluetoothDevice);
  366.         } catch (Exception e) {
  367.             e.printStackTrace();
  368.         }
  369.  
  370.         return true;
  371.     }
  372.  
  373.     /**
  374.      * 执行解绑  反射
  375.      * @param bluetoothDevice 蓝牙设备
  376.      * @return true 执行解绑  false未执行解绑
  377.      */
  378.     public boolean disBoundDevice(BluetoothDevice bluetoothDevice) {
  379.         if (bluetoothDevice == null) {
  380.             Log.e(TAG, "disBoundDevice-->bluetoothDevice == null");
  381.             return false;
  382.         }
  383.  
  384.         try {
  385.             return ClsUtils.removeBond(BluetoothDevice.class, bluetoothDevice);
  386.         } catch (Exception e) {
  387.             e.printStackTrace();
  388.         }
  389.  
  390.         return true;
  391.     }
  392.  
  393.     //   连接设备   ///
  394.  
  395.     /**
  396.      * 开始连接设备
  397.      * @param bluetoothDevice   蓝牙设备
  398.      * @param uuid               发起连接的UUID
  399.      * @param conOutTime        连接超时时间
  400.      */
  401.     public void startConnectDevice(final BluetoothDevice bluetoothDevice, String uuid, long conOutTime) {
  402.         if (bluetoothDevice == null) {
  403.             Log.e(TAG, "startConnectDevice-->bluetoothDevice == null");
  404.             return;
  405.         }
  406.         if (bluetoothAdapter == null) {
  407.             Log.e(TAG, "startConnectDevice-->bluetooth3Adapter == null");
  408.             return;
  409.         }
  410.         //发起连接
  411.         connectThread = new ConnectThread(bluetoothAdapter, curBluetoothDevice, uuid);
  412.         connectThread.setOnBluetoothConnectListener(new ConnectThread.OnBluetoothConnectListener() {
  413.             @Override
  414.             public void onStartConn() {
  415.                 if (ActivityCompat.checkSelfPermission(bluet.this, android.Manifest.permission.BLUETOOTH_CONNECT) != PackageManager.PERMISSION_GRANTED) {
  416.                     // TODO: Consider calling
  417.                     //    ActivityCompat#requestPermissions
  418.                     // here to request the missing permissions, and then overriding
  419.                     //   public void onRequestPermissionsResult(int requestCode, String[] permissions,
  420.                     //                                          int[] grantResults)
  421.                     // to handle the case where the user grants the permission. See the documentation
  422.                     // for ActivityCompat#requestPermissions for more details.
  423.                     return;
  424.                 }
  425.                 Log.d(TAG, "startConnectDevice-->开始连接..." + bluetoothDevice.getName() + "-->" + bluetoothDevice.getAddress());
  426.             }
  427.  
  428.  
  429.             @Override
  430.             public void onConnSuccess(BluetoothSocket bluetoothSocket) {
  431.                 //移除连接超时
  432.                 mHandler.removeCallbacks(connectOuttimeRunnable);
  433.                 Log.d(TAG, "startConnectDevice-->移除连接超时");
  434.                 Log.w(TAG, "startConnectDevice-->连接成功");
  435.  
  436.                 Message message = new Message();
  437.                 message.what = CONNECT_SUCCESS;
  438.                 mHandler.sendMessage(message);
  439.  
  440.                 //标记当前连接状态为true
  441.                 curConnState = true;
  442.                 //管理连接，收发数据
  443.                 managerConnectSendReceiveData(bluetoothSocket);
  444.             }
  445.  
  446.             @Override
  447.             public void onConnFailure(String errorMsg) {
  448.                 Log.e(TAG, "startConnectDevice-->" + errorMsg);
  449.  
  450.                 Message message = new Message();
  451.                 message.what = CONNECT_FAILURE;
  452.                 mHandler.sendMessage(message);
  453.  
  454.                 //标记当前连接状态为false
  455.                 curConnState = false;
  456.  
  457.                 //断开管理连接
  458.                 clearConnectedThread();
  459.             }
  460.         });
  461.  
  462.         connectThread.start();
  463.         //设置连接超时时间
  464.         mHandler.postDelayed(connectOuttimeRunnable, conOutTime);
  465.  
  466.     }
  467.  
  468.     //连接超时
  469.     private Runnable connectOuttimeRunnable = new Runnable() {
  470.         @Override
  471.         public void run() {
  472.             Log.e(TAG, "startConnectDevice-->连接超时");
  473.  
  474.             Message message = new Message();
  475.             message.what = CONNECT_FAILURE;
  476.             mHandler.sendMessage(message);
  477.  
  478.             //标记当前连接状态为false
  479.             curConnState = false;
  480.             //断开管理连接
  481.             clearConnectedThread();
  482.         }
  483.     };
  484.  
  485.     // 断开连接  //
  486.  
  487.     /**
  488.      * 断开已有的连接
  489.      */
  490.     public void clearConnectedThread() {
  491.         Log.d(TAG, "clearConnectedThread-->即将断开");
  492.  
  493.         //connectedThread断开已有连接
  494.         if (connectedThread == null) {
  495.             Log.e(TAG, "clearConnectedThread-->connectedThread == null");
  496.             return;
  497.         }
  498.         connectedThread.terminalClose(connectThread);
  499.  
  500.         //等待线程运行完后再断开
  501.         mHandler.postDelayed(new Runnable() {
  502.             @Override
  503.             public void run() {
  504.                 connectedThread.cancel();  //释放连接
  505.  
  506.                 connectedThread = null;
  507.             }
  508.         }, 10);
  509.  
  510.         Log.w(TAG, "clearConnectedThread-->成功断开连接");
  511.         Message message = new Message();
  512.         message.what = DISCONNECT_SUCCESS;
  513.         mHandler.sendMessage(message);
  514.  
  515.     }
  516.  
  517.     ///
  518.  
  519.     ///  管理已有连接、收发数据  //
  520.  
  521.     /**
  522.      * 管理已建立的连接，收发数据
  523.      * @param bluetoothSocket   已建立的连接
  524.      */
  525.     public void managerConnectSendReceiveData(BluetoothSocket bluetoothSocket) {
  526.         //管理已有连接
  527.         connectedThread = new ConnectedThread(bluetoothSocket);
  528.         connectedThread.start();
  529.         connectedThread.setOnSendReceiveDataListener(new ConnectedThread.OnSendReceiveDataListener() {
  530.             @Override
  531.             public void onSendDataSuccess(byte[] data) {
  532.                 Log.w(TAG, "发送数据成功,长度" + data.length + "->" + bytes2HexString(data, data.length));
  533.                 Message message = new Message();
  534.                 message.what = SEND_SUCCESS;
  535.                 message.obj = "发送数据成功,长度" + data.length + "->" + bytes2HexString(data, data.length);
  536.                 mHandler.sendMessage(message);
  537.             }
  538.  
  539.             @Override
  540.             public void onSendDataError(byte[] data, String errorMsg) {
  541.                 Log.e(TAG, "发送数据出错,长度" + data.length + "->" + bytes2HexString(data, data.length));
  542.                 Message message = new Message();
  543.                 message.what = SEND_FAILURE;
  544.                 message.obj = "发送数据出错,长度" + data.length + "->" + bytes2HexString(data, data.length);
  545.                 mHandler.sendMessage(message);
  546.             }
  547.  
  548.             @Override
  549.             public void onReceiveDataSuccess(byte[] buffer) {
  550.                 Log.w(TAG, "成功接收数据,长度" + buffer.length + "->" + bytes2HexString(buffer, buffer.length));
  551.                 Message message = new Message();
  552.                 message.what = RECEIVE_SUCCESS;
  553.                 message.obj = "成功接收数据,长度" + buffer.length + "->" + bytes2HexString(buffer, buffer.length);
  554.                 mHandler.sendMessage(message);
  555.             }
  556.  
  557.             @Override
  558.             public void onReceiveDataError(String errorMsg) {
  559.                 Log.e(TAG, "接收数据出错：" + errorMsg);
  560.                 Message message = new Message();
  561.                 message.what = RECEIVE_FAILURE;
  562.                 message.obj = "接收数据出错：" + errorMsg;
  563.                 mHandler.sendMessage(message);
  564.             }
  565.         });
  566.     }
  567.  
  568.     /   发送数据  /
  569.  
  570.     /**
  571.      * 发送数据
  572.      * @param data      要发送的数据 字符串
  573.      * @param isHex     是否是16进制字符串
  574.      * @return true 发送成功  false 发送失败
  575.      */
  576.     public boolean sendData(String data, boolean isHex) {
  577.         if (connectedThread == null) {
  578.             Log.e(TAG, "sendData:string -->connectedThread == null");
  579.             return false;
  580.         }
  581.         if (data == null || data.length() == 0) {
  582.             Log.e(TAG, "sendData:string-->要发送的数据为空");
  583.             return false;
  584.         }
  585.  
  586.         if (isHex) {  //是16进制字符串
  587.             data.replace(" ", "");  //取消空格
  588.             //检查16进制数据是否合法
  589.             if (data.length() % 2 != 0) {
  590.                 //不合法，最后一位自动填充0
  591.                 String lasts = "0" + data.charAt(data.length() - 1);
  592.                 data = data.substring(0, data.length() - 2) + lasts;
  593.             }
  594.             Log.d(TAG, "sendData:string -->准备写入：" + data);  //加空格显示
  595.             return connectedThread.write(hexString2Bytes(data));
  596.         }
  597.  
  598.         //普通字符串
  599.         Log.d(TAG, "sendData:string -->准备写入：" + data);
  600.         return connectedThread.write(data.getBytes());
  601.     }
  602.  
  603.     //
  604.  
  605.     ///   数据类型转换  //
  606.  
  607.     /**
  608.      * 字节数组-->16进制字符串
  609.      * @param b   字节数组
  610.      * @param length  字节数组长度
  611.      * @return 16进制字符串 有空格类似“0A D5 CD 8F BD E5 F8”
  612.      */
  613.     public static String bytes2HexString(byte[] b, int length) {
  614.         StringBuffer result = new StringBuffer();
  615.         String hex;
  616.         for (int i = 0; i < length; i++) {
  617.             hex = Integer.toHexString(b[i] & 0xFF);
  618.             if (hex.length() == 1) {
  619.                 hex = '0' + hex;
  620.             }
  621.             result.append(hex.toUpperCase()).append(" ");
  622.         }
  623.         return result.toString();
  624.     }
  625.  
  626.     /**
  627.      * hexString2Bytes
  628.      * 16进制字符串-->字节数组
  629.      * @param src  16进制字符串
  630.      * @return 字节数组
  631.      */
  632.     public static byte[] hexString2Bytes(String src) {
  633.         int l = src.length() / 2;
  634.         byte[] ret = new byte[l];
  635.         for (int i = 0; i < l; i++) {
  636.             ret[i] = (byte) Integer
  637.                     .valueOf(src.substring(i * 2, i * 2 + 2), 16).byteValue();
  638.         }
  639.         return ret;
  640.     }
  641.  
  642.     ///
  643.  
  644.     /**
  645.      * 初始化蓝牙
  646.      */
  647.     private void initBluetooth() {
  648.         bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
  649.         if (bluetoothAdapter == null) {
  650.             Toast.makeText(this, "当前手机设备不支持蓝牙", Toast.LENGTH_SHORT).show();
  651.         } else {
  652.             //手机设备支持蓝牙，判断蓝牙是否已开启
  653.             if (bluetoothAdapter.isEnabled()) {
  654.                 Toast.makeText(this, "手机蓝牙已开启", Toast.LENGTH_SHORT).show();
  655.             } else {
  656.                 //蓝牙没有打开，去打开蓝牙。推荐使用第二种打开蓝牙方式
  657.                 //第一种方式：直接打开手机蓝牙，没有任何提示
  658. //                bluetoothAdapter.enable();  //BLUETOOTH_ADMIN权限
  659.                 //第二种方式：友好提示用户打开蓝牙
  660.                 Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
  661.                 if (ActivityCompat.checkSelfPermission(this, android.Manifest.permission.BLUETOOTH_CONNECT) != PackageManager.PERMISSION_GRANTED) {
  662.                     // TODO: Consider calling
  663.                     //    ActivityCompat#requestPermissions
  664.                     // here to request the missing permissions, and then overriding
  665.                     //   public void onRequestPermissionsResult(int requestCode, String[] permissions,
  666.                     //                                          int[] grantResults)
  667.                     // to handle the case where the user grants the permission. See the documentation
  668.                     // for ActivityCompat#requestPermissions for more details.
  669.                     return;
  670.                 }
  671.                 startActivity(enableBtIntent);
  672.             }
  673.         }
  674.     }
  675.  
  676.     /**
  677.      * 初始化蓝牙广播
  678.      */
  679.     private void initBtBroadcast() {
  680.         //注册广播接收
  681.         btBroadcastReceiver = new BtBroadcastReceiver();
  682.         IntentFilter intentFilter = new IntentFilter();
  683.         intentFilter.addAction(BluetoothAdapter.ACTION_DISCOVERY_STARTED); //开始扫描
  684.         intentFilter.addAction(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);//扫描结束
  685.         intentFilter.addAction(BluetoothDevice.ACTION_FOUND);//搜索到设备
  686.         intentFilter.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED); //配对状态监听
  687.         registerReceiver(btBroadcastReceiver, intentFilter);
  688.  
  689.     }
  690.  
  691.     @Override
  692.     protected void onDestroy() {
  693.         super.onDestroy();
  694.  
  695.         //注销广播接收
  696.         unregisterReceiver(btBroadcastReceiver);
  697.     }
  698.  
  699.     /**
  700.      * 蓝牙广播接收器
  701.      */
  702.     private class BtBroadcastReceiver extends BroadcastReceiver {
  703.  
  704.         @Override
  705.         public void onReceive(Context context, Intent intent) {
  706.             String action = intent.getAction();
  707.             if (TextUtils.equals(action, BluetoothAdapter.ACTION_DISCOVERY_STARTED)) { //开启搜索
  708.                 Log.d(TAG, "开启搜索...");
  709.                 Message message = new Message();
  710.                 message.what = START_DISCOVERY;
  711.                 mHandler.sendMessage(message);
  712.  
  713.             } else if (TextUtils.equals(action, BluetoothAdapter.ACTION_DISCOVERY_FINISHED)) {//完成搜素
  714.                 Log.d(TAG, "停止搜索...");
  715.                 Message message = new Message();
  716.                 message.what = STOP_DISCOVERY;
  717.                 mHandler.sendMessage(message);
  718.  
  719.             } else if (TextUtils.equals(action, BluetoothDevice.ACTION_FOUND)) {  //3.0搜索到设备
  720.                 //蓝牙设备
  721.                 BluetoothDevice bluetoothDevice = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
  722.                 //信号强度
  723.                 int rssi = intent.getShortExtra(BluetoothDevice.EXTRA_RSSI, Short.MIN_VALUE);
  724.  
  725.                 if (ActivityCompat.checkSelfPermission(bluet.this, android.Manifest.permission.BLUETOOTH_CONNECT) != PackageManager.PERMISSION_GRANTED) {
  726.                     // TODO: Consider calling
  727.                     //    ActivityCompat#requestPermissions
  728.                     // here to request the missing permissions, and then overriding
  729.                     //   public void onRequestPermissionsResult(int requestCode, String[] permissions,
  730.                     //                                          int[] grantResults)
  731.                     // to handle the case where the user grants the permission. See the documentation
  732.                     // for ActivityCompat#requestPermissions for more details.
  733.                     return;
  734.                 }
  735.                 Log.w(TAG, "扫描到设备：" + bluetoothDevice.getName() + "-->" + bluetoothDevice.getAddress());
  736.                 Message message = new Message();
  737.                 message.what = DISCOVERY_DEVICE;
  738.                 message.obj = bluetoothDevice;
  739.                 mHandler.sendMessage(message);
  740.  
  741.             } else if (TextUtils.equals(action, BluetoothDevice.ACTION_BOND_STATE_CHANGED)) {
  742.                 BluetoothDevice bluetoothDevice = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
  743.                 if (ActivityCompat.checkSelfPermission(bluet.this, android.Manifest.permission.BLUETOOTH_CONNECT) != PackageManager.PERMISSION_GRANTED) {
  744.                     // TODO: Consider calling
  745.                     //    ActivityCompat#requestPermissions
  746.                     // here to request the missing permissions, and then overriding
  747.                     //   public void onRequestPermissionsResult(int requestCode, String[] permissions,
  748.                     //                                          int[] grantResults)
  749.                     // to handle the case where the user grants the permission. See the documentation
  750.                     // for ActivityCompat#requestPermissions for more details.
  751.                     return;
  752.                 }
  753.                 int bondSate = bluetoothDevice.getBondState();
  754.                 switch(bondSate) {
  755.                     case BluetoothDevice.BOND_NONE:
  756.                         Log.d(TAG, "已解除配对");
  757.                         Message message1 = new Message();
  758.                         message1.what = DEVICE_BOND_NONE;
  759.                         mHandler.sendMessage(message1);
  760.                         break;
  761.  
  762.                     case BluetoothDevice.BOND_BONDING:
  763.                         Log.d(TAG, "正在配对...");
  764.                         Message message2 = new Message();
  765.                         message2.what = DEVICE_BONDING;
  766.                         mHandler.sendMessage(message2);
  767.                         break;
  768.  
  769.                     case BluetoothDevice.BOND_BONDED:
  770.                         Log.d(TAG, "已配对");
  771.                         Message message3 = new Message();
  772.                         message3.what = DEVICE_BONDED;
  773.                         mHandler.sendMessage(message3);
  774.                         break;
  775.                 }
  776.             }
  777.         }
  778.     }
  779. }

类

ConnectedThread.java

ConnectThread.java

ClsUtils.java

太长了，自己去原文下载项目复制粘贴吧，这几个类没什么要修改的，把标红的地方按系统提示给改了就好了。注意复制项目的时候把values文件夹下面的东西也复制一下

并且这个绿色的东西AndroidManifest.xml里面也要声明activity，不然运行不了。

界面

bluetooth.xml

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  3.     xmlns:app="http://schemas.android.com/apk/res-auto"
  4.     xmlns:tools="http://schemas.android.com/tools"
  5.     android:layout_width="match_parent"
  6.     android:layout_height="match_parent"
  7.     android:orientation="vertical"
  8.     tools:context=".MainActivity"
  9.     android:padding="10dp"
  10.     android:focusableInTouchMode="true">
  11.  
  12.     <RelativeLayout
  13.         android:layout_width="match_parent"
  14.         android:layout_height="wrap_content">
  15.  
  16.         <LinearLayout
  17.             android:id="@+id/ll_search"
  18.             android:layout_width="wrap_content"
  19.             android:layout_height="wrap_content"
  20.             android:orientation="vertical">
  21.  
  22.             <Button
  23.                 android:id="@+id/bt_search"
  24.                 android:layout_width="wrap_content"
  25.                 android:layout_height="48dp"
  26.                 android:background="@drawable/bt_bg"
  27.                 android:text="搜索"
  28.                 android:textColor="#FFFFFF"
  29.                 android:textSize="14sp" />
  30.  
  31.             <TextView
  32.                 android:id="@+id/tv_cur_con_state"
  33.                 android:layout_marginTop="10dp"
  34.                 android:layout_width="match_parent"
  35.                 android:layout_height="wrap_content"
  36.                 android:textSize="14sp"
  37.                 android:textColor="@color/colorPrimary"/>
  38.  
  39.             <TextView
  40.                 android:id="@+id/tv_cur_bond_state"
  41.                 android:layout_marginTop="10dp"
  42.                 android:layout_width="match_parent"
  43.                 android:layout_height="wrap_content"
  44.                 android:textSize="14sp"
  45.                 android:textColor="@color/colorPrimary"/>
  46.  
  47.         </LinearLayout>
  48.  
  49.         <LinearLayout
  50.             android:layout_toRightOf="@+id/ll_search"
  51.             android:layout_marginLeft="10dp"
  52.             android:layout_width="match_parent"
  53.             android:layout_height="wrap_content"
  54.             android:orientation="vertical">
  55.  
  56.             <TextView
  57.                 android:id="@+id/tv_name"
  58.                 android:layout_width="match_parent"
  59.                 android:layout_height="wrap_content"
  60.                 android:textSize="14sp"
  61.                 android:hint="设备名"
  62.                 android:textColor="@color/colorPrimary"
  63.                 android:paddingTop="5dp"
  64.                 android:paddingBottom="5dp"
  65.                 android:paddingLeft="10dp"
  66.                 android:background="@drawable/tv_bg"/>
  67.  
  68.             <TextView
  69.                 android:id="@+id/tv_address"
  70.                 android:layout_marginTop="10dp"
  71.                 android:layout_width="match_parent"
  72.                 android:layout_height="wrap_content"
  73.                 android:textSize="14sp"
  74.                 android:hint="设备地址"
  75.                 android:textColor="@color/colorPrimary"
  76.                 android:paddingTop="5dp"
  77.                 android:paddingBottom="5dp"
  78.                 android:paddingLeft="10dp"
  79.                 android:background="@drawable/tv_bg"/>
  80.  
  81.             <LinearLayout
  82.                 android:layout_marginTop="10dp"
  83.                 android:layout_width="match_parent"
  84.                 android:layout_height="wrap_content"
  85.                 android:orientation="horizontal">
  86.  
  87.                 <Button
  88.                     android:id="@+id/bt_connect"
  89.                     android:layout_width="wrap_content"
  90.                     android:layout_height="40dp"
  91.                     android:background="@drawable/bt_bg"
  92.                     android:text="连接"
  93.                     android:textColor="#FFFFFF"
  94.                     android:textSize="14sp"
  95.                     tools:ignore="TouchTargetSizeCheck" />
  96.  
  97.                 <Button
  98.                     android:id="@+id/bt_disconnect"
  99.                     android:layout_width="wrap_content"
  100.                     android:layout_height="40dp"
  101.                     android:layout_marginLeft="10dp"
  102.                     android:background="@drawable/bt_bg"
  103.                     android:text="断开"
  104.                     android:textColor="#FFFFFF"
  105.                     android:textSize="14sp"
  106.                     tools:ignore="TouchTargetSizeCheck" />
  107.  
  108.             </LinearLayout>
  109.  
  110.             <LinearLayout
  111.                 android:layout_marginTop="10dp"
  112.                 android:layout_width="match_parent"
  113.                 android:layout_height="wrap_content"
  114.                 android:orientation="horizontal">
  115.  
  116.                 <Button
  117.                     android:id="@+id/bt_bound"
  118.                     android:layout_width="wrap_content"
  119.                     android:layout_height="40dp"
  120.                     android:background="@drawable/bt_bg"
  121.                     android:text="配对"
  122.                     android:textColor="#FFFFFF"
  123.                     android:textSize="14sp"
  124.                     tools:ignore="TouchTargetSizeCheck" />
  125.  
  126.                 <Button
  127.                     android:id="@+id/bt_disBound"
  128.                     android:layout_width="wrap_content"
  129.                     android:layout_height="40dp"
  130.                     android:layout_marginLeft="10dp"
  131.                     android:background="@drawable/bt_bg"
  132.                     android:text="解除配对"
  133.                     android:textColor="#FFFFFF"
  134.                     android:textSize="14sp"
  135.                     tools:ignore="TouchTargetSizeCheck" />
  136.  
  137.             </LinearLayout>
  138.  
  139.         </LinearLayout>
  140.  
  141.     </RelativeLayout>
  142.  
  143.     <!--搜索设备列表-->
  144.     <LinearLayout
  145.         android:id="@+id/ll_device_list"
  146.         android:layout_width="match_parent"
  147.         android:layout_height="match_parent"
  148.         android:padding="5dp"
  149.         android:visibility="visible">
  150.  
  151.         <ListView
  152.             android:id="@+id/lv_devices"
  153.             android:layout_width="match_parent"
  154.             android:layout_height="match_parent">
  155.  
  156.         </ListView>
  157.  
  158.     </LinearLayout>
  159.  
  160.     <!--数据收发-->
  161.     <LinearLayout
  162.         android:id="@+id/ll_data_send_receive"
  163.         android:visibility="gone"
  164.         android:layout_width="match_parent"
  165.         android:layout_height="match_parent"
  166.         android:orientation="vertical">
  167.  
  168.         <TextView
  169.             android:layout_marginTop="10dp"
  170.             android:layout_width="match_parent"
  171.             android:layout_height="wrap_content"
  172.             android:textSize="14sp"
  173.             android:text="设置要发送的数据(十六进制字符串形式)"
  174.             android:textColor="@color/colorPrimary"/>
  175.  
  176.         <EditText
  177.             android:id="@+id/et_send_msg"
  178.             android:layout_marginTop="10dp"
  179.             android:layout_width="match_parent"
  180.             android:layout_height="wrap_content"
  181.             android:textSize="14sp"
  182.             android:textColor="#333333"
  183.             android:padding="10dp"
  184.             android:hint="在此输入要发送的数据"
  185.             android:background="@drawable/tv_bg"/>
  186.  
  187.         <Button
  188.             android:id="@+id/bt_to_send"
  189.             android:layout_marginLeft="10dp"
  190.             android:layout_marginTop="10dp"
  191.             android:layout_width="wrap_content"
  192.             android:layout_height="40dp"
  193.             android:text="发送"
  194.             android:textColor="#FFFFFF"
  195.             android:textSize="14sp"
  196.             android:background="@drawable/bt_bg"/>
  197.  
  198.         <TextView
  199.             android:layout_marginTop="10dp"
  200.             android:layout_width="match_parent"
  201.             android:layout_height="wrap_content"
  202.             android:textSize="14sp"
  203.             android:text="显示接收的数据操作结果(发送成功/发送失败)"
  204.             android:textColor="@color/colorPrimary"/>
  205.  
  206.         <ScrollView
  207.             android:layout_marginTop="10dp"
  208.             android:layout_width="match_parent"
  209.             android:layout_height="100dp"
  210.             android:background="@drawable/tv_bg">
  211.  
  212.             <TextView
  213.                 android:id="@+id/tv_send_result"
  214.                 android:layout_width="match_parent"
  215.                 android:layout_height="match_parent"
  216.                 android:padding="10dp"
  217.                 android:textSize="14sp"
  218.                 android:hint="此处显示发送数据操作结果"
  219.                 android:textColor="@color/colorPrimary"/>
  220.         </ScrollView>
  221.  
  222.         <TextView
  223.             android:layout_marginTop="10dp"
  224.             android:layout_width="match_parent"
  225.             android:layout_height="wrap_content"
  226.             android:textSize="14sp"
  227.             android:text="显示接收的数据(以十六进制字符串显示)"
  228.             android:textColor="@color/colorPrimary"/>
  229.  
  230.         <ScrollView
  231.             android:layout_marginTop="10dp"
  232.             android:layout_width="match_parent"
  233.             android:layout_height="100dp"
  234.             android:background="@drawable/tv_bg">
  235.  
  236.             <TextView
  237.                 android:id="@+id/tv_receive_result"
  238.                 android:layout_width="match_parent"
  239.                 android:layout_height="match_parent"
  240.                 android:padding="10dp"
  241.                 android:textSize="14sp"
  242.                 android:hint="此处显示发送数据操作结果"
  243.                 android:textColor="@color/colorPrimary"/>
  244.         </ScrollView>
  245.  
  246.     </LinearLayout>
  247.  
  248. </LinearLayout>

device_list.xml

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <LinearLayout
  3.     xmlns:android="http://schemas.android.com/apk/res/android"
  4.     android:layout_width="match_parent"
  5.     android:layout_height="wrap_content"
  6.     android:orientation="vertical">
  7.  
  8.     <TextView
  9.         android:id="@+id/tv_device_name"
  10.         android:layout_width="wrap_content"
  11.         android:layout_height="wrap_content"
  12.         android:padding="5dp"
  13.         android:textColor="@color/colorPrimary"
  14.         android:textSize="16sp"/>
  15.  
  16.     <TextView
  17.         android:id="@+id/tv_device_address"
  18.         android:layout_width="wrap_content"
  19.         android:layout_height="wrap_content"
  20.         android:padding="5dp"
  21.         android:textColor="@color/colorPrimary"
  22.         android:textSize="16sp"/>
  23.  
  24. </LinearLayout>

权限声明

AndroidManifest.xml

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"
  3.     xmlns:tools="http://schemas.android.com/tools">
  4.     <uses-permission android:name="android.permission.BLUETOOTH_ADVERTISE" />
  5.     <uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
  6.     <uses-permission android:name="android.permission.BLUETOOTH_SCAN" />
  7.     <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
  8.     <uses-permission android:name="android.permission.BLUETOOTH" />
  9.     <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" /> <!-- ACCESS_FINE_LOCATION：允许一个程序访问精确位置(如GPS） -->
  10.     <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" /><!-- ACCESS_COARSE_LOCATION：允许一个程序访问CellID或WiFi热点来获取大致的位置 -->
  11.     <application
  12.         android:allowBackup="true"
  13.         android:dataExtractionRules="@xml/data_extraction_rules"
  14.         android:fullBackupContent="@xml/backup_rules"
  15.         android:icon="@mipmap/ic_launcher"
  16.         android:label="@string/app_name"
  17.         android:roundIcon="@mipmap/ic_launcher_round"
  18.         android:supportsRtl="true"
  19.         android:theme="@style/Theme.Bluetooth"
  20.         tools:targetApi="31">
  21.         <activity
  22.             android:name=".bluet"
  23.             android:exported="true"
  24.             android:label="@string/app_name"
  25.             android:theme="@style/AppTheme">
  26.             <intent-filter>
  27.                 <action android:name="android.intent.action.MAIN" />
  28.  
  29.                 <category android:name="android.intent.category.LAUNCHER" />
  30.             </intent-filter>
  31.         </activity>
  32.     </application>
  33.  
  34. </manifest>

新的安卓开发软件在用蓝牙时不仅要声明蓝牙权限，还要声明位置权限。

 运行效果 

搜索后点击配对

配对成功

解除配对成功

连接成功

发送数据成功

说明：先点击配对，首次配对是会弹窗的；再点击连接出现发送数据页面，输入一串数字，显示发送成功，但是接收数据失败，这是出现的问题，我无法解决。并且我尝试了多台设备，只有这个手机设备能够连接成功，还有一个设备是我的耳机，不知道怎么解释这个问题，可能协议不一样？不明白，我还有很多需要学习的地方，这次只是学习别人的代码，演示视频可以看b站，我还有一个专栏介绍了一下如何在拿到别人的项目文件时把项目文件的代码复制到自己的项目中，期间出现了很多问题，最后解决了。记得给手机开权限！还有声明权限！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/运维做开发/article/detail/956154
推荐阅读
相关标签

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

  

闽ICP备14008679号