Android-WiFi密码连接

原创 于 2025-05-13 22:01:17 发布 · 413 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#android #gitee

该文章已生成可运行项目，

Android 开发一款Wifi管理器的问题

  • 问题：我遇到了一个密码连接的操作，正确的密码无法连接，下面是我的核心代码

\app\src\main\java\com\example\qs_wifi\WifiConnectionManager.kt

WifiConnectionManager.kt

package com.example.qs_wifi

import android.content.Context
import android.net.wifi.WifiManager
import android.net.wifi.WifiNetworkSuggestion
import android.os.Build
import android.util.Log
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import android.net.wifi.WifiConfiguration
import android.net.wifi.WifiInfo
import android.content.IntentFilter
import android.net.wifi.WifiManager.NETWORK_STATE_CHANGED_ACTION
import android.net.wifi.WifiManager.SUPPLICANT_STATE_CHANGED_ACTION
import android.net.wifi.SupplicantState
import android.os.Handler
import android.os.Looper
import kotlin.coroutines.resume
import kotlin.coroutines.suspendCoroutine
import android.content.BroadcastReceiver
import android.content.Intent
import android.net.ConnectivityManager
import android.net.NetworkInfo
import android.os.Parcelable

class WifiConnectionManager(private val context: Context) {
    private val wifiManager = context.getSystemService(Context.WIFI_SERVICE) as WifiManager
    private val handler = Handler(Looper.getMainLooper())
    private val TAG = "WifiConnectionManager"

