镜月湖的月亮 發表於 2020-8-11 16:42:00

Android蓝牙开发（二）经典蓝牙消息传输实现

<p>上篇文章中，我们主要介绍了蓝牙模块，传统/经典蓝牙模块BT和低功耗蓝牙BLE及其相关的API，不熟悉的可以查看Android蓝牙开发（一）蓝牙模块及核心API 进行了解。</p>
<p>本篇主要记录用到的经典蓝牙开发流程及连接通讯。</p>
<h1 id="1-开启蓝牙">1. 开启蓝牙</h1>
<p>蓝牙连接前，给与相关系统权限：</p>
<pre><code class="language-xml">&lt;!-- 使用蓝牙的权限 --&gt;
&lt;uses-permission android:name="android.permission.BLUETOOTH" /&gt;
&lt;!-- 扫描蓝牙设备或者操作蓝牙设置 --&gt;
&lt;uses-permission android:name="android.permission.BLUETOOTH_ADMIN" /&gt;
&lt;!--模糊定位权限，仅作用于6.0+--&gt;
&lt;uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" /&gt;
&lt;!--精准定位权限，仅作用于6.0+--&gt;
&lt;uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" /&gt;
</code></pre>
<p>安卓6.0以上系统要动态请求及获取开启GPS内容：</p>
<pre><code class="language-java">/**
* 检查GPS是否打开
*/
private boolean checkGPSIsOpen() {
    LocationManager locationManager = (LocationManager) mContext.getSystemService(Context.LOCATION_SERVICE);
    if (locationManager == null)
      return false;
    return locationManager.isProviderEnabled(android.location.LocationManager.GPS_PROVIDER);
}
</code></pre>
<p>蓝牙核心对象获取，若获取对象为null则说明设备不支持蓝牙：</p>
<pre><code class="language-java">mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
</code></pre>
<p>判断蓝牙是否开启，没有则开启：</p>
<pre><code class="language-java">//判断蓝牙是否开启
if (!mBluetoothAdapter.isEnabled()) {
    //开启蓝牙，耗时，监听广播进行后续操作
    mBluetoothAdapter.enable();
}
</code></pre>
<h1 id="2扫描蓝牙">2.扫描蓝牙</h1>
<p>蓝牙扫描：</p>
<pre><code class="language-java">mBluetoothAdapter.startDiscovery();
</code></pre>
<p>取消扫描：</p>
<pre><code class="language-java">mBluetoothAdapter.cancelDiscovery();
</code></pre>
<h1 id="3蓝牙状态监听">3.蓝牙状态监听</h1>
<p>蓝牙监听广播，监听蓝牙开关，发现设备，扫描结束等状态，定义状态回调接口，进行对应操作，例如：监听到蓝牙开启后，进行设备扫描；发现设备后进行连接等。</p>
<pre><code class="language-java">/**
* 监听蓝牙广播-各种状态
*/
public class BluetoothReceiver extends BroadcastReceiver {
    private static final String TAG = BluetoothReceiver.class.getSimpleName();
    private final OnBluetoothReceiverListener mOnBluetoothReceiverListener;

    public BluetoothReceiver(Context context,OnBluetoothReceiverListener onBluetoothReceiverListener) {
      mOnBluetoothReceiverListener = onBluetoothReceiverListener;
      context.registerReceiver(this,getBluetoothIntentFilter());
    }

    private IntentFilter getBluetoothIntentFilter() {
      IntentFilter filter = new IntentFilter();
      filter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED);//蓝牙开关状态
      filter.addAction(BluetoothAdapter.ACTION_DISCOVERY_STARTED);//蓝牙开始搜索
      filter.addAction(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);//蓝牙搜索结束
      filter.addAction(BluetoothDevice.ACTION_FOUND);//蓝牙发现新设备(未配对的设备)
      return filter;
    }

    @Override
    public void onReceive(Context context, Intent intent) {
      String action = intent.getAction();
      if (action == null) {
            return;
      }
      Log.i(TAG, "===" + action);
      BluetoothDevice dev = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
      if (dev != null) {
            Log.i(TAG, "BluetoothDevice: " + dev.getName() + ", " + dev.getAddress());
      }
      switch (action) {
            case BluetoothAdapter.ACTION_STATE_CHANGED:
                int state = intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, 0);
                Log.i(TAG, "STATE: " + state);
                if (mOnBluetoothReceiverListener != null) {
                  mOnBluetoothReceiverListener.onStateChanged(state);
                }
                break;
            case BluetoothAdapter.ACTION_DISCOVERY_STARTED:
                Log.i(TAG, "ACTION_DISCOVERY_STARTED ");
                break;
            case BluetoothAdapter.ACTION_DISCOVERY_FINISHED:
                if (mOnBluetoothReceiverListener != null) {
                  mOnBluetoothReceiverListener.onScanFinish();
                }
                break;
            case BluetoothDevice.ACTION_FOUND:
                short rssi = intent.getShortExtra(BluetoothDevice.EXTRA_RSSI, Short.MAX_VALUE);
                Log.i(TAG, "EXTRA_RSSI:" + rssi);
                if (mOnBluetoothReceiverListener != null) {
                  mOnBluetoothReceiverListener.onDeviceFound(dev);
                }
                break;
            default:
                break;
      }
    }

    public interface OnBluetoothReceiverListener {
      /**
         * 发现设备
         *
         * @param bluetoothDevice 蓝牙设备
         */
      void onDeviceFound(BluetoothDevice bluetoothDevice);

      /**
         * 扫描结束
         */
      void onScanFinish();

      /**
         * 蓝牙开启关闭状态
         *
         * @param state 状态
         */
      void onStateChanged(int state);
    }
}
</code></pre>
<h1 id="4通讯连接">4.通讯连接</h1>
<p>客户端，与服务端建立长连接，进行通讯：</p>
<pre><code class="language-java">/**
* 客户端，与服务端建立长连接
*/
public class BluetoothClient extends BaseBluetooth {

