• Android 蓝牙开发（ 四 ）

    前言

    上一篇文章给大家分享了Kotlin版的Android蓝牙的基础知识和基础用法，不过上一篇都是一些零散碎片化的程序，，这一篇给大家分享Android蓝牙开发实战项目Kotlin+Compose的初步使用

    效果演示 : 

    Android Compose 蓝牙开发

    Android蓝牙实战开发步骤

    1.新建Android项目添加蓝牙权限

    下图所示：MyBluetoothDemo为刚刚创建的Android空项目，我们现在清单文件中把我们需要用到的权限声明一下，其中定位权限还需要做动态申请

    2.封装BluetoothAdapter类

    BluetoothAdapter类提供了常用的蓝牙API，我这里创建了一个BlueToothController类，小编这里是先将这些API封装到了一个BlueToothController类中，方便后续使用和操作

    1. package com.example.bluetoothcompose
    2.  
    3. import android.annotation.SuppressLint
    4. import android.app.Activity
    5. import android.bluetooth.BluetoothAdapter
    6. import android.bluetooth.BluetoothDevice
    7. import android.bluetooth.BluetoothSocket
    8. import android.content.Context
    9. import android.content.Intent
    10.  
    11. object BlueToothController {
    12.  
    13.     val mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter()
    14.  
    15.     /**
    16.      * 检查设备是否支持蓝牙
    17.      */
    18.     fun isBluetoothSupport(): Boolean {
    19.         return mBluetoothAdapter !=null
    20.     }
    21.  
    22.     /**
    23.      * 检查该设备蓝牙是否开启
    24.      */
    25.     @SuppressLint("MissingPermission")
    26.     fun isBluetoothEnabled(): Boolean {
    27.         return mBluetoothAdapter.enable()
    28.     }
    29.  
    30.  
    31.     /**
    32.      * 打开蓝牙
    33.      */
    34.     @SuppressLint("MissingPermission")
    35.     fun turnOnBlueTooth(activity: Activity, requestCode: Int) {
    36.         val intent = Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE)
    37.         activity.startActivityForResult(intent, requestCode)
    38.     }
    39.  
    40.  
    41.     /**
    42.      * 打开蓝牙可见性
    43.      */
    44.     @SuppressLint("MissingPermission")
    45.     fun enableVisibily(context: Context) {
    46.         val intent = Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE)
    47.         intent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 300)
    48.         context.startActivity(intent)
    49.     }
    50.  
    51.  
    52.     /**
    53.      * 停止查找设备
    54.      */
    55.     @SuppressLint("MissingPermission")
    56.     fun cancelFindDevice() {
    57.         mBluetoothAdapter.cancelDiscovery()
    58.     }
    59.  
    60.     /**
    61.      * 判断当前设备是否在查找蓝牙设备
    62.      */
    63.     @SuppressLint("MissingPermission")
    64.     fun isStartDiscovering(): Boolean {
    65.         return mBluetoothAdapter.isDiscovering
    66.     }
    67.  
    68.     /**
    69.      * 判断当前设备是否未在查找蓝牙设备
    70.      */
    71.     @SuppressLint("MissingPermission")
    72.     fun isCancelDiscovering(): Boolean {
    73.         return !mBluetoothAdapter.isDiscovering
    74.     }
    75.  
    76.  
    77.     /**
    78.      * 查找设备
    79.      */
    80.     @SuppressLint("MissingPermission")
    81.     fun findDevice() {
    82.         mBluetoothAdapter.startDiscovery()
    83.     }
    84.  
    85.  
    86.     /**
    87.      * 获取已绑定设备
    88.      */
    89.     @SuppressLint("MissingPermission")
    90.     fun getBondedDeviceList(): List? {
    91.         return ArrayList(mBluetoothAdapter.bondedDevices)
    92.     }
    93.  
    94.     /**
    95.      * 判断蓝牙是否连接
    96.      */
    97.     @SuppressLint("MissingPermission")
    98.     fun isConnectBlue(bluetoothSocket: BluetoothSocket?): Boolean {
    99.         return bluetoothSocket != null && bluetoothSocket.isConnected
    100.     }
    101. }

    3. 编写Compose UI页面

    这里的UI样式，在后面我给出了完整版的，大家可以去复制一下

    MainScreen：这是我们MainActivity的UI，放置了一个Column（竖向布局）和Menu

    1.     @Composable
    2.     fun MainScreen() {
    3.         var expanded = remember {
    4.             mutableStateOf(false)
    5.         }
    6.  
    7.  
    8.         Column(
    9.             modifier = Modifier.fillMaxSize()
    10.         )
    11.         {
    12.             Row(
    13.                 modifier = Modifier
    14.                     .fillMaxWidth()
    15.                     .background(Blue)
    16.                     .padding(vertical = 12.dp)
    17.                     .height(35.dp),
    18.                 verticalAlignment = Alignment.CenterVertically,
    19.                 horizontalArrangement = Arrangement.Start
    20.             ) {
    21.                 Text(
    22.                     text = "可用设备",
    23.                     modifier = Modifier
    24.                         .weight(1f)
    25.                         .offset(10.dp)
    26.                 )
    27.  
    28.                 if(isRefresh.value){
    29.                     CircularProgressIndicator(
    30.                         modifier = Modifier.size(25.dp),
    31.                         color = White
    32.                     )
    33.                 }
    34.  
    35.                 Box() {
    36.                     Icon(
    37.                         painter = painterResource(id = R.drawable.ic_setting),
    38.                         contentDescription = null,
    39.                         modifier = Modifier
    40.                             .width(50.dp)
    41.                             .fillMaxHeight()
    42.                             .clickable {
    43.                                 expanded.value = true
    44.                             },
    45.                     )
    46.  
    47.                     if(expanded.value){
    48.                         DropdownMenu(
    49.                             expanded = expanded.value,
    50.                             onDismissRequest = {
    51.                                 expanded.value = false
    52.                             }) {
    53.                             data.forEachIndexed{ index: Int, s: String ->
    54.                                 DropdownMenuItem(onClick = {
    55.                                     when (index) {
    56.                                         0 -> {
    57.                                             if(BlueToothController.isBluetoothSupport()){
    58.                                                 Toast.makeText(this@MainActivity,"本机支持蓝牙功能",Toast.LENGTH_SHORT).show()
    59.                                             }else{
    60.                                                 Toast.makeText(this@MainActivity,"本机暂不支持蓝牙功能",Toast.LENGTH_SHORT).show()
    61.                                             }
    62.                                         }
    63.                                         1 -> {
    64.                                             if(BlueToothController.isBluetoothEnabled()){
    65.                                                 Toast.makeText(this@MainActivity,"用户允许开启蓝牙",Toast.LENGTH_SHORT).show()
    66.                                             }else{
    67.                                                 Toast.makeText(this@MainActivity,"用户拒绝开启蓝牙",Toast.LENGTH_SHORT).show()
    68.                                             }
    69.                                         }
    70.                                         2 -> {
    71.                                             selected.value = 3
    72.                                             Log.d(TAG,"查看已绑定设备")
    73.                                             if(BlueToothController.isStartDiscovering()){
    74.                                                 BlueToothController.cancelFindDevice()
    75.                                             }
    76.                                             deviceList.clear()
    77.                                             for (device in BlueToothController.getBondedDeviceList()!!){
    78.                                                 deviceList.add(device!!)
    79.                                             }
    80.  
    81.                                         }
    82.                                         3 -> {
    83.                                             if(BlueToothController.isStartDiscovering()){
    84.                                                 Log.d(TAG,"停止查找")
    85.                                                 BlueToothController.cancelFindDevice()
    86.                                                 deviceList!!.clear()
    87.                                             }
    88.                                             selected.value = 4
    89.                                             BlueToothController.findDevice()
    90.                                             Log.d(TAG,"开始查找")
    91.                                         }
    92.                                     }
    93.                                     Log.d(TAG,selected.value.toString())
    94.                                     expanded.value = false
    95.                                 }) {
    96.                                     Text(text = s)
    97.                                 }
    98.                             }
    99.                         }
    100.                     }
    101.                 }
    102.             }
    103.  
    104.             DeviceListView()
    105.         }
    106.         if(openDialog.value){
    107.             AlterDialog()
    108.         }
    109.     }

    AlterDialog:    用来显示弹窗

    1.     @Composable
    2.     fun AlterDialog() {
    3.             AlertDialog(
    4.                 onDismissRequest = { openDialog.value = false },
    5.                 title = { Text(text = text.value) },
    6.                 text = {
    7.                     Text(
    8.                         text = "0c 11 09 41 23 00 01 03 FF"
    9.                     )
    10.                 }, confirmButton = {
    11.                     TextButton(onClick = {
    12.                         openDialog.value = false
    13.                         sendMessage()
    14.                     }) {
    15.                         Text(text = "发送")
    16.                     }
    17.                 }, dismissButton = {
    18.                     TextButton(onClick = { openDialog.value = false }) {
    19.                         Text(text = "取消")
    20.                     }
    21.                 })
    22.     }

    DeviceListView: 这是一个列表控件，相当于RecycleView  

    1.  
    2.     @Composable
    3.     fun DeviceListView(){
    4.         LazyColumn(
    5.             Modifier
    6.                 .fillMaxSize(),
    7.             contentPadding =  PaddingValues(5.dp,1.dp),
    8.             verticalArrangement = Arrangement.spacedBy(5.dp)
    9.         ){
    10.             items(deviceList!!.size){ index->
    11.                 ListItem(index, deviceList[index])
    12.             }
    13.         }
    14.     }
    15.

    ListItem：这是每个LazyColumn中每个列表的UI样式

    1.  
    2.     @Composable
    3.     fun ListItem(index: Int, blueToothDevice: BluetoothDevice){
    4.         Card(
    5.             shape = RoundedCornerShape(4.dp),
    6.             elevation = 2.dp
    7.         ) {
    8.             Row(
    9.                 modifier = Modifier
    10.                     .height(50.dp)
    11.                     .fillMaxWidth()
    12.                     .clickable {
    13.                         openDialog.value = true
    14.                         if (blueToothDevice.name == null) {
    15.                             text.value = "N/A"
    16.                         } else {
    17.                             text.value = blueToothDevice.name
    18.                         }
    19.  
    20.                         //Gatt协议连接蓝牙
    21.                         var bluetoothGatt =
    22.                             blueToothDevice.connectGatt(this@MainActivity, true, mGattCallback)
    23.                         bluetoothGatt.connect()
    24.                         Log.d(TAG, "点击了第$index 个item")
    25.                     },
    26.                 verticalAlignment = Alignment.CenterVertically,
    27.             ) {
    28.  
    29.                 Image(
    30.                     painter = painterResource(R.drawable.ic_blue),
    31.                     contentDescription = null,
    32.                     modifier = Modifier
    33.                         .fillMaxHeight()
    34.                         .padding(all = 5.dp)
    35.                 )
    36.  
    37.                 Column(
    38.                     modifier = Modifier.fillMaxWidth()
    39.                 ) {
    40.  
    41.                     if(blueToothDevice.name==null){
    42.                         Text(
    43.                             text = "N/A",
    44.                             fontWeight = FontWeight.Bold
    45.                         )
    46.                     }else{
    47.                         Text(
    48.                             text = blueToothDevice.name,
    49.                             fontWeight = FontWeight.Bold
    50.                         )
    51.                     }
    52.                     Text(
    53.                         text = blueToothDevice.address,
    54.                     )
    55.                 }
    56.  
    57.             }
    58.         }
    59.     }

    4. 蓝牙搜索，配对，连接，通信

    小编这里为了让大家方便，便将搜索，配对，连接都写在了MainActivity中了,Compose UI也在这里了，大家可以复制直接去运行

    1. package com.example.bluetoothcompose
    2.  
    3. import android.Manifest.permission.ACCESS_COARSE_LOCATION
    4. import android.Manifest.permission.ACCESS_FINE_LOCATION
    5. import android.annotation.SuppressLint
    6. import android.bluetooth.*
    7. import android.content.BroadcastReceiver
    8. import android.content.Context
    9. import android.content.Intent
    10. import android.content.IntentFilter
    11. import android.os.Bundle
    12. import android.util.Log
    13. import android.widget.Toast
    14. import androidx.activity.ComponentActivity
    15. import androidx.activity.compose.setContent
    16. import androidx.compose.foundation.Image
    17. import androidx.compose.foundation.background
    18. import androidx.compose.foundation.clickable
    19. import androidx.compose.foundation.layout.*
    20. import androidx.compose.foundation.lazy.LazyColumn
    21. import androidx.compose.foundation.shape.RoundedCornerShape
    22. import androidx.compose.material.*
    23. import androidx.compose.runtime.*
    24. import androidx.compose.ui.Alignment
    25. import androidx.compose.ui.Modifier
    26. import androidx.compose.ui.res.painterResource
    27. import androidx.compose.ui.text.font.FontWeight
    28. import androidx.compose.ui.tooling.preview.Preview
    29. import androidx.compose.ui.unit.dp
    30. import androidx.core.content.PermissionChecker.PERMISSION_GRANTED
    31. import com.example.bluetoothcompose.ui.theme.Blue
    32. import com.example.bluetoothcompose.ui.theme.BlueToothComposeTheme
    33. import com.example.bluetoothcompose.ui.theme.White
    34. import java.util.*
    35.  
    36. class MainActivity : ComponentActivity() {
    37.  
    38.     private val TAG = "yf"
    39.     private var deviceList = mutableStateListOf()
    40.     private var data = mutableListOf(
    41.         "检查设备是否支持蓝牙",
    42.         "检查设备是否开启蓝牙",
    43.         "查看已配过的蓝牙设备",
    44.         "查找蓝牙设备"
    45.     )
    46.  
    47.     var selected = mutableStateOf(0)
    48.     var openDialog = mutableStateOf(false)
    49.     var text = mutableStateOf("")
    50.  
    51.     var mGatt: BluetoothGatt? = null
    52.     var mWriter: BluetoothGattCharacteristic? = null
    53.  
    54.  
    55.  
    56.  
    57.     private var isRefresh = mutableStateOf(false)
    58.  
    59.     override fun onCreate(savedInstanceState: Bundle?) {
    60.         super.onCreate(savedInstanceState)
    61.  
    62.         setContent {
    63.             BlueToothComposeTheme {
    64.                 // A surface container using the 'background' color from the theme
    65.                 Surface(
    66.                     modifier = Modifier.fillMaxSize(),
    67.                     color = MaterialTheme.colors.background
    68.                 ) {
    69.                     MainScreen()
    70.                 }
    71.             }
    72.         }
    73.     }
    74.  
    75.     override fun onStart() {
    76.         super.onStart()
    77.  
    78.         isPermission()
    79.         registerBluetoothReceiver()
    80.     }
    81.  
    82.     //处理找到蓝牙设备和搜索完成的广播消息
    83.     var receiver: BroadcastReceiver = object : BroadcastReceiver() {
    84.         @SuppressLint("MissingPermission")
    85.         override fun onReceive(context: Context, intent: Intent) {
    86.             val action = intent.action
    87.  
    88.             //开始查找设备
    89.             when {
    90.                 BluetoothAdapter.ACTION_DISCOVERY_STARTED == action -> {
    91.                     //开始搜索
    92.                     if(deviceList!=null){
    93.                         deviceList!!.clear()
    94.                     }
    95.  
    96.                     isRefresh.value = true
    97.                 }
    98.                 BluetoothDevice.ACTION_FOUND == action -> {
    99.                     //搜到蓝牙设备
    100.                     val device =
    101.                         intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE)
    102.  
    103.                     //把搜索到的设备添加到已找到列表中，显示它的信息
    104.                     deviceList?.add(device!!)
    105.                     Log.d(TAG,"找到了: ${deviceList.size}")
    106.  
    107.                 }
    108.                 BluetoothAdapter.ACTION_DISCOVERY_FINISHED == action -> {
    109.                     //搜索完毕
    110.                     isRefresh.value = false
    111.                     when (selected.value) {
    112.                         3 -> {
    113.  
    114.                         }
    115.                         4 -> {
    116.                             Toast.makeText(this@MainActivity,"选择要配对的蓝牙设备",Toast.LENGTH_SHORT).show()
    117.  
    118.                         }
    119.                     }
    120.                 }
    121.                 BluetoothDevice.ACTION_BOND_STATE_CHANGED == action -> {
    122.                     val device =
    123.                         intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE)
    124.                     if (device == null) {
    125.                         Toast.makeText(this@MainActivity,"无设备",Toast.LENGTH_SHORT).show()
    126.  
    127.                         return
    128.                     }
    129.                     val state = intent.getIntExtra(BluetoothDevice.EXTRA_BOND_STATE, 0)
    130.                     when (state) {
    131.                         BluetoothDevice.BOND_BONDED -> {
    132.                             Toast.makeText(this@MainActivity,"已配对",Toast.LENGTH_SHORT).show()
    133.  
    134.                         }
    135.                         BluetoothDevice.BOND_BONDING -> {
    136.                             Toast.makeText(this@MainActivity,"正在配对",Toast.LENGTH_SHORT).show()
    137.  
    138.                         }
    139.                         BluetoothDevice.BOND_NONE -> {
    140.                             Toast.makeText(this@MainActivity,"未配对",Toast.LENGTH_SHORT).show()
    141.  
    142.                         }
    143.                     }
    144.                 }
    145.             }
    146.         }
    147.     }
    148.  
    149.  
    150.     //动态获取位置权限
    151.     @SuppressLint("WrongConstant")
    152.     private fun isPermission() {
    153.         if (checkSelfPermission(ACCESS_COARSE_LOCATION) !== PERMISSION_GRANTED
    154.             || checkSelfPermission(ACCESS_FINE_LOCATION) !== PERMISSION_GRANTED
    155.         ) {
    156.             requestPermissions(
    157.                 arrayOf(
    158.                     ACCESS_COARSE_LOCATION,
    159.                     ACCESS_FINE_LOCATION
    160.                 ), 200
    161.             )
    162.         }
    163.     }
    164.  
    165.     private fun registerBluetoothReceiver() {
    166.         //filter注册广播接收器
    167.         val filter = IntentFilter()
    168.  
    169.  
    170.         //蓝牙当前状态
    171.         filter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED)
    172.  
    173.  
    174.         //开始扫描蓝牙设备广播
    175.         filter.addAction(BluetoothAdapter.ACTION_DISCOVERY_STARTED)
    176.  
    177.         //找到蓝牙设备广播
    178.         filter.addAction(BluetoothDevice.ACTION_FOUND)
    179.  
    180.         //扫描蓝牙设备结束广播
    181.         filter.addAction(BluetoothAdapter.ACTION_DISCOVERY_FINISHED)
    182.  
    183.         //蓝牙设备配对状态改变广播
    184.         filter.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED)
    185.  
    186.         //设备扫描模式改变广播
    187.         filter.addAction(BluetoothAdapter.ACTION_SCAN_MODE_CHANGED)
    188.         registerReceiver(receiver, filter)
    189.     }
    190.  
    191.  
    192.     @SuppressLint("MissingPermission")
    193.     @Composable
    194.     fun MainScreen() {
    195.         var expanded = remember {
    196.             mutableStateOf(false)
    197.         }
    198.  
    199.  
    200.         Column(
    201.             modifier = Modifier.fillMaxSize()
    202.         )
    203.         {
    204.             Row(
    205.                 modifier = Modifier
    206.                     .fillMaxWidth()
    207.                     .background(Blue)
    208.                     .padding(vertical = 12.dp)
    209.                     .height(35.dp),
    210.                 verticalAlignment = Alignment.CenterVertically,
    211.                 horizontalArrangement = Arrangement.Start
    212.             ) {
    213.                 Text(
    214.                     text = "可用设备",
    215.                     modifier = Modifier
    216.                         .weight(1f)
    217.                         .offset(10.dp)
    218.                 )
    219.  
    220.                 if(isRefresh.value){
    221.                     CircularProgressIndicator(
    222.                         modifier = Modifier.size(25.dp),
    223.                         color = White
    224.                     )
    225.                 }
    226.  
    227.                 Box() {
    228.                     Icon(
    229.                         painter = painterResource(id = R.drawable.ic_setting),
    230.                         contentDescription = null,
    231.                         modifier = Modifier
    232.                             .width(50.dp)
    233.                             .fillMaxHeight()
    234.                             .clickable {
    235.                                 expanded.value = true
    236.                             },
    237.                     )
    238.  
    239.                     if(expanded.value){
    240.                         DropdownMenu(
    241.                             expanded = expanded.value,
    242.                             onDismissRequest = {
    243.                                 expanded.value = false
    244.                             }) {
    245.                             data.forEachIndexed{ index: Int, s: String ->
    246.                                 DropdownMenuItem(onClick = {
    247.                                     when (index) {
    248.                                         0 -> {
    249.                                             if(BlueToothController.isBluetoothSupport()){
    250.                                                 Toast.makeText(this@MainActivity,"本机支持蓝牙功能",Toast.LENGTH_SHORT).show()
    251.                                             }else{
    252.                                                 Toast.makeText(this@MainActivity,"本机暂不支持蓝牙功能",Toast.LENGTH_SHORT).show()
    253.                                             }
    254.                                         }
    255.                                         1 -> {
    256.                                             if(BlueToothController.isBluetoothEnabled()){
    257.                                                 Toast.makeText(this@MainActivity,"用户允许开启蓝牙",Toast.LENGTH_SHORT).show()
    258.                                             }else{
    259.                                                 Toast.makeText(this@MainActivity,"用户拒绝开启蓝牙",Toast.LENGTH_SHORT).show()
    260.                                             }
    261.                                         }
    262.                                         2 -> {
    263.                                             selected.value = 3
    264.                                             Log.d(TAG,"查看已绑定设备")
    265.                                             if(BlueToothController.isStartDiscovering()){
    266.                                                 BlueToothController.cancelFindDevice()
    267.                                             }
    268.                                             deviceList.clear()
    269.                                             for (device in BlueToothController.getBondedDeviceList()!!){
    270.                                                 deviceList.add(device!!)
    271.                                             }
    272.  
    273.                                         }
    274.                                         3 -> {
    275.                                             if(BlueToothController.isStartDiscovering()){
    276.                                                 Log.d(TAG,"停止查找")
    277.                                                 BlueToothController.cancelFindDevice()
    278.                                                 deviceList!!.clear()
    279.                                             }
    280.                                             selected.value = 4
    281.                                             BlueToothController.findDevice()
    282.                                             Log.d(TAG,"开始查找")
    283.                                         }
    284.                                     }
    285.                                     Log.d(TAG,selected.value.toString())
    286.                                     expanded.value = false
    287.                                 }) {
    288.                                     Text(text = s)
    289.                                 }
    290.                             }
    291.                         }
    292.                     }
    293.                 }
    294.             }
    295.  
    296.             DeviceListView()
    297.         }
    298.         if(openDialog.value){
    299.             AlterDialog()
    300.         }
    301.     }
    302.  
    303.     @Preview(
    304.         showBackground = true,
    305.         group = "Group1",
    306.     )
    307.     @Composable
    308.     fun DefaultPreview() {
    309.         MainScreen()
    310.     }
    311.  
    312.  
    313.     @SuppressLint("MissingPermission")
    314.     @Composable
    315.     fun DeviceListView(){
    316.         LazyColumn(
    317.             Modifier
    318.                 .fillMaxSize(),
    319.             contentPadding =  PaddingValues(5.dp,1.dp),
    320.             verticalArrangement = Arrangement.spacedBy(5.dp)
    321.         ){
    322.             items(deviceList!!.size){ index->
    323.                 ListItem(index, deviceList[index])
    324.             }
    325.         }
    326.     }
    327.  
    328.     @SuppressLint("MissingPermission")
    329.     @Composable
    330.     fun ListItem(index: Int, blueToothDevice: BluetoothDevice){
    331.         Card(
    332.             shape = RoundedCornerShape(4.dp),
    333.             elevation = 2.dp
    334.         ) {
    335.             Row(
    336.                 modifier = Modifier
    337.                     .height(50.dp)
    338.                     .fillMaxWidth()
    339.                     .clickable {
    340.                         openDialog.value = true
    341.                         if (blueToothDevice.name == null) {
    342.                             text.value = "N/A"
    343.                         } else {
    344.                             text.value = blueToothDevice.name
    345.                         }
    346.  
    347.                         //Gatt协议连接蓝牙
    348.                         var bluetoothGatt =
    349.                             blueToothDevice.connectGatt(this@MainActivity, true, mGattCallback)
    350.                         bluetoothGatt.connect()
    351.                         Log.d(TAG, "点击了第$index 个item")
    352.                     },
    353.                 verticalAlignment = Alignment.CenterVertically,
    354.             ) {
    355.  
    356.                 Image(
    357.                     painter = painterResource(R.drawable.ic_blue),
    358.                     contentDescription = null,
    359.                     modifier = Modifier
    360.                         .fillMaxHeight()
    361.                         .padding(all = 5.dp)
    362.                 )
    363.  
    364.                 Column(
    365.                     modifier = Modifier.fillMaxWidth()
    366.                 ) {
    367.  
    368.                     if(blueToothDevice.name==null){
    369.                         Text(
    370.                             text = "N/A",
    371.                             fontWeight = FontWeight.Bold
    372.                         )
    373.                     }else{
    374.                         Text(
    375.                             text = blueToothDevice.name,
    376.                             fontWeight = FontWeight.Bold
    377.                         )
    378.                     }
    379.                     Text(
    380.                         text = blueToothDevice.address,
    381.                     )
    382.                 }
    383.  
    384.             }
    385.         }
    386.     }
    387.  
    388.  
    389.     @SuppressLint("MissingPermission")
    390.     @Composable
    391.     fun AlterDialog() {
    392.             AlertDialog(
    393.                 onDismissRequest = { openDialog.value = false },
    394.                 title = { Text(text = text.value) },
    395.                 text = {
    396.                     Text(
    397.                         text = "0c 11 09 41 23 00 01 03 FF"
    398.                     )
    399.                 }, confirmButton = {
    400.                     TextButton(onClick = {
    401.                         openDialog.value = false
    402.                         sendMessage()
    403.                     }) {
    404.                         Text(text = "发送")
    405.                     }
    406.                 }, dismissButton = {
    407.                     TextButton(onClick = { openDialog.value = false }) {
    408.                         Text(text = "取消")
    409.                     }
    410.                 })
    411.     }
    412.  
    413.  
    414.     private val mGattCallback: BluetoothGattCallback = object : BluetoothGattCallback() {
    415.         @SuppressLint("MissingPermission")
    416.         override fun onConnectionStateChange(gatt: BluetoothGatt, status: Int, newState: Int) {
    417.             //连接成功
    418.             if (newState == BluetoothProfile.STATE_CONNECTED) {
    419.                 //进行服务发现
    420.                 gatt.discoverServices()
    421.                 Log.d(TAG, "连接成功")
    422.             } else if (newState == BluetoothProfile.STATE_DISCONNECTED) {
    423.                 //连接断开，处理断开逻辑
    424.                 Log.d(TAG, "连接断开")
    425.             }
    426.         }
    427.  
    428.         @SuppressLint("MissingPermission")
    429.         override fun onServicesDiscovered(gatt: BluetoothGatt, status: Int) {
    430.             Log.d(TAG, "onServicesDiscovered : $status ==>> $gatt")
    431.  
    432.             //发现服务成功，处理服务和特征值
    433.             if (status == BluetoothGatt.GATT_SUCCESS) {
    434.                 //发送消息
    435.                 mGatt = gatt
    436.                 val service =
    437.                     gatt.getService(UUID.fromString("0000180a-0000-1000-8000-00805F9B34FB"))
    438.                 mWriter =
    439.                     service.getCharacteristic(UUID.fromString("00002ad9-0000-1000-8000-00805F9B34FB"))
    440.  
    441.                 //打开消息通知
    442.                 mGatt!!.setCharacteristicNotification(mWriter, true)
    443.                 val descriptor: BluetoothGattDescriptor =
    444.                     mWriter!!.getDescriptor(UUID.fromString("00002902-0000-1000-8000-00805f9b34fb"))
    445.                 descriptor.value = BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE
    446.                 mGatt!!.writeDescriptor(descriptor)
    447.  
    448.             } else {
    449.                 Log.d(TAG, "发现服务失败")
    450.             }
    451.         }
    452.  
    453.         override fun onCharacteristicRead(
    454.             gatt: BluetoothGatt,
    455.             characteristic: BluetoothGattCharacteristic,
    456.             status: Int
    457.         ) {
    458.             Log.e(TAG, "onCharacteristicRead $status")
    459.             //读取特征成功，处理特征值
    460.             if (status == BluetoothGatt.GATT_SUCCESS) {
    461.             }
    462.         }
    463.  
    464.         override fun onCharacteristicWrite(
    465.             gatt: BluetoothGatt,
    466.             characteristic: BluetoothGattCharacteristic,
    467.             status: Int
    468.         ) {
    469.             Log.e(TAG, "onCharacteristicWrite $status")
    470.             //写入特征成功
    471.             if (status == BluetoothGatt.GATT_SUCCESS) {
    472.                 Log.d(TAG, "发送成功")
    473.             } else {
    474.                 Log.d(TAG, "发送失败")
    475.             }
    476.         }
    477.  
    478.         override fun onCharacteristicChanged(
    479.             gatt: BluetoothGatt,
    480.             characteristic: BluetoothGattCharacteristic
    481.         ) {
    482.  
    483.             //接收到数据
    484.             val data = characteristic.value
    485.             //处理接收到的数据
    486.             Log.d(TAG, "Received data: " + bytesToHexFun2(data))
    487.         }
    488.  
    489.         override fun onDescriptorRead(
    490.             gatt: BluetoothGatt,
    491.             descriptor: BluetoothGattDescriptor,
    492.             status: Int
    493.         ) {
    494.             super.onDescriptorRead(gatt, descriptor, status)
    495.         }
    496.  
    497.         override fun onDescriptorWrite(
    498.             gatt: BluetoothGatt,
    499.             descriptor: BluetoothGattDescriptor,
    500.             status: Int
    501.         ) {
    502.             super.onDescriptorWrite(gatt, descriptor, status)
    503.         }
    504.  
    505.         override fun onReliableWriteCompleted(gatt: BluetoothGatt, status: Int) {
    506.             super.onReliableWriteCompleted(gatt, status)
    507.         }
    508.  
    509.         override fun onReadRemoteRssi(gatt: BluetoothGatt, rssi: Int, status: Int) {
    510.             super.onReadRemoteRssi(gatt, rssi, status)
    511.         }
    512.  
    513.         override fun onMtuChanged(gatt: BluetoothGatt, mtu: Int, status: Int) {
    514.             super.onMtuChanged(gatt, mtu, status)
    515.         }
    516.  
    517.         override fun onServiceChanged(gatt: BluetoothGatt) {
    518.             super.onServiceChanged(gatt)
    519.         }
    520.  
    521.         override fun onPhyUpdate(gatt: BluetoothGatt, txPhy: Int, rxPhy: Int, status: Int) {
    522.             super.onPhyUpdate(gatt, txPhy, rxPhy, status)
    523.         }
    524.  
    525.         override fun onPhyRead(gatt: BluetoothGatt, txPhy: Int, rxPhy: Int, status: Int) {
    526.             super.onPhyRead(gatt, txPhy, rxPhy, status)
    527.         }
    528.     }
    529.  
    530.  
    531.     private fun bytesToHexFun2(bytes: ByteArray): String? {
    532.         var result = 0
    533.         for (i in bytes.indices) {
    534.             result += bytes[i]
    535.         }
    536.         return byte2Hex((result.inv() and 0xFF).toByte())
    537.     }
    538.     fun byte2Hex(inByte: Byte?): String //1字节转2个Hex字符
    539.     {
    540.         return String.format("%02x", inByte).toUpperCase()
    541.     }
    542.  
    543.  
    544.     @SuppressLint("MissingPermission")
    545.     fun sendMessage(){
    546.         if (null == mWriter) {
    547.             Log.e("yf123", "ble：发送失败：null == writer !!!!")
    548.         } else {
    549.             mWriter!!.value = byteArrayOf(
    550.                 0x0c.toByte(),
    551.                 0x11.toByte(),
    552.                 0x09.toByte(),
    553.                 0x41.toByte(),
    554.                 0x23.toByte(),
    555.                 0x00.toByte(),
    556.                 0x01.toByte(),
    557.                 0x03.toByte(),
    558.                 0xFF.toByte()
    559.             )
    560.             mGatt!!.writeCharacteristic(mWriter)
    561.         }
    562.     }
    563.  
    564. }
    565.  
    566.  
    567.

    到此为止，我们的程序就到这里了，蓝牙搜索，配对，连接，通信便已经成功实现了，大家可以把代码copy一下拿去运行，具体效果演示图在文章最上方，大家还想了解更多关于Android蓝牙开发的可以继续看我下一篇给大家的分享

  • 相关阅读:
    docker部署redis
    发展新能源汽车加快充换电基础设施建设实施方案-安科瑞黄安南
    java游戏制作-拼图游戏
    面试题整理
    玩转Vue3之shallowRef和shallowReactive
    二维码怎么分解成链接？线上快速解码教学
    PreScan快速入门到精通第三十讲基于PreScan进行摄像头传感器仿真
    复试（服务器测试实习生）、一面
    每日挠头算法题（十五）螺旋矩阵II
    订水商城实战教程08-轮播图
  • 原文地址：https://blog.csdn.net/Ai1114/article/details/132294425