네트워트 연결 상태 Repository로 구현

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/community/runningpost/CreateRunningPostFragment.kt

@@ -25,13 +25,20 @@ internal class CreateRunningPostFragment :
         observeState()
     }
 
+    override fun onDestroyView() {
+        viewModel.finishObservingNetworkState()
+        super.onDestroyView()
+    }
+
     private fun initViews() {
         binding.vm = viewModel
         binding.selectedRunningHistory = viewModel.selectedRunningHistory
+        binding.executePendingBindings()
         setUpMenu()
     }
 
     private fun observeState() {
+        viewModel.startObservingNetworkState()
         viewLifecycleOwner.repeatWhenUiStarted {
             viewModel.createPostState.collect { createPostState ->
                 when (createPostState) {

presentation/src/main/java/com/whyranoid/presentation/community/runningpost/CreateRunningPostViewModel.kt

@@ -3,14 +3,19 @@ package com.whyranoid.presentation.community.runningpost
 import androidx.lifecycle.SavedStateHandle
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
+import com.whyranoid.domain.repository.NetworkRepository
 import com.whyranoid.domain.usecase.CreateRunningPostUseCase
 import com.whyranoid.presentation.model.RunningHistoryUiModel
 import com.whyranoid.presentation.model.UiState
+import com.whyranoid.presentation.util.networkconnection.NetworkState
 import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.FlowPreview
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.debounce
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
@@ -19,6 +24,7 @@ import javax.inject.Inject
 @HiltViewModel
 class CreateRunningPostViewModel @Inject constructor(
     private val createRunningPostUseCase: CreateRunningPostUseCase,
+    private val networkRepository: NetworkRepository,
     savedState: SavedStateHandle
 ) : ViewModel() {
 
@@ -27,8 +33,8 @@ class CreateRunningPostViewModel @Inject constructor(
     val runningPostContent = MutableStateFlow<String?>(null)
 
     val createPostButtonEnableState: StateFlow<Boolean>
-        get() = runningPostContent.map { content ->
-            content.isNullOrBlank().not()
+        get() = runningPostContent.combine(networkState) { content, networkState ->
+            content.isNullOrBlank().not() && networkState is NetworkState.Connection
         }.stateIn(
             initialValue = false,
             started = SharingStarted.WhileSubscribed(5000),
@@ -39,6 +45,18 @@ class CreateRunningPostViewModel @Inject constructor(
     val createPostState: StateFlow<UiState<Boolean>>
         get() = _createPostState.asStateFlow()
 
+    @OptIn(FlowPreview::class)
+    val networkState = networkRepository.getNetworkConnectionState()
+        .map { isConnected ->
+            if (isConnected) NetworkState.Connection else NetworkState.DisConnection
+        }
+        .debounce(500)
+        .stateIn(
+            scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5000),
+            initialValue = NetworkState.UnInitialized
+        )
+
     fun createRunningPost() {
         viewModelScope.launch {
             _createPostState.value = UiState.Loading
@@ -56,6 +74,14 @@ class CreateRunningPostViewModel @Inject constructor(
         }
     }
 
+    fun startObservingNetworkState() {
+        networkRepository.addNetworkConnectionCallback()
+    }
+
+    fun finishObservingNetworkState() {
+        networkRepository.removeNetworkConnectionCallback()
+    }
+
     companion object {
         private const val RUNNING_HISTORY_SAFE_ARGS_KEY = "selectedRunningHistory"
     }

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

@@ -2,24 +2,40 @@ 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
+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.map
+import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
 import javax.inject.Inject
 
 @HiltViewModel
 class RunningStartViewModel @Inject constructor(
     getRunnerCountUseCase: GetRunnerCountUseCase,
-    networkConnectionStateHolder: NetworkConnectionStateHolder
+    private val networkRepository: NetworkRepository
 ) : ViewModel() {
 
     val runningDataManager = RunningDataManager.getInstance()
 
-    val networkState = networkConnectionStateHolder.networkState
+    @OptIn(FlowPreview::class)
+    val networkState = networkRepository.getNetworkConnectionState()
+        .map { isConnected ->
+            if (isConnected) NetworkState.Connection else NetworkState.DisConnection
+        }
+        .debounce(500)
+        .stateIn(
+            scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5000),
+            initialValue = NetworkState.UnInitialized
+        )
 
     val runnerCount = getRunnerCountUseCase()
 
@@ -37,4 +53,12 @@ class RunningStartViewModel @Inject constructor(
             _eventFlow.emit(event)
         }
     }
+
+    fun startObservingNetworkState() {
+        networkRepository.addNetworkConnectionCallback()
+    }
+
+    fun finishObservingNetworkState() {
+        networkRepository.removeNetworkConnectionCallback()
+    }
 }

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
     }
 }