Android 蓝牙开发(一) -- 传统蓝牙聊天室

一、蓝牙概览

以下是蓝牙的介绍，来自维基百科：

蓝牙（英语：Bluetooth），一种无线通讯技术标准，用来让固定与移动设备，在短距离间交换数据，以形成个人局域网（PAN）。其使用短波特高頻（UHF）无线电波，经由2.4至2.485 GHz的ISM频段来进行通信[1]。1994年由电信商爱立信（Ericsson）发展出这个技术[2]。它最初的设计，是希望创建一个RS-232数据线的无线通信替代版本。它能够链接多个设备，克服同步的问题。

简单来讲，就是蓝牙功能支持设备以无线的方式与其他蓝牙设备(手机、音响等)交换数据

本章也重点介绍传统蓝牙，来学习如何使用流的传输方式，实现一个聊天室，效果如下：

客户端	服务端

1.1 基础知识

为了让支持蓝牙的设备能够通信，它们必须先通过配对形成通信通道，可以简单地分为服务端和客户端：

服务端：自身可被检测(搜索)，并自身设置成可接入请求的状态
客户端：支持发现其他可检测蓝牙设备，通过 connect 请求配对设备

当服务端接收配对后，两台设备就完成了绑定过程，并在其期间交换安全密钥，比如两台手机蓝牙连接时，弹出的pin密钥。二者会存储密码，下次连接的时候，就可以自动连接，不用再经历上面的过程。

二、蓝牙开发

下面，一起学习如何使用官方提供的蓝牙实现蓝牙开发。

2.1 权限申请

首先需要先申请权限，如下：

<uses-permission android:name="android.permission.BLUETOOTH" />
    <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
    <!--
 If your app targets Android 9 or lower, you can declare
         ACCESS_COARSE_LOCATION instead.
    -->
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />

如果想要适配 Android 9(API 28) 或更高版本，则需要申请 ACCESS_FINE_LOCATION 精准定位，如果不适配，则申请 ACCESS_COARSE_LOCATION 即可。

注意，如果是Android 10 ，除了开启蓝牙，还需要开启 gps 功能才行，不然不能搜索和连接其他蓝牙设备
可以做个提示：

 //在 Android 10 还需要开启 gps
 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
    
    
     val lm: LocationManager = getSystemService(Context.LOCATION_SERVICE) as LocationManager
     if (!lm.isProviderEnabled(LocationManager.GPS_PROVIDER)){
    
    
         Toast.makeText(this@MainActivity, "请您先开启gps,否则蓝牙不可用", Toast.LENGTH_SHORT).show()
     }
 }

2.2 设置蓝牙

首先拿到 BluetoothAdapter ，BluetoothAdapter 是所有蓝牙交互的入口点，借助该类，你可以发现其他蓝牙设备，查询已绑定的设备的列表，以及获取 BluetoothDevice 等。开启也很简单，如下：

val bluetooth = BluetoothAdapter.getDefaultAdapter()

如果为 null，则说明你的设备并没有蓝牙驱动，如果找到了，还可以通过 bluetooth.isEnabled 来判断蓝牙是否开启：

 if (bluetooth == null) {
    
    
      Toast.makeText(this, "您的设备未找到蓝牙驱动！！", Toast.LENGTH_SHORT).show()
      finish()
  }else {
    
    
      if (!bluetooth.isEnabled) {
    
    
          startActivityForResult(Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE),1)
      }
  }

它会弹出一个是否开启蓝牙的提示框，至于是否开启成功，可以在 oActivityResult 中的 result 去判断开启成功与否，比如：

 override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    
    
     super.onActivityResult(requestCode, resultCode, data)
     if (requestCode == 1){
    
    
         if (resultCode == Activity.RESULT_CANCELED){
    
    
             Toast.makeText(this, "请您不要拒绝开启蓝牙，否则应用无法运行", Toast.LENGTH_SHORT).show()
             finish()
         }
     }
 }

你还可选择监听 ACTION_STATE_CHANGED 广播，每当蓝牙状态发生变化时，系统都会广播此 Intent。此广播包含额外字段 EXTRA_STATE 和 EXTRA_PREVIOUS_STATE，二者分别包含新的和旧的蓝牙状态。这些额外字段可能为以下值：STATE_TURNING_ON、STATE_ON、STATE_TURNING_OFF 和 STATE_OFF

