Move from NetworkProvider to NetworkViewModel

app/src/main/java/com/aurora/store/MainActivity.kt

@@ -24,6 +24,7 @@ import android.os.Bundle
 import android.view.View
 import androidx.activity.addCallback
 import androidx.activity.enableEdgeToEdge
+import androidx.activity.viewModels
 import androidx.appcompat.app.AppCompatActivity
 import androidx.core.view.ViewCompat
 import androidx.core.view.WindowInsetsCompat
@@ -35,13 +36,13 @@ import androidx.navigation.ui.setupWithNavController
 import com.aurora.store.data.event.BusEvent
 import com.aurora.store.data.event.InstallerEvent
 import com.aurora.store.data.model.NetworkStatus
-import com.aurora.store.data.providers.NetworkProvider
 import com.aurora.store.data.receiver.MigrationReceiver
 import com.aurora.store.databinding.ActivityMainBinding
 import com.aurora.store.util.AppUtil
 import com.aurora.store.util.Preferences
 import com.aurora.store.util.Preferences.PREFERENCE_DEFAULT_SELECTED_TAB
 import com.aurora.store.view.ui.sheets.NetworkDialogSheet
+import com.aurora.store.viewmodel.network.NetworkViewModel
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.flow.collectLatest
 import kotlinx.coroutines.launch
@@ -53,6 +54,8 @@ class MainActivity : AppCompatActivity() {
     @Inject
     lateinit var appUtil: AppUtil
 
+    private val networkViewModel: NetworkViewModel by viewModels()
+
     private lateinit var B: ActivityMainBinding
 
     // TopLevelFragments
@@ -90,29 +93,30 @@ class MainActivity : AppCompatActivity() {
             supportFragmentManager.findFragmentById(R.id.nav_host_fragment) as NavHostFragment
         val navController = navHostFragment.navController
 
-        this.lifecycleScope.launch {
-            NetworkProvider(applicationContext).networkStatus.collect {
-                when (it) {
-                    NetworkStatus.AVAILABLE -> {
-                        if (!supportFragmentManager.isDestroyed && isIntroDone()) {
-                            val fragment = supportFragmentManager
-                                .findFragmentByTag(NetworkDialogSheet.TAG)
-                            fragment?.let {
-                                supportFragmentManager.beginTransaction()
-                                    .remove(fragment)
-                                    .commitAllowingStateLoss()
-                            }
-                        }
-                    }
-
-                    NetworkStatus.LOST -> {
-                        if (!supportFragmentManager.isDestroyed && isIntroDone()) {
+        networkViewModel.register()
+        networkViewModel.status.observe(this) { networkStatus ->
+            when (networkStatus) {
+                NetworkStatus.AVAILABLE -> {
+                    if (!supportFragmentManager.isDestroyed && isIntroDone()) {
+                        val fragment = supportFragmentManager
+                            .findFragmentByTag(NetworkDialogSheet.TAG)
+                        fragment?.let {
                             supportFragmentManager.beginTransaction()
-                                .add(NetworkDialogSheet.newInstance(), NetworkDialogSheet.TAG)
+                                .remove(fragment)
                                 .commitAllowingStateLoss()
                         }
                     }
                 }
+
+                NetworkStatus.LOST -> {
+                    if (!supportFragmentManager.isDestroyed && isIntroDone()) {
+                        supportFragmentManager.beginTransaction()
+                            .add(NetworkDialogSheet.newInstance(), NetworkDialogSheet.TAG)
+                            .commitAllowingStateLoss()
+                    }
+                }
+
+                else -> {}
             }
         }
 
@@ -176,6 +180,11 @@ class MainActivity : AppCompatActivity() {
         }
     }
 
+    override fun onDestroy() {
+        networkViewModel.unregister()
+        super.onDestroy()
+    }
+
     private fun isIntroDone(): Boolean {
         return Preferences.getBoolean(this@MainActivity, Preferences.PREFERENCE_INTRO)
     }

app/src/main/java/com/aurora/store/data/model/NetworkStatus.kt

@@ -2,5 +2,6 @@ package com.aurora.store.data.model
 
 enum class NetworkStatus {
     AVAILABLE,
+    UNAVAILABLE,
     LOST
 }

app/src/main/java/com/aurora/store/viewmodel/network/NetworkViewModel.kt

@@ -17,49 +17,47 @@
  *
  */
 
-package com.aurora.store.data.providers
+package com.aurora.store.viewmodel.network
 
 import android.content.Context
 import android.net.ConnectivityManager
 import android.net.Network
 import android.net.NetworkCapabilities
 import android.net.NetworkRequest
-import android.util.Log
+import androidx.lifecycle.MutableLiveData
+import androidx.lifecycle.ViewModel
 import com.aurora.extensions.isMAndAbove
-import com.aurora.store.AuroraApp
 import com.aurora.store.data.model.NetworkStatus
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.launchIn
+import dagger.hilt.android.lifecycle.HiltViewModel
+import dagger.hilt.android.qualifiers.ApplicationContext
+import javax.inject.Inject
 
-class NetworkProvider(context: Context) {
-
-    private val TAG = NetworkProvider::class.java.simpleName
-
-    private val _networkStatus = MutableStateFlow(NetworkStatus.AVAILABLE)
-    val networkStatus = _networkStatus.asStateFlow()
+@HiltViewModel
+class NetworkViewModel @Inject constructor(
+    @ApplicationContext private val context: Context
+) : ViewModel() {
+    val status: MutableLiveData<NetworkStatus> = MutableLiveData(NetworkStatus.UNAVAILABLE)
 
     private val connectivityManager =
         context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+    private val networkCallback = object : ConnectivityManager.NetworkCallback() {
+        override fun onAvailable(network: Network) {
+            super.onAvailable(network)
+            status.postValue(NetworkStatus.AVAILABLE)
+        }
 
-    init {
-        networkStatus.launchIn(AuroraApp.scope)
+        override fun onLost(network: Network) {
+            super.onLost(network)
+            status.postValue(NetworkStatus.LOST)
+        }
+    }
 
-        // Monitor network
-        connectivityManager.registerNetworkCallback(getNetworkRequest(),
-            object : ConnectivityManager.NetworkCallback() {
-                override fun onAvailable(network: Network) {
-                    super.onAvailable(network)
-                    Log.d(TAG, "Network available!")
-                    _networkStatus.value = NetworkStatus.AVAILABLE
-                }
+    fun register() {
+        connectivityManager.registerNetworkCallback(getNetworkRequest(), networkCallback)
+    }
 
-                override fun onLost(network: Network) {
-                    super.onLost(network)
-                    Log.d(TAG, "Network unavailable!")
-                    _networkStatus.value = NetworkStatus.LOST
-                }
-            })
+    fun unregister() {
+        connectivityManager.unregisterNetworkCallback(networkCallback)
     }
 
     private fun getNetworkRequest(): NetworkRequest {
@@ -69,6 +67,7 @@ class NetworkProvider(context: Context) {
         if (isMAndAbove()) {
             networkRequest.addCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)
         }
-        return  networkRequest.build()
+
+        return networkRequest.build()
     }
-}
+}