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

Android 蓝牙开发（ 三 ）_蓝牙 app demo

作者：小小林熬夜学编程 | 2024-04-27 08:39:34

赞

踩

蓝牙 app demo

前言

前两篇文章给大家分享了Android蓝牙的基础开发，用的都是JAVA写的，有人希望我用Kotlin语言来写，因为目前使用Kotlin开发Android的人越来越多了，那今天小编今天就先分享一下Kotlin版的蓝牙开发教程吧

Android蓝牙开发步骤

1.检查设备是否支持蓝牙

在应用程序中，你需要首先检查设备是否支持蓝牙。你可以在AndroidManifest.xml文件中声明必需的蓝牙权限，并使用BluetoothAdapter类来查询设备是否支持蓝牙

  1. val bluetoothAdapter = BluetoothAdapter.getDefaultAdapter()
  2. if (bluetoothAdapter == null) {
  3.     // 该设备不支持蓝牙
  4. } else {
  5.     // 该设备支持蓝牙
  6. }

2.打开蓝牙

在你的应用程序中，你需要引导用户打开他们的蓝牙功能。你可以使用ACTION_REQUEST_ENABLE活动提供一个请求

  1. if (!bluetoothAdapter.isEnabled()) {
  2.     //如果该设备蓝牙未开启
  3.  
  4.     Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
  5.     startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT);
  6. }

3.扫描可用蓝牙设备

一旦蓝牙已启用，你就可以开始扫描设备了。你可以使用BluetoothAdapter类和BluetoothDevice类执行扫描操作

bluetoothAdapter.startDiscovery();

可以使用BroadcastReceiver类来接收扫描结果：

  1. private val broadcastReceiver: BroadcastReceiver = object : BroadcastReceiver() {
  2.     override fun onReceive(context: Context?, intent: Intent) {
  3.         val action = intent.action
  4.         if (BluetoothDevice.ACTION_FOUND == action) {
  5.             val device =
  6.                 intent.getParcelableExtra<BluetoothDevice>(BluetoothDevice.EXTRA_DEVICE)
  7.             //该设备成功搜索到蓝牙设备
  8.         }
  9.     }
  10. }

4.选择蓝牙并与其配对成功

通过BluetoothAdapter对象，你可以来进行蓝牙配对。你需要将BluetoothDevice类实例化并使用其connect()方法来建立连接

  1. var mBluetoothAdapter: BluetoothAdapter
  2. val device: BluetoothDevice = mBluetoothAdapter.getRemoteDevice(address)
  3. device.createBond()

 5.选择蓝牙并与其建立连接

通过BluetoothDevice对象，你可以使用BluetoothSocket类来建立蓝牙连接。你需要将BluetoothSocket类实例化并使用其connect()方法来建立连接

  1. val socket: BluetoothSocket = device.createRfcommSocketToServiceRecord(MY_UUID)
  2. socket.connect()

6.数据传输

一旦蓝牙连接已建立，你可以使用BluetoothSocket的getInputStream()和getOutputStream()方法来发送和接收数据

  1. val inputStream: InputStream = socket.getInputStream()
  2. val outputStream: OutputStream = socket.getOutputStream()

以上就是Android蓝牙开发的基本流程，需要注意的是在实际开发中，还需要处理蓝牙连接的断开、多设备连接等复杂情况

7.断开蓝牙连接并关闭蓝牙

  1. val bluetoothAdapter = BluetoothAdapter.getDefaultAdapter()
  2. bluetoothAdapter.disable() //关闭蓝牙

注意：Android提供了蓝牙模块的管理工具BluetoothAdapter（蓝牙适配器）

BluetoothAdapter类的一些常用方法说明：

1. enable() - 开启蓝牙

2. disable() - 关闭蓝牙

3. startDiscovery() - 开始搜索设备

4. cancelDiscovery() - 取消搜索设备

5. getBondedDevices() - 获取已配对的设备列表

6. getRemoteDevice(String address) - 获取远程设备对象

7. setState(int state) - 设置蓝牙状态

8. setScanMode(int mode) - 设置扫描模式

9. getScanMode() - 获取扫描模式

10. getName() - 获取本地蓝牙设备名称

11. setName(String name) - 设置本地蓝牙设备名称

12. getAddress() - 获取本地蓝牙设备地址

13. isDiscovering：判断是否正在搜索周围的蓝牙设备