    public BluetoothClient(BTListener BTListener) {
      super(BTListener);
    }

    /**
   * 与远端设备建立长连接
   *
   * @param bluetoothDevice 远端设备
   */
    public void connect(BluetoothDevice bluetoothDevice) {
      close();
      try {
//             final BluetoothSocket socket = bluetoothDevice.createRfcommSocketToServiceRecord(SPP_UUID); //加密传输，Android强制执行配对，弹窗显示配对码
            final BluetoothSocket socket = bluetoothDevice.createInsecureRfcommSocketToServiceRecord(SPP_UUID); //明文传输(不安全)，无需配对
            // 开启子线程（必须在新线程中进行连接操作）
            EXECUTOR.execute(new Runnable() {
                @Override
                public void run() {
                  //连接，并进行循环读取
                  loopRead(socket);
                }
            });
      } catch (Throwable e) {
            close();
      }
    }
}
</code></pre>
<p>服务端监听客户端发起的连接，进行接收及通讯：</p>
<pre><code class="language-java">/**
* 服务端监听和连接线程，只连接一个设备
*/
public class BluetoothServer extends BaseBluetooth {
    private BluetoothServerSocket mSSocket;

    public BluetoothServer(BTListener BTListener) {
      super(BTListener);
      listen();
    }

    /**
   * 监听客户端发起的连接
   */
    public void listen() {
      try {
            BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
//            mSSocket = adapter.listenUsingRfcommWithServiceRecord("BT", SPP_UUID); //加密传输，Android强制执行配对，弹窗显示配对码
            mSSocket = adapter.listenUsingInsecureRfcommWithServiceRecord("BT", SPP_UUID); //明文传输(不安全)，无需配对
            // 开启子线程
            EXECUTOR.execute(new Runnable() {
                @Override
                public void run() {
                  try {
                        BluetoothSocket socket = mSSocket.accept(); // 监听连接
                        mSSocket.close(); // 关闭监听，只连接一个设备
                        loopRead(socket); // 循环读取
                  } catch (Throwable e) {
                        close();
                  }
                }
            });
      } catch (Throwable e) {
            close();
      }
    }

