Android新手开发问询：特定WiFi状态周期性检查及弹窗实现优化

Hey there! As someone who’s tangled with Android WiFi checks early on, let me share a cleaner, lifecycle-friendly approach that avoids messy TimerTask loops and plays nicer with Android’s system patterns. Your original idea works in theory, but polling every 30 seconds wastes resources, and looping to check WiFi can lead to ANRs (Application Not Responding) if not handled right. Here’s a better way:

Instead of polling, we’ll let Android notify us when WiFi state changes, then use ViewModel/LiveData to manage state and trigger the dialog only when needed. This is more efficient and follows Android best practices.

Step 1: Set Up Permissions #

First, add these permissions to your AndroidManifest.xml to access WiFi and network state:

<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

Step 2: Create a ViewModel to Manage WiFi State #

We’ll use a ViewModel to hold the WiFi connection status and handle monitoring. This keeps logic tied to the app’s lifecycle and prevents memory leaks:

import android.content.Context
import android.net.wifi.WifiManager
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.launch

class WifiMonitorViewModel : ViewModel() {
    private val _isConnectedToTarget = MutableLiveData<Boolean>()
    val isConnectedToTarget: LiveData<Boolean> = _isConnectedToTarget

    // Replace with your target WiFi SSID
    private val TARGET_WIFI_SSID = "YourRequiredWiFiName"

    fun startMonitoring(context: Context) {
        // Initial check when monitoring starts
        updateConnectionStatus(context)
        
        // Use NetworkCallback (Android 7+) for reliable state updates (better than BroadcastReceiver)
        val connectivityManager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as android.net.ConnectivityManager
        val networkCallback = object : android.net.ConnectivityManager.NetworkCallback() {
            override fun onAvailable(network: android.net.Network) {
                updateConnectionStatus(context)
            }

            override fun onLost(network: android.net.Network) {
                updateConnectionStatus(context)
            }

            override fun onCapabilitiesChanged(
                network: android.net.Network,
                networkCapabilities: android.net.NetworkCapabilities
            ) {
                updateConnectionStatus(context)
            }
        }

        // Register callback to listen for WiFi changes
        connectivityManager.registerNetworkCallback(
            android.net.NetworkRequest.Builder()
                .addTransportType(android.net.NetworkCapabilities.TRANSPORT_WIFI)
                .build(),
            networkCallback
        )

        // Clean up callback when ViewModel is destroyed
        viewModelScope.launch {
            lifecycle.repeatOnLifecycle(androidx.lifecycle.Lifecycle.State.DESTROYED) {
                connectivityManager.unregisterNetworkCallback(networkCallback)
            }
        }
    }

    private fun updateConnectionStatus(context: Context) {
        val wifiManager = context.getSystemService(Context.WIFI_SERVICE) as WifiManager
        val connectionInfo = wifiManager.connectionInfo
        
        // Check if connected to target SSID (strip quotes from SSID string)
        val isConnected = if (connectionInfo.networkId != -1) {
            val currentSsid = connectionInfo.ssid.replace("\"", "")
            currentSsid == TARGET_WIFI_SSID
        } else {
            false
        }
        
        _isConnectedToTarget.postValue(isConnected)
    }
}

Step 3: Handle the AlertDialog in Your Activity/Fragment #

Now observe the WiFi state in your UI component and show/dismiss the dialog accordingly:

import android.content.Intent
import android.net.Uri
import android.os.Bundle
import android.provider.Settings
import androidx.appcompat.app.AlertDialog
import androidx.appcompat.app.AppCompatActivity
import androidx.lifecycle.ViewModelProvider

class MainActivity : AppCompatActivity() {
    private lateinit var viewModel: WifiMonitorViewModel
    private var wifiDialog: AlertDialog? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        viewModel = ViewModelProvider(this)[WifiMonitorViewModel::class.java]
        viewModel.startMonitoring(this)

        // Observe WiFi state changes
        viewModel.isConnectedToTarget.observe(this) { isConnected ->
            if (!isConnected) {
                showRequiredWifiDialog()
            } else {
                dismissWifiDialog()
            }
        }
    }

    private fun showRequiredWifiDialog() {
        // Avoid showing multiple dialogs
        if (wifiDialog?.isShowing == true) return

        wifiDialog = AlertDialog.Builder(this)
            .setTitle("Connect to Required WiFi")
            .setMessage("Please connect to \"YourRequiredWiFiName\" to use this app.")
            .setPositiveButton("Go to WiFi Settings") { _, _ ->
                // Send user directly to WiFi settings
                startActivity(Intent(Settings.ACTION_WIFI_SETTINGS))
            }
            .setCancelable(false) // Prevent user from dismissing without connecting
            .create()
        
        wifiDialog?.show()
    }

    private fun dismissWifiDialog() {
        wifiDialog?.dismiss()
        wifiDialog = null
    }

    override fun onDestroy() {
        super.onDestroy()
        dismissWifiDialog()
    }
}

Why This Is Better Than Your Original Idea #

• No polling waste: We rely on Android’s system callbacks to trigger checks only when WiFi state changes, saving battery and resources.
• Lifecycle-safe: The ViewModel handles cleanup of network listeners, so you don’t get memory leaks.
• Smooth UI flow: The dialog only shows when needed, and the "Go to Settings" button gives users a direct action to fix the issue.
• Avoids ANRs: No infinite loops checking WiFi state—we let the system notify us instead.

内容的提问来源于stack exchange，提问作者flexcookie