admin管理员组文章数量:1540702
简介
本文实现3个功能：
1、获取位置权限
2、获取wifi列表
3、连接指定wifi
1、添加权限
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
<uses-permission android:name="android.permission.CHANGE_WIFI_MULTICAST_STATE" />
<uses-permission android:name="android.permission.CHANGE_NETWORK_STATE"/>
<!--位置权限-->
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_LOCATION_EXTRA_COMMANDS" />
2、MainActivity
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
//搜索wifi
bt1.setOnClickListener {
if (lacksPermission(this, Manifest.permission.ACCESS_FINE_LOCATION)) {
// WifiAdmin(this).startScan()
WifiUtils.getInstance(this).getWifiList()
} else {
rxRequestPermissions(Manifest.permission.ACCESS_FINE_LOCATION, describe = "位置") {
Log.d("WY+", "用户按了允许权限==2")
}
}
}
//连接指定的wifi
bt2.setOnClickListener {
Log.d("WY+", "获取wifi位置权限:" + lacksPermission(this, Manifest.permission.ACCESS_FINE_LOCATION))
if (lacksPermission(this, Manifest.permission.ACCESS_FINE_LOCATION)) {//位置权限是否开启
tv_status.text = "连接中。。。"
WifiUtils.getInstance(this).connectwifi("Fslihua_AI1", "fslihuaqaz2020"){
if (it){
// Log.d("WY+", "连接成功")
tv_status.text = "连接成功"
}else{
// Log.d("WY+", "连接失败")
tv_status.text = "连接失败"
}
}
} else {
Toast.makeText(this, "您还没有开启位置权限", Toast.LENGTH_SHORT).show()
}
}
}
/**
* 判断是否拥有某个权限
*/
fun lacksPermission(mContexts: Context, permission: String): Boolean {
return ContextCompat.checkSelfPermission(mContexts, permission) != PackageManager.PERMISSION_DENIED
}
}
3、WifiUtils工具类
/**
* android9.0需要打开位置权限
* mWifiConfiguration：是指手机本身保存过的wifi
*
* Level>-50 信号最强4格
* -50<Level></Level><-65 信号3格
* -65<Level></Level><-75 信号2格
* -75<Level></Level><-90 信号1格
* -90<Level 信号0格></Level>
*
* 可能会有点报错，线程改协程就可以了
*/
class WifiUtils private constructor(var context: Context) : BroadcastReceiver() {
// 定义WifiManager对象
private val mWifiManager: WifiManager
// 定义WifiInfo对象
private val mWifiInfo: WifiInfo?
// 扫描出的网络连接列表
// 得到网络列表
var wifiList: List<ScanResult>? = null
private set
// 网络连接列表
// 得到配置好的网络
val configuration: List<WifiConfiguration>
val handler = Handler()
var filter: IntentFilter? = null
var SSID: String = ""
var listen: ((Boolean) -> Unit)? = null
/**
* 单例
*/
companion object {
@Volatile
var instance: WifiUtils? = null
fun getInstance(context: Context): WifiUtils {
if (instance == null) {
synchronized(WifiUtils::class) {
if (instance == null) {
instance = WifiUtils(context)
}
}
}
return instance!!
}
}
//构造函数
init {
// 取得WifiManager对象
mWifiManager = context
.getSystemService(Context.WIFI_SERVICE) as WifiManager
// 取得WifiInfo对象
mWifiInfo = mWifiManager.connectionInfo
// 得到配置好的网络连接(手机保存过的wifi)
configuration = mWifiManager.configuredNetworks
}
/**
* 1、连接指定wifi
* 需要密码连接
示例：WifiUtils.getInstance(this).connectwifi("Fslihua_AI", "fslihuaqaz2020"){
if (it){
Log.d("WY+", "连接成功")
}else{
Log.d("WY+", "连接失败")
}
}
*/
fun connectwifi(SSID: String, Password: String, mListen: (Boolean) -> Unit) {
this.SSID = SSID
listen = mListen
//注册广播
filter = IntentFilter()
filter!!.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION)//监听wifi改变
filter!!.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION)//监听wifi连接成功
context.registerReceiver(this, filter)//注册广播
//开始倒计时，如果10秒还是没有连接上传进来的wifi就返回失败
handler.postDelayed({
// Log.d("WY+", "连接失败")
listen?.let { it(false) }//回调给调用者
context.unregisterReceiver(this)//注销广播
handler.removeCallbacksAndMessages(null)//注销handler
}, 10000)//十秒返回连接失败
val wificonfi = IsExsits(SSID)//如果存在就返回配置信息
if (wificonfi == null) {//为空表示没有保存过wifi
//需要密码
mWifiManager.enableNetwork(mWifiManager.addNetwork(
setWifiParamsPassword(SSID, Password)), true)
} else {//不为空表示：保存过wifi
mWifiManager.enableNetwork(wificonfi.networkId, true)
}
}
//判断手机是否保存有这个wifi
private fun IsExsits(SSID: String): WifiConfiguration? {
val existingConfigs = mWifiManager.configuredNetworks
for (existingConfig in existingConfigs) {
if (existingConfig.SSID == "\"" + SSID + "\"") {
return existingConfig
}
}
return null
}
/**
* 连接有密码的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连接情况
*/
override fun onReceive(context: Context?, intent: Intent?) {
if (intent?.action == WifiManager.NETWORK_STATE_CHANGED_ACTION) {//wifi连接上与否
val info = intent.getParcelableExtra<NetworkInfo>(WifiManager.EXTRA_NETWORK_INFO)
if (info.state == NetworkInfo.State.DISCONNECTED) {
// Log.d("WY+", "wifi网络连接断开")
} else if (info.state == NetworkInfo.State.CONNECTED) {
val wifiManager = context?.getSystemService(Context.WIFI_SERVICE) as WifiManager
val wifiInfo = wifiManager.connectionInfo
//获取当前wifi名称
Log.d("WY+", "连接到网络: " + wifiInfo.ssid)
if (wifiInfo.ssid.replace("\"", "") == SSID) {//判断连接的wifi是否为自己想要连的wifi
// Log.d("WY+", "连接成功: " + wifiInfo.ssid)
listen?.let { it(true) }//回调给调用者
handler.removeCallbacksAndMessages(null)//取消handler，让延迟发送不生效
context.unregisterReceiver(this)//注销广播
}
}
} else if (intent?.action == WifiManager.WIFI_STATE_CHANGED_ACTION) {//wifi打开与否
val wifistate = intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE, WifiManager.WIFI_STATE_DISABLED)
if (wifistate == WifiManager.WIFI_STATE_DISABLED) {
Log.d("WY+", "系统关闭wifi ")
} else if (wifistate == WifiManager.WIFI_STATE_ENABLED) {
Log.d("WY+", "系统开启wifi ")
}
}
}
/**
* 2、获取wifi列表
*/
fun getWifiList(){
wifiList = mWifiManager.scanResults
LogScanResult()//打印扫描结果
}
//打印列表结果
private fun LogScanResult() {
(wifiList as MutableList<ScanResult>?)?.forEach {
Log.d("WY+", "wifi列表：" + it)
}
}
}
4、权限的扩展函数
/**
* 获取权限的工具android 6.0以上(扩展函数)
*/
//传入权限与权限描述，在需要权限的功能打开之前调用
fun Activity.rxRequestPermissions(vararg permissions: String, describe: String, onGranted:()->Unit) {
val keylistener = DialogInterface.OnKeyListener { _, keyCode, event ->
keyCode == KeyEvent.KEYCODE_BACK && event.repeatCount == 0
}
var dialog = AlertDialog.Builder(this)
.setTitle("权限申请")
.setMessage("${describe}为必选项，开通后方可正常使用APP,请在设置中开启。")
.setOnKeyListener(keylistener)
.setCancelable(false)
.setPositiveButton("去开启") { _, _ ->
// JumpPermissionManagement.GoToSetting(this)
// finish()
}
.setNegativeButton("结束") { _, _ ->
Toast.makeText(this, "${describe}权限未开启，不能使用该功能！", Toast.LENGTH_SHORT).show()
// finish()
}
.create()
val rxPermissions = RxPermissions(this)
//传递kotlin的可变长参数给Java的可变参数的时候需要使用修饰符 * ；这个修饰符叫做Speread Operator
// 它只支持展开的Array 数组，不支持List集合，它只用于变长参数列表的实参，不能重载，它也不是运算符；
rxPermissions.request(*permissions)
.subscribe {granted ->
if (granted) {
onGranted()
Log.d("WY+","允许了==1")
} else {
dialog.show()
}
}
}
5、xml
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android/apk/res/android"
xmlns:app="http://schemas.android/apk/res-auto"
xmlns:tools="http://schemas.android/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
tools:context=".MainActivity">
<Button
android:id="@+id/bt1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="获取wifi列表"/>
<Button
android:id="@+id/bt2"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="连接某个指定的wifi"/>
<TextView
android:id="@+id/tv_status"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text=""/>
</LinearLayout>
demo的下载地址为：
https://download.csdn/download/wy313622821/12451069
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
}
}
}
版权声明：本文标题：kotlin的wifi获取列表和连接指定wifi 内容由热心网友自发贡献，该文观点仅代表作者本人， 转载请联系作者并注明出处：https://m.elefans.com/xitong/1727036462a1095099.html， 本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容，一经查实，本站将立刻删除。
发表评论