    @Override
    public void close() {
      super.close();
      try {
            mSSocket.close();
      } catch (Throwable e) {
            e.printStackTrace();
      }
    }
}
</code></pre>
<p>客户端连接及服务端监听基类，用于客户端和服务端之前Socket消息通讯，进行消息或文件的发送、接收，进行通讯关闭操作等：</p>
<pre><code class="language-java">public class BaseBluetooth {
    public static final Executor EXECUTOR = Executors.newSingleThreadExecutor();
    protected static final UUID SPP_UUID = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB"); //自定义
    private static final String FILE_PATH = Environment.getExternalStorageDirectory().getAbsolutePath() + "/bluetooth/";
    private static final int FLAG_MSG = 0;//消息标记
    private static final int FLAG_FILE = 1; //文件标记

    private BluetoothSocket mSocket;
    private DataOutputStream mOut;
    private BTListener mBTListener;
    private boolean isRead;
    private boolean isSending;

    public BaseBluetooth(BTListener BTListener) {
      mBTListener = BTListener;
    }

    /**
   * 循环读取对方数据(若没有数据，则阻塞等待)
   */
    public void loopRead(BluetoothSocket socket) {
      mSocket = socket;
      try {
            if (!mSocket.isConnected())
                mSocket.connect();
            notifyUI(BTListener.CONNECTED, mSocket.getRemoteDevice());
            mOut = new DataOutputStream(mSocket.getOutputStream());
            DataInputStream in = new DataInputStream(mSocket.getInputStream());
            isRead = true;
            while (isRead) { //循环读取
                switch (in.readInt()) {
                  case FLAG_MSG: //读取短消息
                        String msg = in.readUTF();
                        notifyUI(BTListener.MSG_RECEIVED, msg);
                        break;
                  case FLAG_FILE: //读取文件
                        File file = new File(FILE_PATH);
                        if (!file.exists()) {
                            file.mkdirs();
                        }
                        String fileName = in.readUTF(); //文件名
                        long fileLen = in.readLong(); //文件长度
                        notifyUI(BTListener.MSG_RECEIVED, "正在接收文件(" + fileName + ")····················");
                        // 读取文件内容
                        long len = 0;
                        int r;
                        byte[] b = new byte;
                        FileOutputStream out = new FileOutputStream(FILE_PATH + fileName);
                        while ((r = in.read(b)) != -1) {
                            out.write(b, 0, r);
                            len += r;
                            if (len &gt;= fileLen)
                              break;
                        }
                        notifyUI(BTListener.MSG_RECEIVED, "文件接收完成(存放在:" + FILE_PATH + ")");
                        break;
                }
            }
      } catch (Throwable e) {
            close();
      }
    }

    /**
   * 发送短消息
   */
    public void sendMsg(String msg) {
      if (isSending || TextUtils.isEmpty(msg))
            return;
      isSending = true;
      try {
            mOut.writeInt(FLAG_MSG); //消息标记
            mOut.writeUTF(msg);
      } catch (Throwable e) {
            close();
      }
      notifyUI(BTListener.MSG_SEND, "发送短消息：" + msg);
      isSending = false;
    }

    /**
   * 发送文件
   */
    public void sendFile(final String filePath) {
      if (isSending || TextUtils.isEmpty(filePath))
            return;
      isSending = true;
      EXECUTOR.execute(new Runnable() {
            @Override
            public void run() {
                try {
                  notifyUI(BTListener.MSG_SEND, "正在发送文件(" + filePath + ")····················");
                  FileInputStream in = new FileInputStream(filePath);
                  File file = new File(filePath);
                  mOut.writeInt(FLAG_FILE); //文件标记
                  mOut.writeUTF(file.getName()); //文件名
                  mOut.writeLong(file.length()); //文件长度
                  int r;
                  byte[] b = new byte;
                  while ((r = in.read(b)) != -1) {
                        mOut.write(b, 0, r);
                  }
                  notifyUI(BTListener.MSG_SEND, "文件发送完成.");
                } catch (Throwable e) {
                  close();
                }
                isSending = false;
            }
      });
    }

    /**
   * 关闭Socket连接
   */
    public void close() {
      try {
            isRead = false;
            if (mSocket != null) {
                mSocket.close();
                notifyUI(BTListener.DISCONNECTED, null);
            }
      } catch (Throwable e) {
            e.printStackTrace();
      }
    }

    /**
   * 当前设备与指定设备是否连接
   */
    public boolean isConnected(BluetoothDevice dev) {
      boolean connected = (mSocket != null &amp;&amp; mSocket.isConnected());
      if (dev == null)
            return connected;
      return connected &amp;&amp; mSocket.getRemoteDevice().equals(dev);
    }

    private void notifyUI(final int state, final Object obj) {
      mBTListener.socketNotify(state, obj);
    }

    public interface BTListener {
      int DISCONNECTED = 0;
      int CONNECTED = 1;
      int MSG_SEND = 2;
      int MSG_RECEIVED = 3;

      void socketNotify(int state, Object obj);
    }
</code></pre>
<p>我这里只是简单记录了项目中用到的蓝牙通讯，两个设备之间不通过配对进行连接、通讯。<br>
相关详细内容及使用请查看Github项目：https://github.com/MickJson/BluetoothCS</p>
<p>蓝牙配对操作及其它内容，可以详细查看我下面的参考资料，写的十分详细，比如设备通过MAC地址，可以通过BluetoothAdapter获取设备，再通过客户端connect方法去进行连接等。</p>
<pre><code class="language-java">BluetoothDevice btDev = mBluetoothAdapter.getRemoteDevice(address);
</code></pre>
<h1 id="最后">最后</h1>
<p>连接中遇到问题：read failed, socket might closed or timeout, read ret: -1。</p>
<p>通过改UUID，反射等方法都还是会出现错误。连接时，要确保服务端及客户端都处于完全断开状态，否则连接就会出现以上问题，但偶尔还是会有问题，期待有什么好的方法可留言告诉我。</p>
<p>参考资料：</p>
<p>Android-经典蓝牙(BT)-建立长连接传输短消息和文件</p>
<p>Android蓝牙开发—经典蓝牙详细开发流程</p>
<p><strong>欢迎点赞/评论，你们的赞同和鼓励是我写作的最大动力！</strong></p>
<p>关注公众号：几圈年轮，查看更多有趣的技术资源。</p><br><br>
来源：https://www.cnblogs.com/jqnl/p/13476587.html
頁: [1]
查看完整版本: Android蓝牙开发（二）经典蓝牙消息传输实现