Wifi연결하기 질문드립니다.

Question

데이터 말고 특정 Wifi로 연결되었을때만 앱이 사용되게끔 하려 합니다.

화면에서 connectivityManager를 이용해서 connectionlivedata의 값에 따라 Text의 값을 변경하게 되어있습니다.

ConnectionLiveData에서 hasWifiCapability로 하니, Wifi를 사용하는지 안하는지 까지는 판별이 되는데, WifiNetworkSpecifier를 통해서 특정 Wifi를 사용하는지 여부에 대해서는 판별이 되지 않습니다.

혹시 해당 부분 설정해보신분 계신가요?

private const val TAG = "NetworkInfo"

class ConnectionLiveData(private val context: Context) : LiveData<Boolean>() {

    private lateinit var networkCallback: ConnectivityManager.NetworkCallback
    private lateinit var wifiNetworkSpecifier: WifiNetworkSpecifier
    private lateinit var wifiNetworkSuggestion: WifiNetworkSuggestion
    private lateinit var broadcastReceiver: BroadcastReceiver

    private val cm = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
    private val wm = context.getSystemService(Context.WIFI_SERVICE) as WifiManager

    private val validNetworks: MutableSet<Network> = HashSet()

    private fun checkValidNetworks() {
        postValue(validNetworks.size > 0)
    }

    private fun test() {
        context.registerReceiver(broadcastReceiver, intentFilter)
    }

    override fun onActive() {
        Log.d(TAG, "--->Test Here onActive")

        broadcastReceiver = createBroadCastReceiver()

        wifiNetworkSpecifier = WifiNetworkSpecifier.Builder()
            .setSsidPattern(PatternMatcher("test1234", PatternMatcher.PATTERN_PREFIX))
            .setWpa2Passphrase("00001112")
            .build()

        wifiNetworkSuggestion = WifiNetworkSuggestion.Builder()
            .setSsid("test1234")
            .setWpa2Passphrase("00001112")
            .build()

        networkCallback = createNetworkCallback()
        val networkRequest = NetworkRequest.Builder()
            .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
            .setNetworkSpecifier(wifiNetworkSpecifier)
            .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
            .addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED)
            .build()
        cm.registerNetworkCallback(networkRequest, networkCallback)
    }

    override fun onInactive() {
        cm.unregisterNetworkCallback(networkCallback)
    }

    private fun createNetworkCallback() = object : ConnectivityManager.NetworkCallback() {
        override fun onAvailable(network: Network) {
            super.onAvailable(network)
            Log.d(TAG,"onAvailable: $network")
            val suggestionList = listOf(wifiNetworkSuggestion)
            val status = wm.addNetworkSuggestions(suggestionList)
            Log.d(TAG,"onAvailable: status $status")
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                cm.bindProcessToNetwork(network)
                val networkCapabilities = cm.getNetworkCapabilities(network)
                val hasWifiCapability = networkCapabilities?.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)
                if (hasWifiCapability == true) {
                    CoroutineScope(Dispatchers.IO).launch {
                        val hasInternet = DoesNetworkHaveInternet.execute(network.socketFactory)
                        if (hasInternet) {
                            withContext(Dispatchers.Main) {
                                validNetworks.add(network)
                                checkValidNetworks()
                                test()
                            }
                        }
                    }
                }
            }
        }

        override fun onUnavailable() {
            checkValidNetworks()
        }

        override fun onLost(network: Network) {
            Log.d(TAG, "onLost: $network")
            validNetworks.remove(network)
            checkValidNetworks()
        }
    }
}