2.3 获取蓝牙列表

通过 BluetoothAdapter 可以拿到已经匹配的蓝牙设备，也可以通过 startDiscovery() 方法去查找附近的蓝牙设备，注意只有开启了可被检测的设备才能被查找到。

2.3.1 获取已配对的蓝牙设备

在查找其他设备之前，可以先拿到已配对的设备，通过 getBondedDevices() 方法，该方法会返回一个 BluetoothDevice 的列表，通过它可以获取设备的 mac 地址和名字，如下：

val pairedDevices: Set<BluetoothDevice>? = bluetoothAdapter?.bondedDevices
pairedDevices?.forEach {
    
     device ->
    val deviceName = device.name
    val deviceHardwareAddress = device.address // MAC address
}

BluetoothDevice 表示蓝牙设备，借助该类，可以通过 BluetoothSocket 请求与某个远程设备建立连接，或这查询有关设备的信息，比如连接状态，名称，地址等

2.3.2 发现设备

要发现周围设备，可以使用 startDiscovery() 方法，该方法为异步操作，返回一个 boolean 值，表示该进程是否成功，该进程通常包含约 12 秒的查询扫描，可以通过广播注册 BluetoothDevice.ACTION_FOUND ,然后通过 BluetoothDevice.EXTRA_DEVICE 拿到被发现的设备，如下：

   /**
     * 查找蓝牙
     */
    fun foundDevices(callback: BlueDevFoundListener?) {
    
    
        blueDevFoundListener = callback;
        //先取消搜索
        bluetoothAdapter.cancelDiscovery()

        //获取已经配对的设备
        val bondedDevices = bluetoothAdapter.bondedDevices
        bondedDevices?.forEach {
    
     device ->
            //公布给外面，方便 recyclerview 等设备连接
            callback?.let {
    
     it(device) }
        }
        //搜索蓝牙，这个过程大概12s左右
        bluetoothAdapter.startDiscovery()
    }

然后在 onReceive() 方法中，按到其他设备：

when (intent?.action) {
    
    
     BluetoothDevice.ACTION_FOUND -> {
    
    
         val device =
             intent.getParcelableExtra<BluetoothDevice>(BluetoothDevice.EXTRA_DEVICE)
         device ?: return
         blueDevFoundListener?.let {
    
     it(device) }
     }
 }

在 recyclerview 显示，如下：
在这里插入图片描述

2.3.3 启动可检测性

一般手机的蓝牙都是可以被检测到的，如果你发现你的手机蓝牙没被发现，或者你不想一直让别人发现你的手机蓝牙，可以使用使用 ACTION_REQUEST_DISCOVERABLE 的 Intent，调用 startActivityForResult(Intent, int) ，这样就可以弃用系统可检测性模式的情趣，从而不用到设置里去配置，默认设备处于可检测模式为 120 s，通过添加 EXTRA_DISCOVERABLE_DURATION Extra 属性，您可以定义不同的持续时间，最高可达 3600 秒（1 小时）。

如果您将 EXTRA_DISCOVERABLE_DURATION Extra 属性的值设置为 0，则设备将始终处于可检测到模式。此配置安全性低，因而非常不建议使用。

以下代码让设备处于可检测模式的时间为 5 分钟 (300s)

val discoverableIntent: Intent = Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE).apply {
    
    
    putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 300)
}
startActivityForResult(discoverableIntent,1)

设备将在分配的时间内保持可检测模式，可以在onActivityResult 中，检测是否开启成功。

如果你也想知道当前模式发现改变的通知，可以注册广播ACTION_SCAN_MODE_CHANGED，然后接收 BluetoothAdapter 的字段 EXTRA_SCAN_MODE 和 EXTRA_PREVIOUS_SCAN_MODE，二者分别提供新的和旧的扫描模式。每个 Extra 属性可能拥有以下值：

SCAN_MODE_CONNECTABLE_DISCOVERABLE ：设备处于可检测模式
SCAN_MODE_CONNECTABLE：设备未处于可检测到模式，但仍能收到连接。
SCAN_MODE_NONE：设备未处于可检测到模式，且无法收到连接。

2.4 连接设备

如果在两台设备创建连接，需要实现服务端和客户端的机制，其中一台设备开放服务端套接字，而另一台通过 mac 地址发起连接，来连接成功之后，就会建立 RFCOMM 通道，就可以接收到套接字的信息了。

