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

刺骨的言语ヽ痛彻心扉 2022-12-01 01:14 516阅读 0赞

![20200825114438732.png][]

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

**目录**

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

一、简单介绍

二、实现原理

三、注意事项

四、效果预览

五、实现步骤

Android 端：

Unity 端

六、关键代码

Android 端

Unity  端

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

## 一、简单介绍 ##

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

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

## 二、实现原理 ##

1、getSystemService(Context.WIFI\_SERVICE) 获取 Wifi 管理器 WifiManager

2、WifiManager.isWifiEnabled() 获取 Wifi 状态

3、WifiManager.setWifiEnabled(true)/WifiManager.setWifiEnabled(false) 设置 Wifi 开关

4、使用广播监听 WifiManager.WIFI\_STATE\_CHANGED\_ACTION 网络Wifi 的状态变化

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

## 三、注意事项 ##

1、需要添加 Wifi 相关权限

> <uses-permission android:name="android.permission.ACCESS\_WIFI\_STATE"/>
> 
> <uses-permission android:name="android.permission.CHANGE\_WIFI\_STATE"/>

## 四、效果预览 ##

![20200825115350608.gif][]

## 五、实现步骤 ##

### Android 端： ###

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70][]

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

![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 显示设置 Wifi 状态

![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、WifiStateUtil

package com.example.wifistatewrapper;
    
    import android.app.Activity;
    import android.content.BroadcastReceiver;
    import android.content.Context;
    import android.content.Intent;
    import android.content.IntentFilter;
    import android.net.wifi.WifiManager;
    import android.util.Log;
    import android.widget.Toast;
    
    public class WifiStateUtil {
    
        private static final String TAG = "Main_WifiStateUtil";
    
        private WifiManager _WifiManager;
        private Context _Context;
        private WifiStateBroadcastReceive mReceive;
        private WifiStateInterface mWifiStateInterface;
    
    
        public void Init(WifiStateInterface wifiStateInterface){
    
            _Context = getActivity();
            _WifiManager = (WifiManager)_Context.getSystemService(Context.WIFI_SERVICE);
            mWifiStateInterface = wifiStateInterface;
        }
    
        /**
         * 获取 Wifi 状态
         * @return
         */
        public boolean getWifiState() {
    
            return _WifiManager.isWifiEnabled();
        }
    
        /**
         * 打开 Wifi
         * @return
         */
        public boolean openWifi() {
            if (getWifiState()) return true;
    
            return _WifiManager.setWifiEnabled(true);
        }
    
        /**
         * 关闭 Wifi
         * @return
         */
        public boolean cloaseWifi() {
            if (!getWifiState()) return true;
    
            return _WifiManager.setWifiEnabled(false);
        }
    
    
        /**
         * 注册监听 Wifi 状态改变的广播
         */
        public void registerWifiReceiver(){
            if(mReceive == null){
                mReceive = new WifiStateBroadcastReceive();
            }
            IntentFilter intentFilter = new IntentFilter();
            intentFilter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);
            _Context.registerReceiver(mReceive, intentFilter);
        }
    
        /**
         * 取消注册监听 Wifi 状态改变的广播
         */
        public void unregisterWifiReceiver(){
            if(mReceive != null){
                _Context.unregisterReceiver(mReceive);
                mReceive = null;
            }
        }
    
        /**
         * Wifi 状态广播
         */
        class WifiStateBroadcastReceive extends BroadcastReceiver {
    
            @Override
            public void onReceive(Context context, Intent intent) {
                int wifiState = intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE, 0);
                switch (wifiState) {
                    case WifiManager.WIFI_STATE_DISABLED:
                        //Toast.makeText(context , "Wifi已关闭", Toast.LENGTH_SHORT).show();
                        Log.i(TAG, "onReceive: "+"Wifi已关闭");
                        if (mWifiStateInterface != null){
    
                            mWifiStateInterface.onWifiStateOFF();
                        }
                        break;
                    case WifiManager.WIFI_STATE_DISABLING:
                        //Toast.makeText(context , "Wifi正在关闭", Toast.LENGTH_SHORT).show();
                        Log.i(TAG, "onReceive: "+"Wifi正在关闭...");
                        break;
                    case WifiManager.WIFI_STATE_ENABLED:
                        //Toast.makeText(context , "Wifi已打开", Toast.LENGTH_SHORT).show();
                        Log.i(TAG, "onReceive: "+"Wifi已打开");
                        if (mWifiStateInterface != null){
    
                            mWifiStateInterface.onWifiStateON();
                        }
                        break;
                    case WifiManager.WIFI_STATE_ENABLING:
                        //Toast.makeText(context , "Wifi正在打开", Toast.LENGTH_SHORT).show();
                        Log.i(TAG, "onReceive: "+"Wifi正在打开...");
                        break;
                    case WifiManager.WIFI_STATE_UNKNOWN:
    
                        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、WifiStateInterface

package com.example.wifistatewrapper;
    
    public interface WifiStateInterface {
        void onWifiStateON();
        void onWifiStateOFF();
    }

3、AndroidManifest.xml

### Unity  端 ###

1、WifiStateWrapper

using System;
    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    namespace AndroidWrapper
    {
        public class WifiStateWrapper : MonoSingleton<WifiStateWrapper>
        {
            /// <summary>
            /// 初始化
            /// </summary>
            /// <param name="VoiceVolumnChangedListener"></param>
            public void Init(Action OnWifiStateONListener, Action OnWifiStateOFFListener)
            {
    
    #if UNITY_EDITOR
    
    #else
    
                MAndroidJavaObject.Call("Init", new WifiStateInterface(OnWifiStateONListener, OnWifiStateOFFListener));
                registerWifiReceiver();
    #endif
    
            }
    
            /// <summary>
            /// 获取 Wifi 当前状态
            /// </summary>
            /// <returns></returns>
            public bool getWifiState()
            {
                return MAndroidJavaObject.Call<bool>("getWifiState");
            }
    
            /// <summary>
            /// 打开 Wifi
            /// </summary>
            /// <returns></returns>
            public bool openWifi()
            {
                return MAndroidJavaObject.Call<bool>("openWifi");
            }
    
            /// <summary>
            /// 关闭 Wifi 
            /// </summary>
            /// <returns></returns>
            public bool cloaseWifi()
            {
    
                return MAndroidJavaObject.Call<bool>("cloaseWifi");
            }
    
            #region 私有方法
    
            /// <summary>
            /// 注册蓝牙状态监听
            /// </summary>
            void registerWifiReceiver()
            {
                MAndroidJavaObject.Call("registerWifiReceiver");
            }
    
            /// <summary>
            /// 取消注册蓝牙状态监听
            /// </summary>
            void unregisterWifiReceiver()
            {
                MAndroidJavaObject.Call("unregisterWifiReceiver");
            }
    
    
            protected override void OnDestroy()
            {
                unregisterWifiReceiver();
                base.OnDestroy();
            }
    
            #endregion
    
            #region 私有变量
    
    
    
            AndroidJavaObject _mAndroidJavaObject;
    
            public AndroidJavaObject MAndroidJavaObject
            {
                get
                {
                    if (_mAndroidJavaObject == null)
                    {
                        _mAndroidJavaObject = new AndroidJavaObject("com.example.wifistatewrapper.WifiStateUtil");
                    }
    
                    return _mAndroidJavaObject;
                }
            }
    
    
            #endregion
        }
    }

2、WifiStateInterface

using System;
    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    namespace AndroidWrapper
    {
        /// <summary>
        /// Wifi 状态变化接听接口
        /// </summary>
        public class WifiStateInterface : AndroidJavaProxy
        {
            /// <summary>
            /// Wifi变化委托事件
            /// </summary>
            Action _mWifiStateON;
            Action _mWifiStateOFF;
    
            public WifiStateInterface(Action mWifiStateON, Action mWifiStateOFF):base("com.example.wifistatewrapper.WifiStateInterface")
            {
                _mWifiStateON = mWifiStateON;
                _mWifiStateOFF = mWifiStateOFF;
            }
    
            /// <summary>
            /// Wifi 开启事件
            /// </summary>
            public void onWifiStateON() {
                if (_mWifiStateON != null)
                {
                    _mWifiStateON();
                }
            }
    
            /// <summary>
            /// Wifi 关闭事件
            /// </summary>
            public void onWifiStateOFF() {
                if (_mWifiStateOFF != null)
                {
                    _mWifiStateOFF();
                }
            }
        }
    }

3、TestWifiStateWrapper

using AndroidWrapper;
    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    using UnityEngine.UI;
    
    public class TestWifiStateWrapper : MonoBehaviour
    {
        public Toggle WifiState_Toggle;
    
        // Start is called before the first frame update
        void Start()
        {
            WifiStateWrapper.Instance.Init(SetOnToggle, SetOffToggle);
            InitToggle();
        }
    
        /// <summary>
        /// 初始化
        /// </summary>
        void InitToggle()
        {
    
    #if UNITY_EDITOR
    
            // 获取当前状态
            SetIsOnToggle(Random.Range(0, 2) == 0 ? false : true);
            // 设置监听事件
            WifiState_Toggle.onValueChanged.AddListener((isOn) => {
    
            });
    
    #else
    
             // 获取当前状态
            SetIsOnToggle(WifiStateWrapper.Instance.getWifiState());
            // 设置监听事件
            WifiState_Toggle.onValueChanged.AddListener((isOn) => {
                if (isOn == true)
                {
                    WifiStateWrapper.Instance.openWifi();
    
                }
                else
                {
                    WifiStateWrapper.Instance.cloaseWifi();
                }
            });
    
    #endif
        }
    
        void SetOnToggle()
        {
            SetIsOnToggle(true);
        }
    
        void SetOffToggle()
        {
            SetIsOnToggle(false);
        }
    
        void SetIsOnToggle(bool isOn)
        {
            WifiState_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][]

[20200825114438732.png]: /images/20221123/678c641afbe9464ebb1b44416d257943.png
[20200825115350608.gif]: /images/20221123/bea638815b3c483eb5bf1c8c984eea50.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70]: /images/20221123/5c0ae81db60e49f79fd934a6a5f3eada.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 1]: /images/20221123/02304231055c42d5aea2701ef7a41bb3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 2]: /images/20221123/1e9ad9fe34b1440b8eaaafd385584097.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 3]: /images/20221123/52a0f7207ec147be836fba15dd5fc8f1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 4]: /images/20221123/db61b8ed5c9444e99416030d445b7bee.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 5]: /images/20221123/d585e51e50c548adaf076164372057ab.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 6]: /images/20221123/6b3b29632157488cad94a68ea1d8187f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 7]: /images/20221123/412824fa0ad74c45b67a000c29ea6a00.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 8]: /images/20221123/63588718abdb421682a818e57e5d3c4a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 9]: /images/20221123/3a8f7ee392f24012969559a6d8b233a1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 10]: /images/20221123/78e607feedf0444ea73712ef92a03ba3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 11]: /images/20221123/e0f86a80caa340828b029484cc55279e.png