Unity Android 之获取蓝牙Bluetooth 的状态，设置的蓝牙Bluetooth 的开关状态，并监听蓝牙Bluetooth 的状态变化方法整理

约定不等于承诺〃 2022-11-30 15:58 930阅读 0赞

![20200825111221117.png][]

# Unity Android 之 获取蓝牙Bluetooth 的状态，设置的蓝牙Bluetooth 的开关状态，并监听蓝牙Bluetooth 的状态变化方法整理 #

**目录**

Unity Android 之 获取蓝牙Bluetooth 的状态，设置的蓝牙Bluetooth 的开关状态，并监听蓝牙Bluetooth 的状态变化方法整理

一、简单介绍

二、实现原理

三、注意事项

四、效果预览

五、实现步骤

Android 端：

Unity 端

六、关键代码

Android 端

Unity 端

--------------------

## 一、简单介绍 ##

Unity Android 开发上会用到的技术简单整理，方便自己日后查看，能帮助到大家就更好了。

本节介绍，Unity 开发中，把从 Android 获取手机设备的蓝牙Bluetooth的状态，并设置蓝牙Bluetooth开关，监听蓝牙Bluetooth的状态变化的方法整理封装给Unity调用，方法不唯一，欢迎指正。

## 二、实现原理 ##

1、获取蓝牙适配器 BluetoothAdapter.getDefaultAdapter()

2、bluetoothAdapter.isEnabled() 获取蓝牙的状态

3、bluetoothAdapter.enable()/bluetoothAdapter.disable() 设置蓝牙开关状态

4、使用广播监听 BluetoothAdapter.ACTION\_STATE\_CHANGED 蓝牙状态变化

5、打包成 aar ，Unity 调用 aar 的封装好的接口

## 三、注意事项 ##

1、添加蓝牙权限

> <uses-permission android:name="android.permission.BLUETOOTH"/>
> 
> <uses-permission android:name="android.permission.BLUETOOTH\_ADMIN"/>

## 四、效果预览 ##

![20200825112206219.gif][]

## 五、实现步骤 ##

### Android 端： ###

1、新建一个Android Library 模块，其他默认设置就好

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70][]

2、在模块中新建两个脚本，BluetoothStateUtil 封装各个功能，BluetoothStateInterface 一个接口函数，蓝牙状态变化的接口

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 1][]

3、脚本编辑 OK，Build - Make Module ‘xxxx’，打包 aar

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 2][]

4、打包成功，build 文件夹outputs/aar中就会 有对应的 aar 生成

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 3][]

### Unity 端 ###

1、把 Android 打包的 aar 导入 Unity

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 4][]

2、在场景中布局UI，Toggle 显示设置 蓝牙状态

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 5][]

3、在 Unity工程中，新建脚本，编辑对应功能

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 6][]

4、把 TestBluetoothStateWrapper 挂载到场景中，并对应赋值

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 7][]

5、运行场景，没有问题，即可打包到真机上测试

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 8][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 9][]

6、真机上的测试效果如上

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 10][]

## 六、关键代码 ##

### Android 端 ###

1、BluetoothStateUtil

