设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

帖子
»论坛 › 操作系统 › 安卓系统 › Android蓝牙调试助手源码分享
返回列表 发新帖
查看: 3839|回复: 1
收起左侧

Android蓝牙调试助手源码分享

[复制链接]
ID:420684 发表于 2018-11-4 20:06 | 显示全部楼层 |阅读模式
0.png
下载：
蓝牙调试助手.zip (121.49 KB, 下载次数: 50)

部分源码预览：
  1. package com.example.android.BluetoothChat;
  2. /**
  3. * 描述：蓝牙服务核心类
  4. */
  5. import java.io.IOException;
  6. import java.io.InputStream;
  7. import java.io.OutputStream;
  8. import java.util.UUID;

  10. import android.bluetooth.BluetoothAdapter;
  11. import android.bluetooth.BluetoothDevice;
  12. import android.bluetooth.BluetoothServerSocket;
  13. import android.bluetooth.BluetoothSocket;
  14. import android.content.Context;
  15. import android.os.Bundle;
  16. import android.os.Handler;
  17. import android.os.Message;
  18. import android.util.Log;
  19. public class BluetoothChatService {
  20.     // 测试数据
  21.     private static final String TAG = "BluetoothChatService";
  22.     private static final boolean D = true;

  24.     private static final String NAME = "BluetoothChat";

  26.     // 声明一个唯一的UUID
  27.     private static final UUID MY_UUID = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");        //change by chongqing jinou        

  29.     private final BluetoothAdapter mAdapter;
  30.     private final Handler mHandler;
  31.     private AcceptThread mAcceptThread;
  32.     private ConnectThread mConnectThread;
  33.     private ConnectedThread mConnectedThread;
  34.     private int mState;

  36.     // 常量,显示当前的连接状态
  37.     public static final int STATE_NONE = 0;
  38.     public static final int STATE_LISTEN = 1;
  39.     public static final int STATE_CONNECTING = 2;
  40.     public static final int STATE_CONNECTED = 3;
  41.    
  42.     public BluetoothChatService(Context context, Handler handler) {
  43.         mAdapter = BluetoothAdapter.getDefaultAdapter();
  44.         mState = STATE_NONE;
  45.         mHandler = handler;
  46.     }

  48.     /**
  49.      * 设置当前的连接状态
  50.      * @param state  连接状态
  51.      */
  52.     private synchronized void setState(int state) {
  53.         if (D) Log.d(TAG, "setState() " + mState + " -> " + state);
  54.         mState = state;

  56.         // 通知Activity更新UI
  57.         mHandler.obtainMessage(BluetoothChatActivity.MESSAGE_STATE_CHANGE, state, -1).sendToTarget();
  58.     }

  60.     /**
  61.      * 返回当前连接状态
  62.      *
  63.      */
  64.     public synchronized int getState() {
  65.         return mState;
  66.     }

  68.     /**
  69.      *开始聊天服务
  70.      *
  71.      */
  72.     public synchronized void start() {
  73.         if (D) Log.d(TAG, "start");

  75.         if (mConnectThread != null) {mConnectThread.cancel(); mConnectThread = null;}

  77.         if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread = null;}

  79.         if (mAcceptThread == null) {
  80.             mAcceptThread = new AcceptThread();
  81.             mAcceptThread.start();
  82.         }
  83.         setState(STATE_LISTEN);
  84.     }

  86.     /**
  87.      * 连接远程设备
  88.      * @param device  连接
  89.      */
  90.     public synchronized void connect(BluetoothDevice device) {
  91.         if (D) Log.d(TAG, "连接到: " + device);

  93.         if (mState == STATE_CONNECTING) {
  94.             if (mConnectThread != null) {mConnectThread.cancel(); mConnectThread = null;}
  95.         }

  97.         if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread = null;}

  99.         mConnectThread = new ConnectThread(device);
  100.         mConnectThread.start();
  101.         setState(STATE_CONNECTING);
  102.     }

  104.     /**
  105.      * 启动ConnectedThread开始管理一个蓝牙连接
  106.      */
  107.     public synchronized void connected(BluetoothSocket socket, BluetoothDevice device) {
  108.         if (D) Log.d(TAG, "连接");

  110.         if (mConnectThread != null) {mConnectThread.cancel(); mConnectThread = null;}

  112.         if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread = null;}

  114.         if (mAcceptThread != null) {mAcceptThread.cancel(); mAcceptThread = null;}

  116.         mConnectedThread = new ConnectedThread(socket);
  117.         mConnectedThread.start();

  119.         Message msg = mHandler.obtainMessage(BluetoothChatActivity.MESSAGE_DEVICE_NAME);
  120.         Bundle bundle = new Bundle();
  121.         bundle.putString(BluetoothChatActivity.DEVICE_NAME, device.getName());
  122.         msg.setData(bundle);
  123.         mHandler.sendMessage(msg);

  125.         setState(STATE_CONNECTED);
  126.     }

  128.     /**
  129.      * 停止所有线程
  130.      */
  131.     public synchronized void stop() {
  132.         if (D) Log.d(TAG, "stop");
  133.         setState(STATE_NONE);
  134.         if (mConnectThread != null) {mConnectThread.cancel(); mConnectThread = null;}
  135.         if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread = null;}
  136.         if (mAcceptThread != null) {mAcceptThread.cancel(); mAcceptThread = null;}
  137.     }

  139.     /**
  140.      * 以非同步方式写入ConnectedThread
  141.      * @param out
  142.      */
  143.     public void write(byte[] out) {
  144.         ConnectedThread r;
  145.         synchronized (this) {
  146.             if (mState != STATE_CONNECTED) return;
  147.             r = mConnectedThread;
  148.         }
  149.         r.write(out);
  150.     }

  152.     /**
  153.      * 无法连接，通知Activity
  154.      */
  155.     private void connectionFailed() {
  156.         setState(STATE_LISTEN);
  157.         
  158.         Message msg = mHandler.obtainMessage(BluetoothChatActivity.MESSAGE_TOAST);
  159.         Bundle bundle = new Bundle();
  160.         bundle.putString(BluetoothChatActivity.TOAST, "无法连接设备");
  161.         msg.setData(bundle);
  162.         mHandler.sendMessage(msg);
  163.     }

  165.     /**
  166.      * 设备断开连接，通知Activity
  167.      */
  168.     private void connectionLost() {

  170.         Message msg = mHandler.obtainMessage(BluetoothChatActivity.MESSAGE_TOAST);
  171.         Bundle bundle = new Bundle();
  172.         bundle.putString(BluetoothChatActivity.TOAST, "设备断开连接");
  173.         msg.setData(bundle);
  174.         mHandler.sendMessage(msg);
  175.     }

  177.     /**
  178.      * 监听传入的连接
  179.      */
  180.     private class AcceptThread extends Thread {
  181.         private final BluetoothServerSocket mmServerSocket;

  183.         public AcceptThread() {
  184.             BluetoothServerSocket tmp = null;

  186.             try {
  187.                 tmp = mAdapter.listenUsingRfcommWithServiceRecord(NAME, MY_UUID);
  188.             } catch (IOException e) {
  189.                 Log.e(TAG, "listen() failed", e);
  190.             }
  191.             mmServerSocket = tmp;
  192.         }

  194.         public void run() {
  195.             if (D) Log.d(TAG, "BEGIN mAcceptThread" + this);
  196.             setName("AcceptThread");
  197.             BluetoothSocket socket = null;

  199.             while (mState != STATE_CONNECTED) {
  200.                 try {
  201.                     socket = mmServerSocket.accept();
  202.                 } catch (IOException e) {
  203.                     Log.e(TAG, "accept() 失败", e);
  204.                     break;
  205.                 }

  207.                 // 如果连接被接受
  208.                 if (socket != null) {
  209.                     synchronized (BluetoothChatService.this) {
  210.                         switch (mState) {
  211.                         case STATE_LISTEN:
  212.                         case STATE_CONNECTING:
  213.                             // 开始连接线程
  214.                             connected(socket, socket.getRemoteDevice());
  215.                             break;
  216.                         case STATE_NONE:
  217.                         case STATE_CONNECTED:
  218.                             // 没有准备好或已经连接
  219.                             try {
  220.                                 socket.close();
  221.                             } catch (IOException e) {
  222.                                 Log.e(TAG, "不能关闭这些连接", e);
  223.                             }
  224.                             break;
  225.                         }
  226.                     }
  227.                 }
  228.             }
  229.             if (D) Log.i(TAG, "结束mAcceptThread");
  230.         }

  232.         public void cancel() {
  233.             if (D) Log.d(TAG, "取消 " + this);
  234.             try {
  235.                 mmServerSocket.close();
  236.             } catch (IOException e) {
  237.                 Log.e(TAG, "关闭失败", e);
  238.             }
  239.         }
  240.     }


  243.     private class ConnectThread extends Thread {
  244.         private final BluetoothSocket mmSocket;
  245.         private final BluetoothDevice mmDevice;

  247.         public ConnectThread(BluetoothDevice device) {
  248.             mmDevice = device;
  249.             BluetoothSocket tmp = null;

  251.             try {
  252.                 tmp = device.createRfcommSocketToServiceRecord(MY_UUID);
  253.             } catch (IOException e) {
  254.                 Log.e(TAG, "create() 失败", e);
  255.             }
  256.             mmSocket = tmp;
  257.         }

  259.         public void run() {
  260.             Log.i(TAG, "开始mConnectThread");
  261.             setName("ConnectThread");

  263.             mAdapter.cancelDiscovery();

  265.             try {
  266.                 mmSocket.connect();
  267.             } catch (IOException e) {
  268.                 connectionFailed();
  269.                 try {
  270.                     mmSocket.close();
  271.                 } catch (IOException e2) {
  272.                     Log.e(TAG, "关闭连接失败", e2);
  273.                 }
  274.                 BluetoothChatService.this.start();
  275.                 return;
  276.             }

  278.             synchronized (BluetoothChatService.this) {
  279.                 mConnectThread = null;
  280.             }

  282.             connected(mmSocket, mmDevice);
  283.         }

  285.         public void cancel() {
  286.             try {
  287.                 mmSocket.close();
  288.             } catch (IOException e) {
  289.                 Log.e(TAG, "关闭连接失败", e);
  290.             }
  291.         }
  292.     }

  294.     /**
  295.      * 处理所有传入和传出的传输
  296.      */
  297.     private class ConnectedThread extends Thread {
  298.         private final BluetoothSocket mmSocket;
  299.         private final InputStream mmInStream;
  300.         private final OutputStream mmOutStream;

  302.         public ConnectedThread(BluetoothSocket socket) {
  303.             Log.d(TAG, "创建 ConnectedThread");
  304.             mmSocket = socket;
  305.             InputStream tmpIn = null;
  306.             OutputStream tmpOut = null;

  308.             // 得到BluetoothSocket输入和输出流
  309.             try {
  310.                 tmpIn = socket.getInputStream();
  311.                 tmpOut = socket.getOutputStream();
  312.             } catch (IOException e) {
  313.                 Log.e(TAG, "temp sockets not created", e);
  314.             }

  316.             mmInStream = tmpIn;
  317.             mmOutStream = tmpOut;
  318.         }

  320.         public void run() {
  321.             Log.i(TAG, "BEGIN mConnectedThread");
  322.             int bytes;
  323.             String str1 = "";            
  324.             // 循环监听消息
  325.             while (true) {
  326.                 try {
  327.                         byte[] buffer = new byte[256];
  328.                         
  329.                     bytes = mmInStream.read(buffer);                    
  330.                     String readStr = new String(buffer, 0, bytes);
  331.                     String str = bytes2HexString(buffer).replaceAll("00","").trim();
  332.                     if(bytes>0)
  333.                     {
  334.                            
  335.                             if (str.endsWith("0D")) {
  336.                                     byte[] buffer1 = (str1+readStr).getBytes();
  337.                                     mHandler.obtainMessage(BluetoothChatActivity.MESSAGE_READ, buffer1.length, -1, buffer1)
  338.                             .sendToTarget();
  339.                                     str1 = "";
  340.                                                 }
  341.                             else{
  342.                                     if (!str.contains("0A")) {
  343.                                             str1 = str1+readStr;
  344.                                                         }else{
  345.                                                                 if (!str.equals("0A")&&str.endsWith("0A")) {
  346.                                                                         mHandler.obtainMessage(BluetoothChatActivity.MESSAGE_READ, bytes, -1, buffer)
  347.                                             .sendToTarget();
  348.                                                                 }
  349.                                                         }
  350.                                                 }
  351.                            
  352.                     }
  353.                     else
  354.                     {
  355.                         Log.e(TAG, "disconnected");
  356.                         connectionLost();
  357.                         
  358.                         if(mState != STATE_NONE)
  359.                         {
  360.                             Log.e(TAG, "disconnected");
  361.                                 BluetoothChatService.this.start();
  362.                         }
  363.                         break;
  364.                     }
  365.                 } catch (IOException e) {
  366.                     Log.e(TAG, "disconnected", e);
  367.                     connectionLost();
  368.                     
  369.                     if(mState != STATE_NONE)
  370.                     {
  371.                             // 在重新启动监听模式启动该服务
  372.                             BluetoothChatService.this.start();
  373.                     }
  374.                     break;
  375.                 }
  376.             }
  377.         }

  379.         /**
  380.          * 写入OutStream连接
  381.          * @param buffer  要写的字节
  382.          */
  383.         public void write(byte[] buffer) {
  384.             try {
  385.                 mmOutStream.write(buffer);

  387.                 // 把消息传给UI
  388.                 mHandler.obtainMessage(BluetoothChatActivity.MESSAGE_WRITE, -1, -1, buffer)
  389.                         .sendToTarget();
  390.             } catch (IOException e) {
  391.                 Log.e(TAG, "Exception during write", e);
  392.             }
  393.         }

  395.         public void cancel() {
  396.             try {
  397.                 mmSocket.close();
  398.             } catch (IOException e) {
  399.                 Log.e(TAG, "close() of connect socket failed", e);
  400.             }
  401.         }
  402.     }
  403.     /**
  404.      * 从字节数组到十六进制字符串转换
  405.      */
  406.     public static String bytes2HexString(byte[] b) {
  407.             String ret = "";
  408.             for (int i = 0; i < b.length; i++) {
  409.              String hex = Integer.toHexString(b[ i ] & 0xFF);
  410.              if (hex.length() == 1) {
  411.               hex = '0' + hex;
  412.              }
  413.              ret += hex.toUpperCase();
  414.             }
  415.             return ret;
  416.           }
  417. }
复制代码


回复

举报

ID:422379 发表于 2018-11-7 15:24 | 显示全部楼层
1244194082@qq.com
回复

举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表