14. getBluetoothLeScanner() - 获取BluetoothLeScanner对象

15. getProfileProxy(Context context, BluetoothProfile.ServiceListener listener, int profile) - 获取BluetoothProfile对象

16. closeProfileProxy(int profile, BluetoothProfile proxy) - 关闭BluetoothProfile对象的连接

Android蓝牙开发效果演示

1. 声明蓝牙权限

新建一个Android项目，然后在AndroidManifest清单文件里声明相关的权限

2. 动态获取定位权限

  1. package com.example.bluetoothproject
  2.  
  3. import android.Manifest
  4. import android.annotation.SuppressLint
  5. import android.content.pm.PackageManager
  6. import android.os.Bundle
  7. import androidx.appcompat.app.AppCompatActivity
  8.  
  9.  
  10. class MainActivity : AppCompatActivity() {
  11.     override fun onCreate(savedInstanceState: Bundle?) {
  12.         super.onCreate(savedInstanceState)
  13.         setContentView(R.layout.activity_main)
  14.  
  15.         isPermission()
  16.     }
  17.  
  18.     //动态获取位置权限
  19.     @SuppressLint("NewApi")
  20.     private fun isPermission() {
  21.         if (checkSelfPermission(Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED
  22.             || checkSelfPermission(Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED
  23.         ) {
  24.             requestPermissions(
  25.                 arrayOf(
  26.                     Manifest.permission.ACCESS_COARSE_LOCATION,
  27.                     Manifest.permission.ACCESS_FINE_LOCATION
  28.                 ), 200
  29.             )
  30.         }
  31.     }
  32. }
  33.

运行效果：

3. 判断该设备是否支持蓝牙功能

  1. package com.example.bluetoothproject
  2.  
  3. import android.bluetooth.BluetoothAdapter
  4. import android.os.Bundle
  5. import android.widget.Toast
  6. import androidx.appcompat.app.AppCompatActivity
  7.  
  8.  
  9. class MainActivity : AppCompatActivity() {
  10.     private var mBluetoothAdapter: BluetoothAdapter? = null
  11.  
  12.     override fun onCreate(savedInstanceState: Bundle?) {
  13.         super.onCreate(savedInstanceState)
  14.         setContentView(R.layout.activity_main)
  15.  
  16.         //初始化蓝牙适配器
  17.         mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter()
  18.         if (isBluetoothSupport()) {
  19.             Toast.makeText(this@MainActivity, "该设备支持蓝牙功能", Toast.LENGTH_SHORT).show()
  20.         } else {
  21.             Toast.makeText(this@MainActivity, "该设备不支持蓝牙功能", Toast.LENGTH_SHORT).show()
  22.         }
  23.     }
  24.  
  25.  
  26.     //判断该设备是否支持蓝牙功能
  27.     private fun isBluetoothSupport(): Boolean {
  28.         return when (mBluetoothAdapter) {
  29.             null -> {
  30.                 false
  31.             }
  32.             else -> {
  33.                 true
  34.             }
  35.         }
  36.     }
  37. }
  38.

运行效果：

4. 判断本机是否开启蓝牙

  1. package com.example.bluetoothproject
  2.  
  3. import android.annotation.SuppressLint
  4. import android.bluetooth.BluetoothAdapter
  5. import android.content.Intent
  6. import android.os.Bundle
  7. import android.widget.Toast
  8. import androidx.appcompat.app.AppCompatActivity
  9.  
  10.  
  11. class MainActivity : AppCompatActivity() {
  12.     private var mBluetoothAdapter: BluetoothAdapter? = null
  13.  
  14.     @SuppressLint("MissingPermission")
  15.     override fun onCreate(savedInstanceState: Bundle?) {
  16.         super.onCreate(savedInstanceState)
  17.         setContentView(R.layout.activity_main)
  18.  
  19.         //初始化蓝牙适配器
  20.         mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter()
  21.  
  22.  
  23.         //判断蓝牙是否打开
  24.         if (!isBluetoothEnabled()) {
  25.             //如果蓝牙未开启，则申请打开蓝牙
  26.             val enableBluetoothIntent = Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE)
  27.             startActivityForResult(enableBluetoothIntent, RESULT_CANCELED)
  28.         } else {
  29.         }
  30.     }
  31.  
  32.  
  33.     /**
  34.      * 检查该设备蓝牙是否开启
  35.      */
  36.     private fun isBluetoothEnabled(): Boolean {
  37.         return when {
  38.             mBluetoothAdapter!!.isEnabled -> {
  39.                 true
  40.             }
  41.             else -> {
  42.                 false
  43.             }
  44.         }
  45.     }
  46.  
  47.  
  48.     override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
  49.         super.onActivityResult(requestCode, resultCode, data)
  50.         if (requestCode == RESULT_CANCELED) {
  51.             if (resultCode == RESULT_OK) {
  52.                 // 蓝牙已成功开启
  53.                 Toast.makeText(this@MainActivity, "用户已开启蓝牙", Toast.LENGTH_SHORT).show()
  54.             } else {
  55.                 // 用户取消了蓝牙开启请求
  56.                 Toast.makeText(this@MainActivity, "用户已拒绝开启蓝牙", Toast.LENGTH_SHORT).show()
  57.             }
  58.         }
  59.     }
  60. }
  61.

