✨ 네트워크 연결 상태를 repository로 노출

Author: bngsh

data/src/main/AndroidManifest.xml

@@ -1,4 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
 
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
 </manifest>

data/src/main/java/com/whyranoid/data/di/ConnectionModule.kt

@@ -0,0 +1,22 @@
+package com.whyranoid.data.di
+
+import android.content.Context
+import com.whyranoid.data.running.NetworkRepositoryImpl
+import com.whyranoid.domain.repository.NetworkRepository
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.components.SingletonComponent
+import javax.inject.Singleton
+
+@Module
+@InstallIn(SingletonComponent::class)
+class ConnectionModule {
+
+    @Provides
+    @Singleton
+    fun provideNetworkRepository(@ApplicationContext context: Context): NetworkRepository {
+        return NetworkRepositoryImpl(context)
+    }
+}

data/src/main/java/com/whyranoid/data/running/NetworkRepositoryImpl.kt

@@ -0,0 +1,78 @@
+package com.whyranoid.data.running
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.net.ConnectivityManager
+import android.net.Network
+import android.net.NetworkCapabilities
+import android.os.Build
+import com.whyranoid.domain.repository.NetworkRepository
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+
+class NetworkRepositoryImpl(private val context: Context) :
+    NetworkRepository {
+
+    private val _networkConnectionState = MutableStateFlow(getCurrentNetwork())
+    override fun getNetworkConnectionState() = _networkConnectionState.asStateFlow()
+
+    private val connectivityManager =
+        context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+
+    private val connectivityCallback = object : ConnectivityManager.NetworkCallback() {
+        override fun onAvailable(network: Network) {
+            emitNetworkConnectionState(true)
+        }
+
+        override fun onLost(network: Network) {
+            emitNetworkConnectionState(false)
+        }
+    }
+    private val connectivityReceiver = object : BroadcastReceiver() {
+        override fun onReceive(context: Context?, intent: Intent?) {
+            if (context != null && context.isConnected) {
+                emitNetworkConnectionState(true)
+            } else {
+                emitNetworkConnectionState(false)
+            }
+        }
+    }
+
+    override fun addNetworkConnectionCallback() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+            connectivityManager.registerDefaultNetworkCallback(connectivityCallback)
+        } else {
+            context.registerReceiver(
+                connectivityReceiver,
+                IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION)
+            )
+        }
+    }
+
+    override fun removeNetworkConnectionCallback() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+            connectivityManager.unregisterNetworkCallback(connectivityCallback)
+        } else {
+            context.unregisterReceiver(connectivityReceiver)
+        }
+    }
+
+    private fun getCurrentNetwork(): Boolean {
+        return try {
+            val networkCapabilities =
+                connectivityManager.getNetworkCapabilities(connectivityManager.activeNetwork)
+            networkCapabilities?.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET) == true
+        } catch (e: Exception) {
+            false
+        }
+    }
+
+    private fun emitNetworkConnectionState(currentState: Boolean) {
+        _networkConnectionState.value = currentState
+    }
+}
+
+val Context.isConnected: Boolean
+    get() = (getSystemService(Context.CONNECTIVITY_SERVICE) as? ConnectivityManager)?.activeNetworkInfo?.isConnected == true

domain/src/main/java/com/whyranoid/domain/repository/NetworkRepository.kt

@@ -0,0 +1,12 @@
+package com.whyranoid.domain.repository
+
+import kotlinx.coroutines.flow.StateFlow
+
+interface NetworkRepository {
+
+    fun getNetworkConnectionState(): StateFlow<Boolean>
+
+    fun addNetworkConnectionCallback()
+
+    fun removeNetworkConnectionCallback()
+}

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

@@ -2,8 +2,8 @@ package com.whyranoid.presentation.runningstart
 
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
+import com.whyranoid.domain.repository.NetworkRepository
 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
@@ -12,20 +12,24 @@ import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.asSharedFlow
 import kotlinx.coroutines.flow.debounce
+import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
 import javax.inject.Inject
 
 @HiltViewModel
 class RunningStartViewModel @Inject constructor(
     getRunnerCountUseCase: GetRunnerCountUseCase,
-    private val networkConnectionStateHolder: NetworkConnectionStateHolder
+    private val networkRepository: NetworkRepository
 ) : ViewModel() {
 
     val runningDataManager = RunningDataManager.getInstance()
 
     @OptIn(FlowPreview::class)
-    val networkState = networkConnectionStateHolder.networkConnectionState
+    val networkState = networkRepository.getNetworkConnectionState()
+        .map { isConnected ->
+            if (isConnected) NetworkState.Connection else NetworkState.DisConnection
+        }
         .debounce(500)
         .stateIn(
             scope = viewModelScope,
@@ -51,10 +55,10 @@ class RunningStartViewModel @Inject constructor(
     }
 
     fun startObservingNetworkState() {
-        networkConnectionStateHolder.startObservingState()
+        networkRepository.addNetworkConnectionCallback()
     }
 
     fun finishObservingNetworkState() {
-        networkConnectionStateHolder.finishObservingState()
+        networkRepository.removeNetworkConnectionCallback()
     }
 }