    suspend fun connectToWifi(ssid: String, password: String): Boolean = withContext(Dispatchers.IO) {
        try {
            Log.d(TAG, "=== 开始WiFi连接流程 ===")
            Log.d(TAG, "目标网络: $ssid")
            Log.d(TAG, "密码长度: ${password.length}")
            
            // 检查WiFi是否已启用
            if (!wifiManager.isWifiEnabled) {
                Log.e(TAG, "WiFi未启用，无法连接")
                return@withContext false
            }
            Log.d(TAG, "WiFi已启用")

            // 检查是否已连接
            val currentWifi = wifiManager.connectionInfo
            val currentSsid = currentWifi?.ssid?.removeSurrounding("\"")
            Log.d(TAG, "当前连接的网络: $currentSsid")
            
            if (currentSsid == ssid) {
                Log.d(TAG, "已经连接到目标网络")
                return@withContext true
            }

            // 尝试连接
            Log.d(TAG, "开始尝试连接...")
            val success = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
                connectWithSuggestion(ssid, password)
            } else {
                connectWithConfiguration(ssid, password)
            }

            if (!success) {
                Log.e(TAG, "连接请求失败")
                return@withContext false
            }

            // 等待连接结果
            Log.d(TAG, "等待连接结果...")
            waitForConnection(ssid)
        } catch (e: Exception) {
            Log.e(TAG, "连接WiFi时发生错误", e)
            false
        }
    }

    private suspend fun waitForConnection(ssid: String): Boolean = suspendCoroutine { continuation ->
        var isConnected = false
        var retryCount = 0
        val maxRetries = 20 // 最多等待10秒

        val receiver = object : BroadcastReceiver() {
            override fun onReceive(context: Context, intent: Intent) {
                when (intent.action) {
                    NETWORK_STATE_CHANGED_ACTION -> {
                        @Suppress("DEPRECATION")
                        val networkInfo = intent.getParcelableExtra<NetworkInfo>(WifiManager.EXTRA_NETWORK_INFO)
                        Log.d(TAG, "网络状态变化: ${networkInfo?.isConnected}")
                        
                        if (networkInfo?.isConnected == true) {
                            val currentWifi = wifiManager.connectionInfo
                            val currentSsid = currentWifi?.ssid?.removeSurrounding("\"")
                            Log.d(TAG, "当前连接的网络: $currentSsid")
                            
                            if (currentSsid == ssid) {
                                // 验证连接状态
                                val supplicantState = wifiManager.connectionInfo.supplicantState
                                Log.d(TAG, "Supplicant状态: $supplicantState")
                                
                                if (supplicantState == SupplicantState.COMPLETED) {
                                    Log.d(TAG, "连接成功完成")
                                    isConnected = true
                                    context.unregisterReceiver(this)
                                    continuation.resume(true)
                                } else {
                                    Log.d(TAG, "连接未完成，当前状态: $supplicantState")
                                }
                            }
                        }
                    }
                    SUPPLICANT_STATE_CHANGED_ACTION -> {
                        @Suppress("DEPRECATION")
                        val state = intent.getParcelableExtra<SupplicantState>(WifiManager.EXTRA_NEW_STATE)
                        Log.d(TAG, "Supplicant状态变化: $state")
                        
                        when (state) {
                            SupplicantState.DISCONNECTED -> {
                                retryCount++
                                Log.d(TAG, "连接断开，重试次数: $retryCount")
                                if (retryCount >= maxRetries) {
                                    Log.e(TAG, "达到最大重试次数，连接失败")
                                    context.unregisterReceiver(this)
                                    continuation.resume(false)
                                }
                            }
                            SupplicantState.AUTHENTICATING -> {
                                Log.d(TAG, "正在验证...")
                            }
                            SupplicantState.ASSOCIATING -> {
                                Log.d(TAG, "正在关联...")
                            }
                            SupplicantState.ASSOCIATED -> {
                                Log.d(TAG, "已关联")
                            }
                            SupplicantState.FOUR_WAY_HANDSHAKE -> {
                                Log.d(TAG, "正在进行四次握手...")
                            }
                            SupplicantState.COMPLETED -> {
                                Log.d(TAG, "连接完成")
                            }
                            else -> {
                                Log.d(TAG, "其他状态: $state")
                            }
                        }
                    }
                }
            }
        }

        // 注册接收器
        val filter = IntentFilter().apply {
            addAction(NETWORK_STATE_CHANGED_ACTION)
            addAction(SUPPLICANT_STATE_CHANGED_ACTION)
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
                addAction(WifiManager.ACTION_WIFI_NETWORK_SUGGESTION_POST_CONNECTION)
            }
        }
        context.registerReceiver(receiver, filter)
        Log.d(TAG, "已注册网络状态监听器")

        // 设置超时
        handler.postDelayed({
            if (!isConnected) {
                Log.e(TAG, "连接超时")
                context.unregisterReceiver(receiver)
                continuation.resume(false)
            }
        }, 10000) // 10秒超时
    }

    private fun connectWithSuggestion(ssid: String, password: String): Boolean {
        Log.d(TAG, "使用WifiNetworkSuggestion方式连接")
        val suggestion = WifiNetworkSuggestion.Builder()
            .setSsid(ssid)
            .setWpa2Passphrase(password)
            .setIsAppInteractionRequired(true)
            .build()

        val suggestions = listOf(suggestion)
        val status = wifiManager.addNetworkSuggestions(suggestions)
        
        return when (status) {
            WifiManager.STATUS_NETWORK_SUGGESTIONS_SUCCESS -> {
                Log.d(TAG, "网络建议添加成功")
                true
            }
            WifiManager.STATUS_NETWORK_SUGGESTIONS_ERROR_ADD_DUPLICATE -> {
                Log.d(TAG, "网络建议已存在")
                true
            }
            else -> {
                Log.e(TAG, "添加网络建议失败，状态码: $status")
                false
            }
        }
    }

    private fun connectWithConfiguration(ssid: String, password: String): Boolean {
        Log.d(TAG, "使用WifiConfiguration方式连接")
        val config = WifiConfiguration().apply {
            SSID = "\"$ssid\""
            preSharedKey = "\"$password\""
            status = WifiConfiguration.Status.ENABLED
            allowedProtocols.clear()
            allowedKeyManagement.clear()
            allowedPairwiseCiphers.clear()
            allowedGroupCiphers.clear()
            
            // 设置WPA2加密
            allowedProtocols.set(WifiConfiguration.Protocol.RSN)
            allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK)
            allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP)
            allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP)
        }

        val netId = wifiManager.addNetwork(config)
        if (netId == -1) {
            Log.e(TAG, "添加网络配置失败")
            return false
        }
        Log.d(TAG, "网络配置添加成功，netId: $netId")

        val success = wifiManager.enableNetwork(netId, true)
        Log.d(TAG, "启用网络结果: $success")
        return success
    }
}