package com.example.bluetoothstatewrapper;
    
    import android.app.Activity;
    import android.bluetooth.BluetoothAdapter;
    import android.bluetooth.BluetoothDevice;
    import android.content.BroadcastReceiver;
    import android.content.Context;
    import android.content.Intent;
    import android.content.IntentFilter;
    import android.util.Log;
    import android.widget.Toast;
    
    public class BluetoothStateUtil {
    
        private static final String TAG = "Main_BluetoothStateUtil";
    
        private BluetoothAdapter bluetoothAdapter;
        private BluetoothStateBroadcastReceive mReceive;
        private Context mContext;
        private BluetoothStateInterface mBluetoothStateInterface;
    
        /**
         * 初始化
         */
        public void Init(BluetoothStateInterface bluetoothStateInterface){
    
            // 获得蓝牙适配器对象
            bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
            mContext = getActivity();
            mBluetoothStateInterface = bluetoothStateInterface;
        }
    
        /**
         * 获取蓝牙状态
         * @return
         */
        public boolean getBlueToothState() {
            // 获取蓝牙状态
            return bluetoothAdapter.isEnabled();
        }
    
        /**
         * 开启蓝牙
         * @return
         */
        public boolean openBlueTooth() {
            if (getBlueToothState()) return true;
            // 打开蓝牙
            return bluetoothAdapter.enable();
        }
    
        /**
         * 关闭蓝牙
         * @return
         */
        public boolean colseBlueTooth() {
            if (!getBlueToothState()) return true;
            // 关闭蓝牙
            return bluetoothAdapter.disable();
        }
    
        // 调用系统的请求打开蓝牙
        public void gotoSystem(Context context){
            Intent intent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
            context.startActivity(intent);
        }
    
        /**
         * 注册监听蓝牙变化
         */
        public void registerBluetoothReceiver(){
            if(mReceive == null){
                mReceive = new BluetoothStateBroadcastReceive();
            }
            IntentFilter intentFilter = new IntentFilter();
            intentFilter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED);
            intentFilter.addAction(BluetoothDevice.ACTION_ACL_CONNECTED);
            intentFilter.addAction(BluetoothDevice.ACTION_ACL_DISCONNECTED);
            intentFilter.addAction("android.bluetooth.BluetoothAdapter.STATE_OFF");
            intentFilter.addAction("android.bluetooth.BluetoothAdapter.STATE_ON");
            mContext.registerReceiver(mReceive, intentFilter);
        }
    
        /**
         * 取消监听蓝牙变化
         */
        public void unregisterBluetoothReceiver(){
            if(mReceive != null){
                mContext.unregisterReceiver(mReceive);
                mReceive = null;
            }
        }
    
        /**
         * 蓝牙状态变化监听
         */
        class BluetoothStateBroadcastReceive extends BroadcastReceiver {
    
            @Override
            public void onReceive(Context context, Intent intent) {
                String action = intent.getAction();
                BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
                switch (action){
                    case BluetoothDevice.ACTION_ACL_CONNECTED:
                        //Toast.makeText(context , "蓝牙设备:" + device.getName() + "已连接", Toast.LENGTH_SHORT).show();
                        Log.i(TAG, "onReceive: "+"蓝牙设备:" + device.getName() + "已连接");
                        break;
                    case BluetoothDevice.ACTION_ACL_DISCONNECTED:
                        //Toast.makeText(context , "蓝牙设备:" + device.getName() + "已断开", Toast.LENGTH_SHORT).show();
                        Log.i(TAG, "onReceive: "+"蓝牙设备:" + device.getName() + "已断开");
                        break;
                    case BluetoothAdapter.ACTION_STATE_CHANGED:
                        int blueState = intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, 0);
                        switch (blueState){
                            case BluetoothAdapter.STATE_OFF:
                                //Toast.makeText(context , "蓝牙已关闭", Toast.LENGTH_SHORT).show();
                                Log.i(TAG, "onReceive: "+"蓝牙已关闭:" );
                                mBluetoothStateInterface.onBluetoothStateOFF();
                                break;
                            case BluetoothAdapter.STATE_ON:
                                //Toast.makeText(context , "蓝牙已开启"  , Toast.LENGTH_SHORT).show();
                                Log.i(TAG, "onReceive: "+"蓝牙已开启:");
                                mBluetoothStateInterface.onBluetoothStateON();
                                break;
                        }
                        break;
                }
            }
        }
    
    
        // 设置一个 Activity 参数
        private Activity _unityActivity;
    
        // 通过反射获取 Unity 的 Activity 的上下文
        Activity getActivity(){
    
            if(null == _unityActivity){
    
                try{
    
                    Class<?> classtype = Class.forName("com.unity3d.player.UnityPlayer");
    
                    Activity activity = (Activity) classtype.getDeclaredField("currentActivity").get(classtype);
    
                    _unityActivity = activity;
    
                }catch (ClassNotFoundException e){
    
                    e.printStackTrace();
    
                }catch (IllegalAccessException e){
    
                    e.printStackTrace();
    
                }catch (NoSuchFieldException e){
    
                    e.printStackTrace();
    
                }
    
            }
    
            return _unityActivity;
    
        }
    }

2、BluetoothStateInterface

