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

 

 

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"/>

 

四、效果预览

 

五、实现步骤

Android 端：

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

 

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

 

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

 

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

 

Unity 端

1、把 Android 打包的 aar 导入 Unity

 

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

 

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

 

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

 

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

 

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

 

六、关键代码

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

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.wifistatewrapper" >
    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>
    <uses-permission android:name="android.permission.CHANGE_WIFI_STATE"/>
</manifest>

 

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;
    }
}