\app\src\main\java\com\example\qs_wifi\MainActivity.kt

MainActivity.kt

// MainActivity.kt
package com.example.qs_wifi

import android.Manifest
import android.content.*
import android.content.pm.PackageManager
import android.net.wifi.ScanResult
import android.net.wifi.WifiManager
import android.os.Bundle
import android.provider.Settings
import android.util.Log
import android.widget.Toast
import androidx.appcompat.app.AlertDialog
import androidx.appcompat.app.AppCompatActivity
import androidx.core.app.ActivityCompat
import androidx.lifecycle.lifecycleScope
import androidx.recyclerview.widget.LinearLayoutManager
import com.example.qs_wifi.databinding.ActivityMainBinding
import com.example.qs_wifi.databinding.DialogConnectWifiBinding
import com.example.qs_wifi.databinding.DialogProgressBinding
import com.google.android.material.dialog.MaterialAlertDialogBuilder
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext

class MainActivity : AppCompatActivity() {
    private val TAG = "MainActivity"
    private lateinit var binding: ActivityMainBinding
    private lateinit var wifiManager: WifiManager
    private lateinit var wifiConnectionManager: WifiConnectionManager
    private lateinit var wifiAdapter: WifiAdapter
    private var isScanning = false
    private var progressDialog: AlertDialog? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        Log.d(TAG, "=== 应用启动 ===")
        
        binding = ActivityMainBinding.inflate(layoutInflater)
        setContentView(binding.root)

        wifiManager = getSystemService(Context.WIFI_SERVICE) as WifiManager
        wifiConnectionManager = WifiConnectionManager(this)
        Log.d(TAG, "WiFi管理器初始化完成")