package com.example.bluetoothstatewrapper;
    
    public interface BluetoothStateInterface {
    
        void onBluetoothStateON();
        void onBluetoothStateOFF();
    
    }

3、AndroidManifest.xml

### Unity 端 ###

1、BluetoothStateWrapper

using System;
    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    namespace AndroidWrapper { 
    
        /// <summary>
        /// 蓝牙状态封装
        /// 使用说明
        /// 1、首先初始化，绑定监听事件
        /// 2、可获取蓝牙状态，设置蓝牙状态
        /// 3、获得监听结果
        /// </summary>
        public class BluetoothStateWrapper : MonoSingleton<BluetoothStateWrapper>
        {
    
            /// <summary>
            /// 初始化
            /// </summary>
            /// <param name="VoiceVolumnChangedListener"></param>
            public void Init(Action OnBluetoothStateONListener, Action OnBluetoothStateOFFListener)
            {
    
    #if UNITY_EDITOR
    #else
    
                MAndroidJavaObject.Call("Init",new BluetoothStateInterface(OnBluetoothStateONListener, OnBluetoothStateOFFListener));
                registerBluetoothReceiver();
    #endif
    
            }
    
            /// <summary>
            /// 获得蓝牙状态
            /// </summary>
            /// <returns></returns>
            public bool getBlueToothState()
            {
                
                return MAndroidJavaObject.Call<bool>("getBlueToothState");
            }
    
            /// <summary>
            /// 开启蓝牙
            /// </summary>
            /// <returns></returns>
            public bool openBlueTooth()
            {
                
                return MAndroidJavaObject.Call<bool>("openBlueTooth");
            }
    
            /// <summary>
            /// 关闭蓝牙
            /// </summary>
            /// <returns></returns>
            public bool colseBlueTooth()
            {
                
                return MAndroidJavaObject.Call<bool>("colseBlueTooth");
            }
    
    
    #region 私有方法
    
            /// <summary>
            /// 注册蓝牙状态监听
            /// </summary>
            void registerBluetoothReceiver()
            {
                MAndroidJavaObject.Call("registerBluetoothReceiver");
            }
    
            /// <summary>
            /// 取消注册蓝牙状态监听
            /// </summary>
            void unregisterBluetoothReceiver()
            {
                MAndroidJavaObject.Call("unregisterBluetoothReceiver");
            }
    
    
            protected override void OnDestroy()
            {
                unregisterBluetoothReceiver();
                base.OnDestroy();
            }
    
    #endregion
    
    #region 私有变量
    
     
    
            AndroidJavaObject _mAndroidJavaObject;
    
            public AndroidJavaObject MAndroidJavaObject
            {
                get
                {
                    if (_mAndroidJavaObject == null)
                    {
                        _mAndroidJavaObject = new AndroidJavaObject("com.example.bluetoothstatewrapper.BluetoothStateUtil");
                    }
    
                    return _mAndroidJavaObject;
                }
            }
    
    
    #endregion
        }
    }

2、BluetoothStateInterface

using System;
    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    
    namespace AndroidWrapper
    {
        /// <summary>
        /// 蓝牙状态监听接口
        /// </summary>
        public class BluetoothStateInterface : AndroidJavaProxy
        {
            /// <summary>
            /// 蓝牙变化委托事件
            /// </summary>
            Action _mBluetoothStateON;
            Action _mBluetoothStateOFF;
    
            public BluetoothStateInterface(Action mBluetoothStateON, Action mBluetoothStateOFF) : base("com.example.bluetoothstatewrapper.BluetoothStateInterface")
            {
                _mBluetoothStateON = mBluetoothStateON;
                _mBluetoothStateOFF = mBluetoothStateOFF;
            }
    
            /// <summary>
            /// 蓝牙打开事件监听
            /// </summary>
            public void onBluetoothStateON()
            {
    
                if (_mBluetoothStateON != null)
                {
                    _mBluetoothStateON();
                }
    
                Debug.Log(GetType() + "/onBluetoothStateON()/ 蓝牙开启事件");
            }
    
            /// <summary>
            /// 蓝牙关闭事件监听
            /// </summary>
            public void onBluetoothStateOFF()
            {
                if (_mBluetoothStateOFF != null)
                {
                    _mBluetoothStateOFF();
                }
    
                Debug.Log(GetType() + "/onBluetoothStateOFF()/ 蓝牙关闭事件");
            }
        }
    }