运行效果：

5. 获取设备已配对过的蓝牙设备

  1. package com.example.bluetoothproject
  2.  
  3. import android.Manifest
  4. import android.annotation.SuppressLint
  5. import android.bluetooth.BluetoothAdapter
  6. import android.content.pm.PackageManager
  7. import android.os.Bundle
  8. import android.util.Log
  9. import androidx.appcompat.app.AppCompatActivity
  10.  
  11.  
  12. class MainActivity : AppCompatActivity() {
  13.     private var mBluetoothAdapter: BluetoothAdapter? = null
  14.  
  15.  
  16.     @SuppressLint("MissingPermission", "MissingInflatedId")
  17.     override fun onCreate(savedInstanceState: Bundle?) {
  18.         super.onCreate(savedInstanceState)
  19.         setContentView(R.layout.activity_main)
  20.  
  21.         //初始化蓝牙适配器
  22.         mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter()
  23.  
  24.         //判断是否有访问位置的权限，没有权限，直接申请位置权限
  25.         isPermission()
  26.         getPairedDevices()
  27.     }
  28.  
  29.     //动态获取位置权限
  30.     @SuppressLint("NewApi")
  31.     private fun isPermission() {
  32.         if (checkSelfPermission(Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED
  33.             || checkSelfPermission(Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED
  34.         ) {
  35.             requestPermissions(
  36.                 arrayOf(
  37.                     Manifest.permission.ACCESS_COARSE_LOCATION,
  38.                     Manifest.permission.ACCESS_FINE_LOCATION
  39.                 ), 200
  40.             )
  41.         }
  42.     }
  43.  
  44.  
  45.     @SuppressLint("MissingPermission")
  46.     private fun getPairedDevices() {
  47.         val bluetoothAdapter = BluetoothAdapter.getDefaultAdapter()
  48.         val pairedDevices = bluetoothAdapter.bondedDevices
  49.         if (pairedDevices.size > 0) {
  50.             for (device in pairedDevices) {
  51.                 val deviceName = device.name
  52.                 val deviceHardwareAddress = device.address
  53.                 Log.d("MainActivity", "设备名：$deviceName\n地址：$deviceHardwareAddress")
  54.             }
  55.         }
  56.     }
  57.  
  58. }
  59.

运行效果：

6. 搜索蓝牙设备

  1. package com.example.bluetoothproject
  2.  
  3. import android.Manifest
  4. import android.annotation.SuppressLint
  5. import android.bluetooth.BluetoothAdapter
  6. import android.bluetooth.BluetoothDevice
  7. import android.content.BroadcastReceiver
  8. import android.content.Context
  9. import android.content.Intent
  10. import android.content.IntentFilter
  11. import android.content.pm.PackageManager
  12. import android.os.Bundle
  13. import android.util.Log
  14. import android.widget.Toast
  15. import androidx.appcompat.app.AppCompatActivity
  16.  
  17.  
  18. class MainActivity : AppCompatActivity() {
  19.     private var mBluetoothAdapter: BluetoothAdapter? = null
  20.  
  21.  
  22.     @SuppressLint("MissingPermission", "MissingInflatedId")
  23.     override fun onCreate(savedInstanceState: Bundle?) {
  24.         super.onCreate(savedInstanceState)
  25.         setContentView(R.layout.activity_main)
  26.  
  27.         //初始化蓝牙适配器
  28.         mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter()
  29.  
  30.         //判断是否有访问位置的权限，没有权限，直接申请位置权限
  31.         isPermission()
  32.         mBluetoothAdapter!!.startDiscovery()
  33.         registerBluetoothReceiver()
  34.     }
  35.  
  36.     //动态获取位置权限
  37.     @SuppressLint("NewApi")
  38.     private fun isPermission() {
  39.         if (checkSelfPermission(Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED
  40.             || checkSelfPermission(Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED
  41.         ) {
  42.             requestPermissions(
  43.                 arrayOf(
  44.                     Manifest.permission.ACCESS_COARSE_LOCATION,
  45.                     Manifest.permission.ACCESS_FINE_LOCATION
  46.                 ), 200
  47.             )
  48.         }
  49.     }
  50.  
  51.  
  52.     private fun registerBluetoothReceiver() {
  53.         //filter注册广播接收器
  54.         val filter = IntentFilter()
  55.  
  56.  
  57.         //蓝牙当前状态
  58.         filter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED)
  59.  
  60.  
  61.         //开始扫描蓝牙设备广播
  62.         filter.addAction(BluetoothAdapter.ACTION_DISCOVERY_STARTED)
  63.  
  64.         //找到蓝牙设备广播
  65.         filter.addAction(BluetoothDevice.ACTION_FOUND)
  66.  
  67.         //扫描蓝牙设备结束广播
  68.         filter.addAction(BluetoothAdapter.ACTION_DISCOVERY_FINISHED)
  69.  
  70.         //蓝牙设备配对状态改变广播
  71.         filter.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED)
  72.  
  73.         //设备扫描模式改变广播
  74.         filter.addAction(BluetoothAdapter.ACTION_SCAN_MODE_CHANGED)
  75.         registerReceiver(receiver, filter)
  76.     }
  77.  
  78.  
  79.     //处理找到蓝牙设备和搜索完成的广播消息
  80.     var receiver: BroadcastReceiver = object : BroadcastReceiver() {
  81.         @SuppressLint("MissingPermission")
  82.         override fun onReceive(context: Context?, intent: Intent) {
  83.             val action = intent.action
  84.  
  85.             //开始查找设备
  86.             if (BluetoothAdapter.ACTION_DISCOVERY_STARTED == action) {
  87.                 Log.d("", "开始查找")
  88.             } else if (BluetoothDevice.ACTION_FOUND == action) {
  89.                 //搜到蓝牙设备
  90.                 val device =
  91.                     intent.getParcelableExtra<BluetoothDevice>(BluetoothDevice.EXTRA_DEVICE)
  92.  
  93.                 //把搜索到的设备添加到已找到列表中，显示它的信息
  94.                 Log.d(
  95.                     "", """
  96.                         设备名：${device!!.name}
  97.                         地址：${device.address}
  98.                         """.trimIndent()
  99.                 )
  100.             } else if (BluetoothAdapter.ACTION_DISCOVERY_FINISHED == action) {
  101.                 //搜索完毕
  102.                 Toast.makeText(this@MainActivity, "选择要配对的蓝牙设备", Toast.LENGTH_SHORT).show()
  103.                 Log.d("", "查找结束")
  104.             }
  105.         }
  106.     }
  107.  
  108. }
  109.

运行效果：

7. 配对蓝牙设备

  1. package com.example.bluetoothdemo;
  2.  
  3. import androidx.appcompat.app.AppCompatActivity;
  4.  
  5. import android.Manifest;
  6. import android.annotation.SuppressLint;
  7. import android.bluetooth.BluetoothAdapter;
  8. import android.bluetooth.BluetoothDevice;
  9. import android.content.BroadcastReceiver;
  10. import android.content.Context;
  11. import android.content.Intent;
  12. import android.content.IntentFilter;
  13. import android.content.pm.PackageManager;
  14. import android.os.Bundle;
  15. import android.util.Log;
  16. import android.widget.Toast;
  17.  
  18. import java.util.Set;
  19.  
  20. public class MainActivity extends AppCompatActivity {
  21.     package com.example.bluetoothproject
  22.  
  23. import android.Manifest
  24. import android.annotation.SuppressLint
  25. import android.bluetooth.BluetoothAdapter
  26. import android.content.pm.PackageManager
  27. import android.os.Bundle
  28. import android.util.Log
  29. import androidx.appcompat.app.AppCompatActivity
  30.  
  31.  
  32. class MainActivity : AppCompatActivity() {
  33.     private var mBluetoothAdapter: BluetoothAdapter? = null
  34.  
  35.  
  36.     @SuppressLint("MissingPermission", "MissingInflatedId")
  37.     override fun onCreate(savedInstanceState: Bundle?) {
  38.         super.onCreate(savedInstanceState)
  39.         setContentView(R.layout.activity_main)
  40.  
  41.         //初始化蓝牙适配器
  42.         mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter()
  43.  
  44.         //判断是否有访问位置的权限，没有权限，直接申请位置权限
  45.         isPermission()
  46.         getPairedDevices()
  47.     }
  48.  
  49.     //动态获取位置权限
  50.     @SuppressLint("NewApi")
  51.     private fun isPermission() {
  52.         if (checkSelfPermission(Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED
  53.             || checkSelfPermission(Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED
  54.         ) {
  55.             requestPermissions(
  56.                 arrayOf(
  57.                     Manifest.permission.ACCESS_COARSE_LOCATION,
  58.                     Manifest.permission.ACCESS_FINE_LOCATION
  59.                 ), 200
  60.             )
  61.         }
  62.     }
  63.  
  64.  
  65.     @SuppressLint("MissingPermission")
  66.     private fun getPairedDevices() {
  67.         val bluetoothAdapter = BluetoothAdapter.getDefaultAdapter()
  68.         val pairedDevices = bluetoothAdapter.bondedDevices
  69.         if (pairedDevices.size > 0) {
  70.             var i = 0
  71.             for (device in pairedDevices) {
  72.                 i++
  73.                 if (i == pairedDevices.size) {
  74.                     device.createBond()
  75.                     Log.d("", "本机与另一个蓝牙设备" + device.name + "成功配对")
  76.                 }
  77.                 val deviceName = device.name
  78.                 val deviceHardwareAddress = device.address
  79.                 Log.d("", "设备名：$deviceName\n地址：$deviceHardwareAddress")
  80.             }
  81.         }
  82.     }
  83. }
  84.  
  85.  
  86.  
  87.  
  88. }

运行效果：

这一篇文章就先分享到这里，大家可以把代码复制一下去运行；下一篇给大家分享一下Kotlin+Compose蓝牙项目实战用法

Android蓝牙开发注意事项：

  1. 确保设备支持蓝牙：在开发之前，请确保您的设备支持蓝牙。大多数现代智能手机和平板电脑都支持蓝牙。

  2. 获取必要的权限：在开发蓝牙应用之前，您需要获取适当的权限。例如，您需要请求“android.permission.BLUETOOTH”权限，以便您的应用程序可以使用蓝牙。

  3. 确定您需要的蓝牙配置类型：Android提供了两种不同的蓝牙配置类型：经典蓝牙和低功耗蓝牙。使用低功耗蓝牙可以延长设备电池寿命，但需要Android 4.3（API level 18）或更高版本。

  4. 确保您的应用程序与其他应用程序兼容：在您的应用程序中使用蓝牙之前，请确保它与其他应用程序兼容。如果您的应用程序和其他应用程序同时使用蓝牙，可能会导致冲突和不稳定的行为。

  5. 使用正确的蓝牙协议：在开发蓝牙应用程序时，您需要确保使用正确的蓝牙协议。不同的设备和应用程序可能使用不同的蓝牙协议，因此您需要确定您的应用程序需要使用哪些协议。

  6. 处理错误和异常：在使用蓝牙时，可能会出现错误和异常。要确保您的应用程序具有适当的错误处理和异常处理代码，以确保它可以在出现问题时正确地处理蓝牙连接。

  7. 调试您的应用程序：在开发蓝牙应用程序时，请确保使用适当的调试工具。Android Studio提供了一些内置的调试工具，用于诊断和修复蓝牙连接问题。

  8. 避免使用已知的蓝牙错误：在使用蓝牙时，可能会出现许多已知的错误。要避免这些错误，请编写适当的代码，以确保您的应用程序可以正确处理这些错误。

需要注意的是，蓝牙开发需要特别注意电量和性能问题，对于频繁的蓝牙搜索、连接和数据传输等操作，应尽量减少或优化，避免对设备电量和性能造成过大的影响。

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

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

  

闽ICP备14008679号