当一台设备连接另一台设备时，Android框架会自动想用户显示请求通知框，RFCOMM请求会一直阻塞，直到用户点击配对成功；或者用户拒绝配对，或者超时时，阻塞才会消失。

如下图：
在这里插入图片描述

2.4.1 服务端连接

当两台设备连接时，其中一台充当服务端，它会监听是否有客户端接入，通过以下步骤创建服务端：

通过 BluetoothAdapter 的 listenUsingInsecureRfcommWithServiceRecord() 去拿到 BluetoothserverSocket。
它的参数是 (String name, UUID uuid) ，第一个表示服务可识别名称，系统会自动写入到设备上的服务发现协议(SDP)数据库条目，该名称可随意写。uuid 比较关键，你可以连接成 socket 的端口，它是服务的唯一标识，它有128位，所以基本不用担心冲突问题；可以使用 fromString(String) 初始化一个 UUID。注意要和客户端保持一致(端口一致)
调用 accpet() 监听连接请求，该方法会一致阻塞，当接收或者异常时会返回，只有 uuid 相同时，才会接受连接，返回连接的 BluetoothSocket
如果不接受更多的连接，可以使用 close() 方法：如果你不打算连接多个设备，可以使用 close() ，它只会关闭服务端的套接字，但不会关闭 accept() 的 BluetoothSocket 套接字，和 Socket 不同，RFCOMM 一次只允许一个已连接的客户端通信，可以一般都是调用 close() 方法

所以，我们可以这样写：

/**
     * 监听是否有设备接入
     */
    private inner class AcceptThread(val readListener: HandleSocket.BluetoothListener?,
                                     val writeListener:HandleSocket.BaseBluetoothListener?) : Thread() {
    
    


        private val serverSocket: BluetoothServerSocket? by lazy {
    
    
            //非明文匹配，不安全
            readListener?.onStart()
            bluetooth.listenUsingInsecureRfcommWithServiceRecord(TAG, BlueHelper.BLUE_UUID)
        }

        override fun run() {
    
    
            super.run()
            var shouldLoop = true
            while (shouldLoop) {
    
    
                var socket: BluetoothSocket? =
                    try {
    
    
                        //监听是否有接入
                        serverSocket?.accept()
                    } catch (e: Exception) {
    
    
                        Log.d(TAG, "zsr blue socket accept fail: ${e.message}")
                        shouldLoop = false
                        null
                    }
                socket?.also {
    
    
                    //拿到接入设备的名字
                    readListener?.onConnected(socket.remoteDevice.name)
                    //处理接收事件
                    handleSocket = HandleSocket(socket)
                    handleSocket.start(readListener,writeListener)
                    //关闭服务端，只连接一个
                    serverSocket?.close()
                    shouldLoop = false;
                }
            }
        }

        fun cancel() {
    
    
            serverSocket?.close()
            handleSocket.close()
        }
    }

可以看到，使用 listenUsingInsecureRfcommWithServiceRecord() 之后，使用 accept() 去等待设备接入，拿到 BluetoothSocket 之后，交给 HandleSocket 去处理读写。这个后面再说

2.4.2 客户端

有了服务端，那么客户端也与 socket 相似，它的步骤如下：

使用 BluetoothDevice 的 createRfcommSocketToServiceRecord(UUID) 方法获取 BluetoothSocket。
此方法会初始化 BluetoothSocket 对象，以便客户端连接至 BluetoothDevice。此处传递的 UUID 必须与服务器设备在调用 listenUsingRfcommWithServiceRecord(String, UUID) 开放其 BluetoothServerSocket 时所用的 UUID 相匹配。
通过调用 connect() 发起连接。请注意，此方法为阻塞调用。
当客户端调用此方法后，系统会执行 SDP 查找(上面服务端的时候也说了)，以找到带有所匹配 UUID 的远程设备。如果查找成功并且远程设备接受连接，则其会共享 RFCOMM 通道，在连接期间就可以通信，并且 connect() 方法将会返回套接字。如果连接失败，或者 connect() 方法超时（约 12 秒后），则此方法将引发 IOException。

代码如下：