3、TestBluetoothStateWrapper

using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    using AndroidWrapper;
    using UnityEngine.UI;
    
    public class TestBluetoothStateWrapper : MonoBehaviour
    {
        public Toggle BTState_Toggle;
    
        // Start is called before the first frame update
        void Start()
        {
            BluetoothStateWrapper.Instance.Init(SetOnToggle, SetOffToggle);
            InitToggle();
        }
    
        /// <summary>
        /// 初始化
        /// </summary>
        void InitToggle() {
    
    #if UNITY_EDITOR
    
            // 获取当前状态
            SetIsOnToggle(Random.Range(0,2) ==0 ? false:true);
            // 设置监听事件
            BTState_Toggle.onValueChanged.AddListener((isOn) => {
               
            });
    #else
    
            // 获取当前状态
            SetIsOnToggle(BluetoothStateWrapper.Instance.getBlueToothState());
            // 设置监听事件
            BTState_Toggle.onValueChanged.AddListener((isOn)=> {
                if (isOn == true)
                {
                    BluetoothStateWrapper.Instance.openBlueTooth();
    
                }
                else {
                    BluetoothStateWrapper.Instance.colseBlueTooth();
                }
            });
    
    #endif
        }
    
        void SetOnToggle() {
            SetIsOnToggle(true);
        }
    
        void SetOffToggle()
        {
            SetIsOnToggle(false);
        }
    
        void SetIsOnToggle(bool isOn) {
            BTState_Toggle.isOn = isOn;
        }
    
    }

4、MonoSingleton

using UnityEngine;
    
    public abstract class MonoSingleton<T> : MonoBehaviour where T : MonoBehaviour
    {
        private static T instance = null;
    
        private static readonly object locker = new object();
    
        private static bool bAppQuitting;
    
        public static T Instance
        {
            get
            {
                if (bAppQuitting)
                {
                    instance = null;
                    return instance;
                }
    
                lock (locker)
                {
                    if (instance == null)
                    {
                        instance = FindObjectOfType<T>();
                        if (FindObjectsOfType<T>().Length > 1)
                        {
                            Debug.LogError("不应该存在多个单例！");
                            return instance;
                        }
    
                        if (instance == null)
                        {
                            var singleton = new GameObject();
                            instance = singleton.AddComponent<T>();
                            singleton.name = "(singleton)" + typeof(T);
                            singleton.hideFlags = HideFlags.None;
                            DontDestroyOnLoad(singleton);
                        }
                        else
                            DontDestroyOnLoad(instance.gameObject);
                    }
                    instance.hideFlags = HideFlags.None;
                    return instance;
                }
            }
        }
    
        protected virtual void Awake()
        {
            bAppQuitting = false;
        }
    
        protected virtual void OnDestroy()
        {
            bAppQuitting = true;
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 11][]

[20200825111221117.png]: /images/20221123/9085be24800e46ff9ec2bfc8a583b9c4.png
[20200825112206219.gif]: /images/20221123/a6a687ed593d435eb863fdd94b19c65d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70]: /images/20221123/a98f4134b81449a2962e222616cb5dc2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 1]: /images/20221123/7bc9536b03d24e51adad2da4c3ddcd44.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 2]: /images/20221123/fcc9dc2c1514464b866c0f771456a270.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 3]: /images/20221123/44ec770309a440f3ad0867fa5bfcfe85.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 4]: /images/20221123/00358df47a514a358e21f04881c33a0a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 5]: /images/20221123/0a7b5452a52b4ae2a25be6bbacd10db0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 6]: /images/20221123/b67eeb3eeccd40089ab72b3761a932bf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 7]: /images/20221123/51f6fcb45f00468f9ef81273b24b1f6b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 8]: /images/20221123/6b3f240fd15d467396eb649226907e8e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 9]: /images/20221123/db7c36c184d64798b4183534e7b9bf93.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 10]: /images/20221123/0a6d74ad0e784c9c8ceb12e417905462.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 11]: /images/20221123/6214440a5d934a7da65dab449c471a9b.png