        setupUI()
        checkPermissions()
    }

    private fun setupUI() {
        Log.d(TAG, "设置UI组件")
        binding.wifiList.layoutManager = LinearLayoutManager(this)
        wifiAdapter = WifiAdapter { wifiItem ->
            Log.d(TAG, "用户点击WiFi: ${wifiItem.ssid}")
            showConnectDialog(wifiItem)
        }
        binding.wifiList.adapter = wifiAdapter

        binding.swipeRefresh.setOnRefreshListener {
            Log.d(TAG, "用户触发刷新")
            startWifiScan()
        }

        binding.fabScan.setOnClickListener {
            Log.d(TAG, "用户点击扫描按钮")
            startWifiScan()
        }
    }

    private fun showConnectDialog(wifiItem: WifiItem) {
        Log.d(TAG, "显示连接对话框: ${wifiItem.ssid}")
        if (wifiItem.isConnected) {
            Log.d(TAG, "网络已连接，无需操作")
            return
        }

        val dialogBinding = DialogConnectWifiBinding.inflate(layoutInflater)
        val dialog = MaterialAlertDialogBuilder(this)
            .setTitle("连接 ${wifiItem.ssid}")
            .setView(dialogBinding.root)
            .setPositiveButton("连接") { dialog, _ ->
                val password = dialogBinding.passwordInput.text.toString()
                Log.d(TAG, "用户输入密码，长度: ${password.length}")
                connectToWifi(wifiItem.ssid, password)
                dialog.dismiss()
            }
            .setNegativeButton("取消", null)
            .create()

        dialog.show()
    }

    private fun connectToWifi(ssid: String, password: String) {
        Log.d(TAG, "开始连接WiFi: $ssid")
        showProgressDialog("正在连接...")
        
        lifecycleScope.launch {
            try {
                val success = wifiConnectionManager.connectToWifi(ssid, password)
                Log.d(TAG, "连接结果: $success")
                
                withContext(Dispatchers.Main) {
                    progressDialog?.dismiss()
                    if (success) {
                        showToast("连接成功")
                        startWifiScan() // 刷新列表
                    } else {
                        showToast("连接失败，请检查密码")
                    }
                }
            } catch (e: Exception) {
                Log.e(TAG, "连接过程发生异常", e)
                withContext(Dispatchers.Main) {
                    progressDialog?.dismiss()
                    showToast("连接失败: ${e.message}")
                }
            }
        }
    }

    private fun startWifiScan() {
        if (isScanning) {
            Log.d(TAG, "扫描正在进行中，忽略请求")
            return
        }

        Log.d(TAG, "开始WiFi扫描")
        isScanning = true
        binding.swipeRefresh.isRefreshing = true
        binding.fabScan.isEnabled = false

        wifiManager.startScan()
        registerReceiver(wifiScanReceiver, IntentFilter(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION))
    }

    private val wifiScanReceiver = object : BroadcastReceiver() {
        override fun onReceive(context: Context, intent: Intent) {
            Log.d(TAG, "收到扫描结果广播")
            if (intent.action == WifiManager.SCAN_RESULTS_AVAILABLE_ACTION) {
                context.unregisterReceiver(this)
                handleScanResults()
            }
        }
    }

    private fun handleScanResults() {
        Log.d(TAG, "处理扫描结果")
        try {
            val results = wifiManager.scanResults
            Log.d(TAG, "扫描到 ${results.size} 个网络")

            // 获取当前连接的网络
            val currentWifi = wifiManager.connectionInfo
            val currentSsid = currentWifi?.ssid?.removeSurrounding("\"")
            Log.d(TAG, "当前连接的网络: $currentSsid")

            // 获取已保存的网络列表
            val savedNetworks = wifiManager.configuredNetworks
            val savedSsids = savedNetworks?.map { it.SSID.removeSurrounding("\"") } ?: emptyList()
            Log.d(TAG, "已保存的网络: $savedSsids")

            // 处理扫描结果
            val wifiItems: List<WifiItem> = results
                .filter { it.SSID.isNotEmpty() }
                .groupBy { it.SSID }
                .mapNotNull { (ssid, networks) ->
                    networks.maxByOrNull { it.level }?.let { bestNetwork ->
                        val signalStrength = WifiManager.calculateSignalLevel(bestNetwork.level, 100)
                        val isSecure = bestNetwork.capabilities.contains("WPA") || 
                                     bestNetwork.capabilities.contains("WPA2") ||
                                     bestNetwork.capabilities.contains("WPA3") ||
                                     bestNetwork.capabilities.contains("WEP")
                        
                        WifiItem(
                            ssid = ssid,
                            signalStrength = signalStrength,
                            isSecure = isSecure,
                            isSaved = savedSsids.contains(ssid),
                            isConnected = ssid == currentSsid
                        )
                    }
                }
                .sortedByDescending { it.signalStrength }

            Log.d(TAG, "处理后的网络列表大小: ${wifiItems.size}")
            wifiAdapter.updateWifiList(wifiItems)
        } catch (e: Exception) {
            Log.e(TAG, "处理扫描结果时发生错误", e)
        } finally {
            isScanning = false
            binding.swipeRefresh.isRefreshing = false
            binding.fabScan.isEnabled = true
        }
    }

    private fun showProgressDialog(message: String) {
        Log.d(TAG, "显示进度对话框: $message")
        val dialogBinding = DialogProgressBinding.inflate(layoutInflater)
        dialogBinding.message.text = message

        progressDialog = MaterialAlertDialogBuilder(this)
            .setView(dialogBinding.root)
            .setCancelable(false)
            .create()

        progressDialog?.show()
    }

    private fun showToast(message: String) {
        Log.d(TAG, "显示Toast: $message")
        Toast.makeText(this, message, Toast.LENGTH_SHORT).show()
    }

    private fun checkPermissions() {
        if (hasRequiredPermissions()) {
            startWifiScan()
        } else {
            requestPermissions()
        }
    }

    private fun hasRequiredPermissions(): Boolean {
        return REQUIRED_PERMISSIONS.all {
            ActivityCompat.checkSelfPermission(this, it) == PackageManager.PERMISSION_GRANTED
        }
    }

    private fun requestPermissions() {
        ActivityCompat.requestPermissions(this, REQUIRED_PERMISSIONS, PERMISSIONS_REQUEST_CODE)
    }

    override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<String>, grantResults: IntArray) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
        if (requestCode == PERMISSIONS_REQUEST_CODE) {
            if (grantResults.all { it == PackageManager.PERMISSION_GRANTED }) {
                startWifiScan()
            } else {
                Toast.makeText(this, "需要位置权限才能扫描WiFi", Toast.LENGTH_SHORT).show()
            }
        }
    }

    override fun onDestroy() {
        super.onDestroy()
        try {
            unregisterReceiver(wifiScanReceiver)
        } catch (e: Exception) {
            Log.e(TAG, "取消注册接收器失败", e)
        }
        progressDialog?.dismiss()
    }

    companion object {
        private const val PERMISSIONS_REQUEST_CODE = 101
        private val REQUIRED_PERMISSIONS = arrayOf(
            Manifest.permission.ACCESS_FINE_LOCATION,
            Manifest.permission.ACCESS_COARSE_LOCATION
        )
    }
}