/**
     * 连接类
     */
    inner class ConnectThread(
        val device: BluetoothDevice, val readListener: HandleSocket.BluetoothListener?,
        val writeListener: HandleSocket.BaseBluetoothListener?
    ) : Thread() {
    
    
        var handleSocket: HandleSocket? = null
        private val socket: BluetoothSocket? by lazy {
    
    
            readListener?.onStart()
            //监听该 uuid 
            device.createRfcommSocketToServiceRecord(BlueHelper.BLUE_UUID)
        }

        override fun run() {
    
    
            super.run()
            //下取消
            bluetooth.cancelDiscovery()
            try {
    
    

                socket.run {
    
    
                    //阻塞等待
                    this?.connect()
                    //连接成功，拿到服务端设备名
                    socket?.remoteDevice?.let {
    
     readListener?.onConnected(it.name) }

                    //处理 socket 读写
                    handleSocket = HandleSocket(this)
                    handleSocket?.start(readListener, writeListener)

                }
            } catch (e: Exception) {
    
    
                readListener?.onFail(e.message.toString())
            }
        }

        fun cancel() {
    
    
            socket?.close()
            handleSocket?.close()
        }
    }

步骤比较简单，就没好说的了

2.4.3 套接字读写

上面不管是服务端还是客户端都用到 HandleSocket 来处理套接字读写的问题。
首先，可以通过 BluetoothSocket 的使用 getInputStream() 和 getOutputStream()，分别获取通过套接字处理数据传输的 InputStream 和 OutputStream。
接着使用使用 read(byte[]) 和 write(byte[]) 读取数据以及将其写入数据流。

这样，我们的读就可以这样写：

/**
     * 读取数据
     */
    private class ReadThread(val socket: BluetoothSocket?,val bluetoothListener: BaseBluetoothListener?) : Thread() {
    
    

        //拿到 BluetoothSocket 的输入流
        private val inputStream: DataInputStream? = DataInputStream(socket?.inputStream)
        private var isDone = false
        private val listener :BluetoothListener? = bluetoothListener as BluetoothListener
        //todo 目前简单数据，暂时使用这种
        private val byteBuffer: ByteArray = ByteArray(1024)
        override fun run() {
    
    
            super.run()
            var size :Int? = null
            while (!isDone) {
    
    
                try {
    
    
                    //拿到读的数据和大小
                    size = inputStream?.read(byteBuffer)
                } catch (e: Exception) {
    
    
                    isDone = false
                    e.message?.let {
    
     listener?.onFail(it) }
                    return
                }


                if (size != null && size>0) {
    
    
                    //把结果公布出去
                    listener?.onReceiveData(String(byteBuffer,0,size))
                } else {
    
    
                    //如果接收不到数据，则证明已经断开了
                    listener?.onFail("断开连接")
                    isDone = false;
                }
            }
        }

        fun cancel() {
    
    
            isDone = false;
            socket?.close()
            close(inputStream)
        }
    }

非常简单，拿到inputstream 之后，通过 read() 方法读数据即可，由于是聊天室，所以这里直接转换 String，如果你是要传文件，可以修改成你想要的。

接着是写

/**
     * 写数据
     */
    class WriteThread(private val socket: BluetoothSocket?,val listener: BaseBluetoothListener?) {
    
    

        private var isDone = false
        //拿到 socket 的 outputstream
        private val dataOutput: OutputStream? = socket?.outputStream
        //暂时现成的线程池
        private val executor = Executors.newSingleThreadExecutor()
        fun sendMsg(msg:String){
    
    
            //通过线程池去发
            executor.execute(sendSync(msg))
        }

        fun cancel(){
    
    
            isDone = true
            executor.shutdownNow()
            socket?.close()
            close(dataOutput)
        }
        //用一个 runnable 去复用
        private inner class  sendSync(val msg:String) :Runnable{
    
    
            override fun run() {
    
    
                if (isDone){
    
    
                    return
                }

                try {
    
    
                    //写数据
                    dataOutput?.write(msg.toByteArray())
                    dataOutput?.flush()

                }catch (e:Exception){
    
    
                    e.message?.let {
    
     listener?.onFail(it) }
                }

            }

        }

    }

可以看到，拿到 outputStream 之后，通过 write() 把数据写过去，虽然官网说 write() 一般不会阻塞，但是我们还是放在线程中，这里用线程池去复用一个 runnable，直接发送即可。

这样，我们就学习完了经典蓝牙的聊天室功能，下一章，学习通过 A2DP 的协议，实现手机与蓝牙音响的音频传输。

转载:https://blog.csdn.net/u011418943/article/details/107818438