✨ 네트워크 연결 상태 가져오는 네트워크 콜백 구현

Author: bngsh

presentation/src/main/java/com/whyranoid/presentation/runningstart/RunningStartFragment.kt

@@ -65,8 +65,15 @@ internal class RunningStartFragment :
         observeState()
     }
 
+    override fun onDestroyView() {
+        viewModel.finishObservingNetworkState()
+        super.onDestroyView()
+    }
+
     private fun initViews() {
         binding.vm = viewModel
+        binding.executePendingBindings()
+
         if ((viewModel.runningDataManager.runningState.value is RunningState.NotRunning).not()) {
             runningActivityLauncher.launch(
                 Intent(
@@ -78,6 +85,7 @@ internal class RunningStartFragment :
     }
 
     private fun observeState() {
+        viewModel.startObservingNetworkState()
         viewLifecycleOwner.repeatWhenUiStarted {
             viewModel.runnerCount.collect { runnerCount ->
                 binding.tvRunnerCountNumber.text = runnerCount.toString()

presentation/src/main/java/com/whyranoid/presentation/runningstart/RunningStartViewModel.kt

@@ -4,22 +4,34 @@ import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.whyranoid.domain.usecase.GetRunnerCountUseCase
 import com.whyranoid.presentation.util.networkconnection.NetworkConnectionStateHolder
+import com.whyranoid.presentation.util.networkconnection.NetworkState
 import com.whyranoid.runningdata.RunningDataManager
 import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.FlowPreview
 import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.asSharedFlow
+import kotlinx.coroutines.flow.debounce
+import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
 import javax.inject.Inject
 
 @HiltViewModel
 class RunningStartViewModel @Inject constructor(
     getRunnerCountUseCase: GetRunnerCountUseCase,
-    networkConnectionStateHolder: NetworkConnectionStateHolder
+    private val networkConnectionStateHolder: NetworkConnectionStateHolder
 ) : ViewModel() {
 
     val runningDataManager = RunningDataManager.getInstance()
 
-    val networkState = networkConnectionStateHolder.networkState
+    @OptIn(FlowPreview::class)
+    val networkState = networkConnectionStateHolder.networkConnectionState
+        .debounce(500)
+        .stateIn(
+            scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5000),
+            initialValue = NetworkState.UnInitialized
+        )
 
     val runnerCount = getRunnerCountUseCase()
 
@@ -37,4 +49,12 @@ class RunningStartViewModel @Inject constructor(
             _eventFlow.emit(event)
         }
     }
+
+    fun startObservingNetworkState() {
+        networkConnectionStateHolder.startObservingState()
+    }
+
+    fun finishObservingNetworkState() {
+        networkConnectionStateHolder.finishObservingState()
+    }
 }

presentation/src/main/java/com/whyranoid/presentation/util/networkconnection/NetworkConnectionStateHolder.kt

@@ -5,27 +5,68 @@ import android.content.Context
 import android.content.Intent
 import android.content.IntentFilter
 import android.net.ConnectivityManager
+import android.net.ConnectivityManager.NetworkCallback
+import android.net.Network
+import android.net.NetworkCapabilities
+import android.os.Build
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.asStateFlow
 
-class NetworkConnectionStateHolder(context: Context) {
+class NetworkConnectionStateHolder(private val context: Context) {
 
-    private val _networkState = MutableStateFlow<NetworkState>(NetworkState.UnInitialized)
-    val networkState: StateFlow<NetworkState> get() = _networkState.asStateFlow()
+    private val _networkConnectionState = MutableStateFlow<NetworkState>(NetworkState.UnInitialized)
+    val networkConnectionState: StateFlow<NetworkState> = _networkConnectionState
 
-    private val networkReceiver = object : BroadcastReceiver() {
-        override fun onReceive(context: Context, intent: Intent) {
-            _networkState.value =
-                if (context.isConnected) NetworkState.Connection else NetworkState.DisConnection
+    private val connectivityManager =
+        context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+    private val connectivityCallback = object : NetworkCallback() {
+        override fun onAvailable(network: Network) {
+            emitNetworkConnectionState(NetworkState.Connection)
+        }
+
+        override fun onLost(network: Network) {
+            emitNetworkConnectionState(NetworkState.DisConnection)
+        }
+    }
+    private val connectivityReceiver = object : BroadcastReceiver() {
+        override fun onReceive(context: Context?, intent: Intent?) {
+            if (context != null && context.isConnected) {
+                emitNetworkConnectionState(NetworkState.Connection)
+            } else {
+                emitNetworkConnectionState(NetworkState.DisConnection)
+            }
+        }
+    }
+
+    fun startObservingState() {
+        val networkCapabilities =
+            connectivityManager.getNetworkCapabilities(connectivityManager.activeNetwork)
+        if (networkCapabilities?.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET) == true) {
+            emitNetworkConnectionState(NetworkState.Connection)
+        } else {
+            emitNetworkConnectionState(NetworkState.DisConnection)
+        }
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+            connectivityManager.registerDefaultNetworkCallback(connectivityCallback)
+        } else {
+            context.registerReceiver(
+                connectivityReceiver,
+                IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION)
+            )
+        }
+    }
+
+    fun finishObservingState() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+            connectivityManager.unregisterNetworkCallback(connectivityCallback)
+        } else {
+            context.unregisterReceiver(connectivityReceiver)
         }
     }
 
-    init {
-        context.registerReceiver(
-            networkReceiver,
-            IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION)
-        )
+    private fun emitNetworkConnectionState(currentState: NetworkState) {
+        _networkConnectionState.value = currentState
     }
 }