\app\src\main\java\com\example\qs_wifi\WifiItem.kt

WifiItem.kt

package com.example.qs_wifi

data class WifiItem(
    val ssid: String,
    val signalStrength: Int,
    val isSecure: Boolean,
    val isSaved: Boolean,
    val isConnected: Boolean
) {
    companion object {
        fun fromScanResult(result: android.net.wifi.ScanResult, isConnected: Boolean, isSaved: Boolean): WifiItem {
            val signalStrength = android.net.wifi.WifiManager.calculateSignalLevel(result.level, 100)
            val isSecure = result.capabilities.contains("WPA") || 
                          result.capabilities.contains("WPA2") ||
                          result.capabilities.contains("WPA3") ||
                          result.capabilities.contains("WEP")
            
            return WifiItem(
                ssid = result.SSID,
                signalStrength = signalStrength,
                isSecure = isSecure,
                isSaved = isSaved,
                isConnected = isConnected
            )
        }
    }
}
本文章已经生成可运行项目
精选资源
Android--Wifi列表、连接 Wifi 及Wifi登录验证
02-10
在Android平台上，开发一个应用程序以实现“Android--Wifi列表、连接 Wifi 及Wifi登录验证”涉及到几个关键的技术点。下面将详细阐述这些知识点，并提供相关的实现思路。 首先，要获取Wifi列表，Android提供了`...
Android开发--实现输入密码连接WIFI
04-06
在Android开发中，连接Wi-Fi是一项常见的功能，尤其在移动应用中，用户可能需要自动或手动连接到特定的Wi-Fi网络。本项目提供了一个简单的实现，允许用户输入密码来连接Wi-Fi，并且在成功连接后能够保存配置，以便于...
wifi工具类
xiaoerbuyu1233的博客
08-04 408
忘哪儿看到的了,保存一下。
android通过代码连接wifi
11-06 4512
Android SDK API 29（对应Android 10）以下，可以在app之中通过代码直接设置wifi名称和密码进行连接。API 29及其以上版本，增加了动态管理权限功能，启用了之前的接口，同时app连接wifi时必须通过用户同意，具体方式是弹出一个Activity显示wifi列表，用户点击之后再返回app。
Android 9.0以上 连接wifi失败 解决方案
hongranzuoxiang的博客
06-13 3282
见addNetworkSuggestions(java.util.List)， removeNetworkSuggestions(java.util.List)新的API添加Wi-Fi网络进行审议时，自动连接到无线网络。兼容性注意：对于目标Build.VERSION_CODES.Q或更高的应用程序 ，此API将始终返回-1。完美解决Android9.0以上wifi连接失败的问题~此方法在API级别Q中已弃用）
android WifiNetworkSpecifier连接wifi
weixin_29171129的博客
07-15 873
Android WifiNetworkSpecifier连接WiFi 在Android应用中，连接WiFi是一个常见的需求。Android 8.0引入了WifiNetworkSpecifier类，使得通过代码连接到指定的WiFi网络变得更加简单和灵活。在本文中，我们将介绍如何使用WifiNetworkSpecifier类连...
Android NDK开发详解连接性之适用于互联网连接的 WLAN 建议 API
hnjzfwy的博客
11-18 362
原生开发套件 (NDK) 是一套工具，使您能够在 Android 应用中使用 C 和 C++ 代码，并提供众多平台库，您可使用这些平台库管理原生 activity 和访问实体设备组件，例如传感器和触控输入。NDK 可能不适合大多数 Android 编程初学者，这些初学者只需使用 Java 代码和框架 API 开发应用
Android-wifi.zip_android_android wifi_android wifi_wifi androi
09-24
在Android平台上，Wi-Fi功能是移动设备连接到无线局域网（WLAN）的主要途径，为用户提供高速数据传输。在给定的“Android-wifi.zip”压缩包中，包含了一个Android Wi-Fi应用的APK文件以及其源码，这对于开发者来说是...
Android-将Android手机WiFi连接到指定的热点
08-13
在Android平台上，将设备的WiFi连接到特定的热点是一项常见的任务，尤其对于开发者来说，可能需要自定义控制网络连接以实现特定功能。本教程将详细解释如何在Android应用中实现这个功能，主要涉及Android的WiFi管理...
android wifi连接密码错误的wpa2和wpa3热点的状态日志
最新发布
05-21
android wifi连接密码错误的wpa2和wpa3热点的状态日志
`android.net.wifi` 是 Android 系统中用于管理 Wi-Fi 连接的 API
BLOG域名:programb.blog.youkuaiyun.com
05-12 685
它提供了一些类和接口，允许开发者在应用程序中执行与 Wi-Fi 相关的操作，例如扫描附近的 Wi-Fi 网络、连接到特定的 Wi-Fi 网络以及获取当前连接的 Wi-Fi 信息等。：这个类表示当前的 Wi-Fi 连接信息，包括连接的 SSID、BSSID、信号强度等。：这个类表示一个建议的 Wi-Fi 网络，可以用于向系统提供自动连接的建议。：这是一个广播动作，当 Wi-Fi 网络扫描完成后，系统会发送这个广播。：这个类表示一个 Wi-Fi 网络的配置信息，包括网络名称、密码等。
Android打造易用的 WiFi 工具类：WifiUtils 封装实践
tangweiguo03051987的博客
03-09 765
Android在全局范围内使用`WifiUtils`工具类，我们可以将其设计为一个单例，并通过`Application`类进行初始化。这样可以确保在整个应用程序中只有一个`WifiUtils`实例
Android 12 Wifi 开发（获取列表、连接、断开连接）
热门推荐
weixin_44917215的博客
01-09 1万+
扫描（这个方法早在Android 9.0 就被弃用），不过如果不调用的话是没法及时获取Wifi列表的广播的。然后需要系统签名，可在系统源码中获得。不知道各位有没有什么好的解决方法。
Android实现自动连接目标wifi
优快云zzh95的博客
07-14 2629
Android实现自动连接目标wifi
【android WiFi 切换】如何实现WiFi切换（支持AndroidQ及以上）
大胡子老哥的博客
11-10 3798
android实现WiFi切换，解决AndroidQ以上新版API无法支持WiFi切换的问题
kotlin的wifi获取列表和连接指定wifi
wy313622821的博客
03-24 7075
wifi工具类 代码： class WifiAdmin// 构造器 (internal var context: Context) { // 定义WifiManager对象 private val mWifiManager: WifiManager // 定义WifiInfo对象 private val mWifiInfo: WifiInfo? // 扫描出...
Android WIFI连接总结
weixin_40812272的博客
11-24 4012
Android10、11、12连接WIFI
Kotlin：Android App主动切换手机WiFi
hk13513973690的博客
04-10 762
有了这些权限大概率还是不行的，尤其是对于Android系统的较高版本，第一个接受来自某个app的wifi网络建议需要手动在手机上允许（会有弹窗），后面会好，且如果手机本身有wifi链接（我本人尝试是无法切换的，也希望评论区大佬给意见）。2.代码使用kotlin完成，Java也类似。输入需要wifi的ssid，password，以及设定的wifimanager。逻辑就是 链接--检查链接--反馈。赋予Android应用权限，在某一步后，需要切换手机wifi到指定wifi，给出反馈。
Android 10 中的隐私权变更
hnjzfwy的博客
10-17 504
Android 10（API 级别 29）引入了多项功能和行为变更，目的是更好地保护用户的隐私权。这些变更能让用户更清楚地了解并更好地控制他们的数据及为应用提供的权能。这些隐私权功能可能意味着应用所依赖的特定行为或数据可能会与较低版本的平台有所不同。如果您的应用遵循当前有关处理用户数据的最佳做法，则其受到的影响应该会最大限度地减少。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值