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

Android 蓝牙设备通讯的开发(配对/连接/传输数据)_android 获取蓝牙列表,连接蓝牙,发送数据

作者：小蓝xlanll | 2024-05-30 12:07:22

赞

踩

android 获取蓝牙列表,连接蓝牙,发送数据

最近公司想做一个关于蓝牙的项目,同时我也学习到了很多关于蓝牙方面的很多知识点,希望在这里跟大家分享下,不足之处有望指明.

项目源码:http://download.csdn.net/detail/qq_30552993/9529815

这里先附上项目图片,不过这里ListView中如果是已配对的就进行连接,如果是未配对的就进行配对,配对完成之后这里的话要重新搜索设备,这里没做刷新.还有就是可以在两只手机上都装上这个,再连接上就可以进行发送到另一只手机上去,不知道为什么有时候好像蓝牙有些不知是否不太稳定,出现搜索蓝牙有些没搜到.

在很多方面，蓝牙是一种能够发送或接受两个不同的设备之间传输的数据。 Android平台包含了蓝牙框架，使设备以无线方式与其他蓝牙设备进行数据交换的支持。

Android提供蓝牙API来执行这些不同的操作。

  1. 扫描其他蓝牙设备
  2. 获取配对设备列表
  3. 连接到通过服务发现其他设备
  • Android提供BluetoothAdapter类蓝牙通信。通过调用创建的对象的静态方法getDefaultAdapter()。其语法如下给出。
  1. private BluetoothAdapter BA;
  2. BA = BluetoothAdapter.getDefaultAdapter();
  • 这里我把一些关于蓝牙的打开/关闭/配对/连接/数据传输的线程都封装BlueToothUtils这个蓝牙工具类中
  1. import android.bluetooth.BluetoothAdapter;
  2. import android.bluetooth.BluetoothDevice;
  3. import android.bluetooth.BluetoothServerSocket;
  4. import android.bluetooth.BluetoothSocket;
  5. import android.content.Context;
  6. import android.os.Handler;
  7. import android.os.Message;
  8. import android.util.Log;
  9. import android.widget.Toast;
  10.  
  11. import java.io.IOException;
  12. import java.io.InputStream;
  13. import java.io.OutputStream;
  14. import java.lang.reflect.Field;
  15. import java.lang.reflect.InvocationTargetException;
  16. import java.lang.reflect.Method;
  17. import java.util.ArrayList;
  18. import java.util.List;
  19. import java.util.Set;
  20. import java.util.UUID;
  21.  
  22. /**
  23.  * Created by shaolin on 5/23/16.
  24.  */
  25. public class BlueToothUtils {
  26.     private static final String TAG = "BlueToothUtils";
  27.     private Context mContext;
  28.     public static BlueToothUtils sInstance;
  29.     private BluetoothAdapter mBA;
  30.     // UUID.randomUUID()随机获取UUID
  31.     private final UUID MY_UUID = UUID
  32.             .fromString("db764ac8-4b08-7f25-aafe-59d03c27bae3");
  33.     // 连接对象的名称
  34.     private final String NAME = "LGL";
  35.  
  36.     // 这里本身即是服务端也是客户端，需要如下类
  37.     private BluetoothSocket mSocket;
  38.     private BluetoothDevice mOldDevice;
  39.     private BluetoothDevice mCurDevice;
  40.     // 输出流_客户端需要往服务端输出
  41.     private OutputStream os;
  42.  
  43.     //线程类的实例
  44.     private AcceptThread ac;
  45.  
  46.     public static synchronized BlueToothUtils getInstance() {
  47.         if (sInstance == null) {
  48.             sInstance = new BlueToothUtils();
  49.         }
  50.         return sInstance;
  51.     }
  52.  
  53.     public BlueToothUtils() {
  54.         mBA = BluetoothAdapter.getDefaultAdapter();
  55.         ac = new AcceptThread();
  56.     }
  57.  
  58.     public void setContext(Context context) {
  59.         this.mContext = context;
  60.     }
  61.  
  62.     public BluetoothAdapter getBA() {
  63.         return mBA;
  64.     }
  65.  
  66.     public AcceptThread getAc() {
  67.         return ac;
  68.     }
  69.  
  70.     public BluetoothDevice getCurDevice() {
  71.         return mCurDevice;
  72.     }
  73.  
  74.     /**
  75.      * 判断是否打开蓝牙
  76.      *
  77.      * @return
  78.      */
  79.     public boolean isEnabled() {
  80.         if (mBA.isEnabled()) {
  81.             return true;
  82.         }
  83.         return false;
  84.     }
  85.  
  86.     /**
  87.      * 搜索设备
  88.      */
  89.     public void searchDevices() {
  90.         // 判断是否在搜索,如果在搜索，就取消搜索
  91.         if (mBA.isDiscovering()) {
  92.             mBA.cancelDiscovery();
  93.         }
  94.         // 开始搜索
  95.         mBA.startDiscovery();
  96.         Log.e(TAG, "正在搜索...");
  97.     }
  98.  
  99.     /**
  100.      * 获取已经配对的设备
  101.      *
  102.      * @return
  103.      */
  104.     public List<BluetoothDevice> getBondedDevices() {
  105.         List<BluetoothDevice> devices = new ArrayList<>();
  106.         Set<BluetoothDevice> pairedDevices = mBA.getBondedDevices();
  107.         // 判断是否有配对过的设备
  108.         if (pairedDevices.size() > 0) {
  109.             for (BluetoothDevice device : pairedDevices) {
  110.                 devices.add(device);
  111.                 Log.e(TAG, "BondedDevice:" + device.getName());
  112.             }
  113.         }
  114.         return devices;
  115.     }
  116.  
  117.     /**
  118.      * 与设备配对
  119.      *
  120.      * @param device
  121.      */
  122.     public void createBond(BluetoothDevice device) {
  123.         try {
  124.             Method createBondMethod = BluetoothDevice.class.getMethod("createBond");
  125.             createBondMethod.invoke(device);
  126.         } catch (Exception e) {
  127.             e.printStackTrace();
  128.         }
  129.     }
  130.  
  131.     /**
  132.      * 与设备解除配对
  133.      *
  134.      * @param device
  135.      */
  136.     public void removeBond(BluetoothDevice device) {
  137.         try {
  138.             Method removeBondMethod = device.getClass().getMethod("removeBond");
  139.             removeBondMethod.invoke(device);
  140.         } catch (Exception e) {
  141.             e.printStackTrace();
  142.         }
  143.     }
  144.  
  145.     /**
  146.      *
  147.      * @param device
  148.      * @param str  设置PIN码
  149.      * @return
  150.      */
  151.     public boolean setPin(BluetoothDevice device, String str) {
  152.         try {
  153.             Method removeBondMethod = device.getClass().getDeclaredMethod("setPin",
  154.                     new Class[]{byte[].class});
  155.             Boolean returnValue = (Boolean) removeBondMethod.invoke(device,
  156.                     new Object[]{str.getBytes()});
  157.             Log.e("returnValue", "" + returnValue);
  158.         } catch (SecurityException e) {
  159.             e.printStackTrace();
  160.         } catch (IllegalArgumentException e) {
  161.             e.printStackTrace();
  162.         } catch (Exception e) {
  163.             e.printStackTrace();
  164.         }
  165.         return true;
  166.     }
  167.  
  168.     /**
  169.      * 取消用户输入
  170.      */
  171.     public boolean cancelPairingUserInput(BluetoothDevice device) {
  172.         Boolean returnValue = false;
  173.         try {
  174.             Method createBondMethod = device.getClass().getMethod("cancelPairingUserInput");
  175.             returnValue = (Boolean) createBondMethod.invoke(device);
  176.         } catch (NoSuchMethodException e) {
  177.             e.printStackTrace();
  178.         } catch (InvocationTargetException e) {
  179.             e.printStackTrace();
  180.         } catch (IllegalAccessException e) {
  181.             e.printStackTrace();
  182.         }
  183.         // cancelBondProcess()
  184.         return returnValue.booleanValue();
  185.     }
  186.  
  187.     /**
  188.      * 取消配对
  189.      */
  190.     public boolean cancelBondProcess(BluetoothDevice device) {
  191.         Boolean returnValue = null;
  192.         try {
  193.             Method createBondMethod = device.getClass().getMethod("cancelBondProcess");
  194.             returnValue = (Boolean) createBondMethod.invoke(device);
  195.         } catch (IllegalAccessException e) {
  196.             e.printStackTrace();
  197.         } catch (InvocationTargetException e) {
  198.             e.printStackTrace();
  199.         } catch (NoSuchMethodException e) {
  200.             e.printStackTrace();
  201.         }
  202.         return returnValue.booleanValue();
  203.     }
  204.  
  205.     /**
  206.      * @param strAddr
  207.      * @param strPsw
  208.      * @return
  209.      */
  210.     public boolean pair(String strAddr, String strPsw) {
  211.         boolean result = false;
  212.         mBA.cancelDiscovery();
  213.  
  214.         if (!mBA.isEnabled()) {
  215.             mBA.enable();
  216.         }
  217.  
  218.         if (!BluetoothAdapter.checkBluetoothAddress(strAddr)) { // 检查蓝牙地址是否有效
  219.             Log.d("mylog", "devAdd un effient!");
  220.         }
  221.  
  222.         BluetoothDevice device = mBA.getRemoteDevice(strAddr);
  223.         if (device.getBondState() != BluetoothDevice.BOND_BONDED) {
  224.             Log.d("mylog", "NOT BOND_BONDED");
  225.             try {
  226.                 setPin(device, strPsw); // 手机和蓝牙采集器配对
  227.                 createBond(device);
  228.                 result = true;
  229.             } catch (Exception e) {
  230.                 Log.d("mylog", "setPiN failed!");
  231.                 e.printStackTrace();
  232.             } //
  233.  
  234.         } else {
  235.             Log.d("mylog", "HAS BOND_BONDED");
  236.             try {
  237.                 createBond(device);
  238.                 setPin(device, strPsw); // 手机和蓝牙采集器配对
  239.                 createBond(device);
  240.                 result = true;
  241.             } catch (Exception e) {
  242.                 Log.d("mylog", "setPiN failed!");
  243.                 e.printStackTrace();
  244.             }
  245.         }
  246.         return result;
  247.     }
  248.  
  249.     /**
  250.      * 获取device.getClass()这个类中的所有Method
  251.      *
  252.      * @param clsShow
  253.      */
  254.     public void printAllInform(Class clsShow) {
  255.         try {
  256.             // 取得所有方法
  257.             Method[] hideMethod = clsShow.getMethods();
  258.             int i = 0;
  259.             for (; i < hideMethod.length; i++) {
  260.                 Log.e("method name", hideMethod[i].getName() + ";and the i is:" + i);
  261.             }
  262.             // 取得所有常量
  263.             Field[] allFields = clsShow.getFields();
  264.             for (i = 0; i < allFields.length; i++) {
  265.                 Log.e("Field name", allFields[i].getName());
  266.             }
  267.         } catch (SecurityException e) {
  268.             e.printStackTrace();
  269.         } catch (IllegalArgumentException e) {
  270.             e.printStackTrace();
  271.         } catch (Exception e) {
  272.             e.printStackTrace();
  273.         }
  274.     }
  275.  
  276.     /**
  277.      * 打开蓝牙
  278.      */
  279.     public void openBlueTooth() {
  280.         if (!mBA.isEnabled()) {
  281.             // 弹出对话框提示用户是后打开
  282.             /*Intent intent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
  283.             startActivityForResult(intent, 1);*/
  284.             // 不做提示，强行打开
  285.             mBA.enable();
  286.             showToast("打开蓝牙");
  287.         } else {
  288.             showToast("蓝牙已打开");
  289.         }
  290.     }
  291.  
  292.     /**
  293.      * 关闭蓝牙
  294.      */
  295.     public void closeBlueTooth() {
  296.         mBA.disable();
  297.         showToast("关闭蓝牙");
  298.     }
  299.  
  300.     /**
  301.      * 弹出Toast窗口
  302.      *
  303.      * @param message
  304.      */
  305.     private void showToast(String message) {
  306.         if (mContext != null) {
  307.             Toast.makeText(mContext, message, Toast.LENGTH_LONG).show();
  308.         } else {
  309.             Log.e(TAG, "message:" + message);
  310.         }
  311.     }
  312.  
  313.     /**
  314.      * 主动连接蓝牙
  315.      *
  316.      * @param device
  317.      */
  318.     public void connectDevice(BluetoothDevice device) {
  319.         // 判断是否在搜索,如果在搜索，就取消搜索
  320.         if (mBA.isDiscovering()) {
  321.             mBA.cancelDiscovery();
  322.         }
  323.         try {
  324.             // 获得远程设备
  325.             if (mCurDevice == null || mCurDevice != mOldDevice) {
  326.                 mCurDevice = mBA.getRemoteDevice(device.getAddress());
  327.                 mOldDevice = mCurDevice;
  328.                 Log.e(TAG, "device:" + mCurDevice);
  329.                 mSocket = mCurDevice.createRfcommSocketToServiceRecord(MY_UUID);
  330.                 // 连接
  331.                 mSocket.connect();
  332.                 // 获得输出流
  333.                 os = mSocket.getOutputStream();
  334.             }
  335.             // 如果成功获得输出流
  336.  
  337.         } catch (IOException e) {
  338.             e.printStackTrace();
  339.         }
  340.     }
  341.  
  342.     /**
  343.      * 传输数据
  344.      *
  345.      * @param message
  346.      */
  347.     public void write(String message) {
  348.         try {
  349.             if (os != null) {
  350.                 os.write(message.getBytes("GBK"));
  351.             }
  352.             Log.e(TAG, "write:" + message);
  353.         } catch (IOException e) {
  354.             e.printStackTrace();
  355.         }
  356.  
  357.     }
  358.  
  359.     // 服务端，需要监听客户端的线程类
  360.     private Handler handler = new Handler() {
  361.         public void handleMessage(Message msg) {
  362.             showToast(String.valueOf(msg.obj));
  363.             Log.e(TAG, "服务端:" + msg.obj);
  364.             super.handleMessage(msg);
  365.         }
  366.     };
  367.  
  368.  
  369.     // 线程服务类
  370.     public class AcceptThread extends Thread {
  371.         private BluetoothServerSocket serverSocket;
  372.         private BluetoothSocket socket;
  373.         // 输入 输出流
  374.         private OutputStream os;
  375.         private InputStream is;
  376.  
  377.         public AcceptThread() {
  378.             try {
  379.                 serverSocket = mBA.listenUsingRfcommWithServiceRecord(NAME, MY_UUID);
  380.             } catch (IOException e) {
  381.                 e.printStackTrace();
  382.             }
  383.         }
  384.  
  385.         @Override
  386.         public void run() {
  387.             // 截获客户端的蓝牙消息
  388.             try {
  389.                 socket = serverSocket.accept(); // 如果阻塞了，就会一直停留在这里
  390.                 is = socket.getInputStream();
  391.                 os = socket.getOutputStream();
  392.                 while (true) {
  393.                     synchronized (this) {
  394.                         byte[] tt = new byte[is.available()];
  395.                         if (tt.length > 0) {
  396.                             is.read(tt, 0, tt.length);
  397.                             Message msg = new Message();
  398.                             msg.obj = new String(tt, "GBK");
  399.                             Log.e(TAG, "客户端:" + msg.obj);
  400.                             handler.sendMessage(msg);
  401.                         }
  402.                     }
  403.                 }
  404.             } catch (Exception e) {
  405.                 e.printStackTrace();
  406.             }
  407.         }
  408.     }
  409. }

参考:Android Bluetooth（蓝牙）实例 -Android教程

如何实现android蓝牙开发 自动配对连接,并不弹出提示框 - 天边的星星 - 博客园

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

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

  

闽ICP备14008679号