NetworkStatusTracker_full.kt

@AndroidEntryPoint
class MainActivity : AppCompatActivity() {
    private lateinit var binding: ActivityMainBinding

    private val activityViewModel: ShearedViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityMainBinding.inflate(layoutInflater)
        setContentView(binding.root)

       lifecycleScope.launch {
           repeatOnLifecycle(Lifecycle.State.STARTED){
               activityViewModel.networkState.collect{
                   when(it){
                      is NetworkStatus.Available -> Timber.tag("mahdiTest").d("networkAvailable")
                       is NetworkStatus.Unavailable-> Timber.tag("mahdiTest").d("networkUnAvailable")
                   }
               }
           }
       }

    }
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////
@HiltViewModel
class ShearedViewModel @Inject constructor(
    //private val repository: Repository,
    private val networkStatusTracker: NetworkStatusTracker
) : ViewModel() {

    private val _networkState: MutableStateFlow<NetworkStatus> =
        MutableStateFlow(NetworkStatus.Unavailable)
    val networkState = _networkState.asStateFlow()

    init {
        viewModelScope.launch {
            networkStatusTracker.networkStatus.collectLatest {
                _networkState.emit(it)
            }
        }
    }
    /////////////////////////////////////////////////////////////////////////////////////
    @Provides
    @Singleton
    fun provideNetworkState(
        @ApplicationContext context: Context
    ) = NetworkStatusTracker(context)
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////

sealed class NetworkStatus {
    object Available : NetworkStatus()
    object Unavailable : NetworkStatus()
}

class NetworkStatusTracker @Inject constructor(context: Context) {
    private val connectivityManager =
        context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager

    val validNetworkConnections= ArrayList<Network>()

    val networkStatus = callbackFlow<NetworkStatus> {
            val networkStatusCallback = object : ConnectivityManager.NetworkCallback() {
                override fun onUnavailable() {
                    if (validNetworkConnections.isEmpty()) trySend(NetworkStatus.Unavailable)
                        Timber.tag("mahdiTest").d("1overUnavailable")
                }

                override fun onAvailable(network: Network) {
                    val networkCapability = connectivityManager.getNetworkCapabilities(network)
                    val hasNetworkConnection = networkCapability?.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)?:false
                    if (hasNetworkConnection) {
                        validNetworkConnections.add(network)
                        if (validNetworkConnections.isNotEmpty()) trySend(NetworkStatus.Available)
                    }
                }

                override fun onLost(network: Network) {
                    validNetworkConnections.remove(network)
                    if (validNetworkConnections.isEmpty()) trySend(NetworkStatus.Unavailable)
                    Timber.tag("mahdiTest").d("2overUnavailable")
                }
            }
            val request = NetworkRequest.Builder()
                .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
                .build()

            connectivityManager.registerNetworkCallback(request, networkStatusCallback)

            awaitClose {
                close()
                connectivityManager.unregisterNetworkCallback(networkStatusCallback)
            }
    }

}