kotlin的wifi工具类

wifi工具类

代码：

class WifiAdmin// 构造器
(internal var context: Context) {
    // 定义WifiManager对象
    private val mWifiManager: WifiManager
    // 定义WifiInfo对象
    private val mWifiInfo: WifiInfo?
    // 扫描出的网络连接列表
    // 得到网络列表
    var wifiList: List<ScanResult>? = null
        private set
    // 网络连接列表
    // 得到配置好的网络
    val configuration: List<WifiConfiguration>
    // 定义一个WifiLock
    internal var mWifiLock: WifiManager.WifiLock?=null
    private val permissionHelper: PermissionHelper? = null
    internal var wifiAdminCallback: WifiAdminCallback?=null

    // 得到MAC地址
    val macAddress: String
        get() = if (mWifiInfo == null) "NULL" else mWifiInfo.macAddress

    // 得到接入点的BSSID
    val bssid: String
        get() = if (mWifiInfo == null) "NULL" else mWifiInfo.bssid

    // 得到IP地址
    val ipAddress: Int
        get() = mWifiInfo?.ipAddress ?: 0

    // 得到连接的ID
    val networkId: Int
        get() = mWifiInfo?.networkId ?: 0

    // 得到WifiInfo的所有信息包
    val wifiInfo: String
        get() = mWifiInfo?.toString() ?: "NULL"


    /*************以下是原工具类没有的 */
    /**
     * 获取当前连接的wifi名称（android8.0以下的版本可以用，8.0以上需要打开位置信息）
     */
    //        Log.d("wifiInfo", wifiInfo.toString());
    val connectedWifiName: String?
        get() {
            val wifiInfo = mWifiManager.connectionInfo
            return wifiInfo.ssid
        }

    /**
     * 获取当前连接的wifi名称（android8.0的版本可以用）
     * 调试不通过
     */
    val wifiName8: String
        get() {
            val cm = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
            val networkInfo = cm.activeNetworkInfo

            return networkInfo.extraInfo
        }


    init {
        // 取得WifiManager对象
        mWifiManager = context
                .getSystemService(Context.WIFI_SERVICE) as WifiManager
        // 取得WifiInfo对象
        mWifiInfo = mWifiManager.connectionInfo
        // 得到配置好的网络连接(手机保存过的wifi)
        configuration = mWifiManager.configuredNetworks
        //        Log.i("手机保存过的wifi",""+mWifiConfiguration);
    }

    // 打开WIFI
    fun openWifi() {
        if (!mWifiManager.isWifiEnabled) {
            mWifiManager.isWifiEnabled = true
        }
    }

    // 关闭WIFI
    fun closeWifi() {
        if (mWifiManager.isWifiEnabled) {
            mWifiManager.isWifiEnabled = false
        }
    }

    /**
     * 检查当前WIFI状态
     *
     * @return 1.表示没有开wifi 2表示wifi正在打开 3.已经打开了wifi
     */
    fun checkState(): Int {
        return mWifiManager.wifiState
    }

    // 锁定WifiLock
    fun acquireWifiLock() {
        mWifiLock!!.acquire()
    }

    // 解锁WifiLock
    fun releaseWifiLock() {
        // 判断时候锁定
        if (mWifiLock!!.isHeld) {
            mWifiLock!!.acquire()
        }
    }

    // 创建一个WifiLock
    fun creatWifiLock() {
        mWifiLock = mWifiManager.createWifiLock("Test")
    }

    // 指定配置好的网络进行连接（已经连过的wifi用这个方法来连）
    fun connectConfiguration(index: Int) {
        // 索引大于配置好的网络索引返回
        if (index > configuration.size) {
            return
        }
        // 连接配置好的指定ID的网络
        mWifiManager.enableNetwork(configuration[index].networkId,
                true)
    }

    fun startScan() {
        mWifiManager.startScan()
        // 得到扫描结果
        wifiList = mWifiManager.scanResults
        // 得到配置好的网络连接(已连接过的wifi)
        //        mWifiConfiguration = mWifiManager.getConfiguredNetworks();
    }

    // 查看扫描结果
    fun lookUpScan(): StringBuilder {
        val stringBuilder = StringBuilder()
        for (i in wifiList!!.indices) {
            stringBuilder
                    .append("Index_" + (i + 1).toString() + ":")
            // 将ScanResult信息转换成一个字符串包
            // 其中把包括：BSSID、SSID、capabilities、frequency、level
            stringBuilder.append(wifiList!![i].toString())
            stringBuilder.append("/n")
        }
        return stringBuilder
    }

    //打印列表结果
    fun LogScanResult() {

    }

    // 添加一个网络并连接
    fun addNetwork(wcg: WifiConfiguration) {
        val wcgID = mWifiManager.addNetwork(wcg)
        val b = mWifiManager.enableNetwork(wcgID, true)
        println("a--$wcgID")
        println("b--$b")
    }

    // 断开指定ID的网络
    fun disconnectWifi(netId: Int) {
        mWifiManager.disableNetwork(netId)
        mWifiManager.disconnect()
    }

    //然后是一个实际应用方法，只验证过没有密码的情况：
    fun CreateWifiInfo(SSID: String, Password: String, Type: Int): WifiConfiguration {
        val config = WifiConfiguration()
        config.allowedAuthAlgorithms.clear()
        config.allowedGroupCiphers.clear()
        config.allowedKeyManagement.clear()
        config.allowedPairwiseCiphers.clear()
        config.allowedProtocols.clear()
        config.SSID = "\"" + SSID + "\""

        val tempConfig = this.IsExsits(SSID)//检查是否手机保存的wifi，没有保存过就返回空
        if (tempConfig != null) {//非空表示有保存过
            mWifiManager.removeNetwork(tempConfig.networkId)
        }

        if (Type == 1)
        //WIFICIPHER_NOPASS(不用密码连)
        {
            config.wepKeys[0] = ""
            config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE)
            config.wepTxKeyIndex = 0
        }
        if (Type == 2)
        //WIFICIPHER_WEP(基本上不用这个连)
        {
            config.hiddenSSID = true
            config.wepKeys[0] = "\"" + Password + "\""
            config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.SHARED)
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP)
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP)
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP40)
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP104)
            config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE)
            config.wepTxKeyIndex = 0
        }
        if (Type == 3)
        //WIFICIPHER_WPA（使用密码连）
        {
            config.preSharedKey = "\"" + Password + "\""
            config.hiddenSSID = true
            config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN)
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP)
            config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK)
            config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP)
            //config.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP)
            config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP)
            config.status = WifiConfiguration.Status.ENABLED
        }
        return config
    }

    /**
     * 连接有密码的wifi.
     *
     * @param SSID     ssid
     * @param Password Password
     * @return apConfig
     */
    private fun setWifiParamsPassword(SSID: String, Password: String): WifiConfiguration {
        val apConfig = WifiConfiguration()
        apConfig.SSID = "\"" + SSID + "\""
        apConfig.preSharedKey = "\"" + Password + "\""
        //不广播其SSID的网络
        apConfig.hiddenSSID = true
        apConfig.status = WifiConfiguration.Status.ENABLED
        //公认的IEEE 802.11验证算法。
        apConfig.allowedAuthAlgorithms.clear()
        apConfig.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN)
        //公认的的公共组密码
        apConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP)
        apConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP)
        //公认的密钥管理方案
        apConfig.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK)
        //密码为WPA。
        apConfig.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP)
        apConfig.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP)
        //公认的安全协议。
        apConfig.allowedProtocols.set(WifiConfiguration.Protocol.RSN)
        return apConfig
    }

    /**
     * 连接没有密码wifi.
     *
     * @param ssid ssid
     * @return configuration
     */
    private fun setWifiParamsNoPassword(ssid: String): WifiConfiguration {
        val configuration = WifiConfiguration()
        configuration.SSID = "\"" + ssid + "\""
        configuration.status = WifiConfiguration.Status.ENABLED
        configuration.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP)
        configuration.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK)
        configuration.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE)
        configuration.allowedPairwiseCiphers
                .set(WifiConfiguration.PairwiseCipher.TKIP)
        configuration.allowedPairwiseCiphers
                .set(WifiConfiguration.PairwiseCipher.CCMP)
        configuration.allowedProtocols.set(WifiConfiguration.Protocol.RSN)
        return configuration
    }

    //判断手机是否保存有这个wifi
    private fun IsExsits(SSID: String): WifiConfiguration? {
        val existingConfigs = mWifiManager.configuredNetworks
        for (existingConfig in existingConfigs) {
            if (existingConfig.SSID == "\"" + SSID + "\"") {
                return existingConfig
            }
        }
        return null
    }

    /**
     * （原来是使用addNetwork方法进行连接）
     * 连接指定wifi
     * 需要密码连接
     */
    fun connectwifi(SSID: String, Password: String) {
        val wificonfi = IsExsits(SSID)//如果存在就返回配置信息
        //        Log.i("wifi配置",""+wificonfi);
        if (wificonfi == null) {//为空表示没有保存过wifi
            //需要密码
            mWifiManager.enableNetwork(mWifiManager.addNetwork(
                    setWifiParamsPassword(SSID, Password)), true)
        } else {//不为空表示：保存过wifi
            mWifiManager.enableNetwork(wificonfi.networkId, true)
        }
    }

    fun connectwifiNopassword(SSID: String) {
        val wificonfi = IsExsits(SSID)//如果存在就返回配置信息
        //        Log.i("wifi配置",""+wificonfi);
        if (wificonfi == null) {//为空表示没有保存过wifi

            //需要密码
            mWifiManager.enableNetwork(mWifiManager.addNetwork(
                    setWifiParamsNoPassword(SSID)), true)
        } else {//不为空表示：保存过wifi
            mWifiManager.enableNetwork(wificonfi.networkId, true)
        }
    }


    /**
     * 判断当前连接的wifi名称是否包含eifle_s开头
     *
     * @param ssid
     * @return 其他方法调用的时候返回1，再判断数据流量有没有打开
     */
    fun wifiUNcontainEifle_s(ssid: String): Int {
        if (!mWifiManager.isWifiEnabled) {//wifiManager.isWifiEnabled()表示wifi是打开的
            return 1//1表示wifi没有打开
        }
        Log.d(TAG, "wifi的名称：" + connectedWifiName!!)
        return if (connectedWifiName!!.contains(ssid)) {
            3//3表示wifi打开，且wifi名称包含eifles
        } else {
            2//2表示wifi打开，且wifi名称不包含包含eifles
        }
    }


    /**
     * 开一个线程循环连接wifi，直到连接上了(无接口返回)
     * @param SSID wifi帐号密码
     * @param Password 密码
     */
    fun connectwifiCycle(SSID: String, Password: String) {
        val wifiRun = Runnable() //创建线程
        {
            var wifiRun: Boolean? = true
            var i = 0//控制循环的次数
            while (wifiRun!!) {
                try {
                    Log.d(TAG, "Cycle=wifi的名称：" + connectedWifiName + "/SSID为" + SSID + "==" + (connectedWifiName == "\"" + SSID + "\""))
                    if (connectedWifiName != null && connectedWifiName == "\"" + SSID + "\"") {
                        wifiRun = false
                    } else {
                        connectwifi(SSID, Password)
                        if (i < 10) {//控制只运行10次循环
                            Log.d(TAG, "运行次数为：$i")
                            i++
                        } else {
                            wifiRun = false
                        }
                    }
                    sleep(4000)
                } catch (e: InterruptedException) {
                    e.printStackTrace()
                }

            }
        }
        ThreadPoolUtil.getInstance().execute(wifiRun)
    }

    /**
     * 开一个线程循环连接wifi，直到连接上了，通过接口回调返回
     * @param SSID wifi帐号
     * @param Password 密码
     * @param wifiAdminCallback 回调接口
     */
    fun connectwifiCycle(SSID: String, Password: String, wifiAdminCallback: WifiAdminCallback) {
        val wifiRun = Runnable(){//创建线程
            var wifiRun: Boolean? = true
            var i = 0//控制循环的次数
            while (wifiRun!!) {
                try {
                    //                        Log.d(TAG, "Cycle=wifi的名称：" + getConnectedWifiName() + "/SSID为" + SSID + "==" + getConnectedWifiName().equals("\"" + SSID + "\""));
                    if (connectedWifiName != null && connectedWifiName == "\"" + SSID + "\"") {
                        wifiRun = false
                        wifiAdminCallback.wifiAdminCallback(true)
                    } else {
                        connectwifi(SSID, Password)
                        if (i < 5) {//控制只运行10次循环
                            Log.d(TAG, "循环连wifi中$i")
                            i++
                        } else {
                            wifiRun = false
                            wifiAdminCallback.wifiAdminCallback(false)
                        }
                    }
                    sleep(4000)
                } catch (e: InterruptedException) {
                    e.printStackTrace()
                }

            }
        }
        ThreadPoolUtil.getInstance().execute(wifiRun)
    }

    //自定义回调接口
    interface WifiAdminCallback {
        fun wifiAdminCallback(isConnected: Boolean?)
    }

    fun setWifiAdminCallback(wifiAdminCallback: WifiAdminCallback) {//构造函数中传callback进来
        this.wifiAdminCallback = wifiAdminCallback
    }

    companion object {
        private val TAG = "WifiAdmin"


        /**
         * 检测移动数据是否打开
         *
         * @param context
         * @return
         */
        fun isMobile(context: Context): Boolean {
            val connectivityManager = context
                    .getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
            val networkInfo = connectivityManager.activeNetworkInfo
            return if (networkInfo != null && networkInfo.type == ConnectivityManager.TYPE_MOBILE) {
                true
            } else false
        }
    }


}