diff --git a/NetworkX/src/main/java/com/rommansabbir/networkx/NetworkSpeedType.kt b/NetworkX/src/main/java/com/rommansabbir/networkx/NetworkSpeedType.kt index 5387ab4..b644582 100644 --- a/NetworkX/src/main/java/com/rommansabbir/networkx/NetworkSpeedType.kt +++ b/NetworkX/src/main/java/com/rommansabbir/networkx/NetworkSpeedType.kt @@ -4,4 +4,5 @@ object NetworkSpeedType { const val GB = "GB" const val MB = "MB" const val KB = "KB" + const val NONE = "NONE" } \ No newline at end of file diff --git a/NetworkX/src/main/java/com/rommansabbir/networkx/NetworkXProvider.kt b/NetworkX/src/main/java/com/rommansabbir/networkx/NetworkXProvider.kt index a8730d8..8332517 100644 --- a/NetworkX/src/main/java/com/rommansabbir/networkx/NetworkXProvider.kt +++ b/NetworkX/src/main/java/com/rommansabbir/networkx/NetworkXProvider.kt @@ -5,6 +5,11 @@ import android.os.Handler import android.os.Looper import androidx.lifecycle.LiveData import androidx.lifecycle.MutableLiveData +import com.rommansabbir.networkx.extension.getDefaultIOScope +import com.rommansabbir.networkx.extension.getDefaultLastKnownSpeed +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.launch object NetworkXProvider { /** @@ -29,6 +34,9 @@ object NetworkXProvider { Handler(Looper.getMainLooper()).post { connected = value isInternetConnectedMutableLiveData.value = value + getDefaultIOScope.launch { + isInternetConnectedFlow.emit(value) + } } } } @@ -44,20 +52,27 @@ object NetworkXProvider { */ private var isInternetConnectedMutableLiveData: MutableLiveData = MutableLiveData() + val isInternetConnectedLiveData: LiveData get() = isInternetConnectedMutableLiveData + val isInternetConnectedFlow: MutableStateFlow = MutableStateFlow(connected) + // Store last known speed - private var lastKnownSpeedRef: LastKnownSpeed? = null + private var lastKnownSpeedRef: LastKnownSpeed = getDefaultLastKnownSpeed /** * Public access point to get the last known network speed */ - val lastKnownSpeed: LastKnownSpeed? + val lastKnownSpeed: LastKnownSpeed get() = lastKnownSpeedRef - private val lastKnownSpeedLiveDataRef: MutableLiveData = MutableLiveData(null) + private val lastKnownSpeedLiveDataRef: MutableLiveData = + MutableLiveData(getDefaultLastKnownSpeed) + + val lastKnownSpeedFlow: MutableStateFlow = + MutableStateFlow(getDefaultLastKnownSpeed) /** * Public access point to get the last known network speed which can be observed from Activity/Fragment. @@ -69,6 +84,9 @@ object NetworkXProvider { synchronized(value) { lastKnownSpeedRef = value lastKnownSpeedLiveDataRef.value = value + getDefaultIOScope.launch { + lastKnownSpeedFlow.emit(value) + } } } @@ -79,7 +97,10 @@ object NetworkXProvider { * * @param application, [Application] reference */ - @Deprecated("Use NetworkXProvider.enable(config: NetworkXConfig) to initialize NetworkX properly") + @Deprecated( + "Use NetworkXProvider.enable(config: NetworkXConfig) to initialize NetworkX properly", + replaceWith = ReplaceWith("NetworkXProvider.enable(NetworkXConfig.Builder().withApplication(this).withEnableSpeedMeter(true).build())") + ) fun init(application: Application, enableSpeedMeter: Boolean = false) { try { if (manager != null) { @@ -96,7 +117,7 @@ object NetworkXProvider { * First check for [NetworkXManager] instance, if the status is null then initialize it properly * else ignore the initialization. * - * @param config, [NetworkXConfig] reference + * @param config [NetworkXConfig] reference. */ fun enable(config: NetworkXConfig) { try { diff --git a/NetworkX/src/main/java/com/rommansabbir/networkx/extension/NetworkXExtensions.kt b/NetworkX/src/main/java/com/rommansabbir/networkx/extension/NetworkXExtensions.kt new file mode 100644 index 0000000..0bca019 --- /dev/null +++ b/NetworkX/src/main/java/com/rommansabbir/networkx/extension/NetworkXExtensions.kt @@ -0,0 +1,59 @@ +package com.rommansabbir.networkx.extension + +import androidx.lifecycle.LiveData +import com.rommansabbir.networkx.LastKnownSpeed +import com.rommansabbir.networkx.NetworkSpeedType +import com.rommansabbir.networkx.NetworkXConfig +import com.rommansabbir.networkx.NetworkXProvider +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.flow.MutableStateFlow + +/** + * Return if internet is connected or not. + */ +val isInternetConnected: Boolean = NetworkXProvider.isInternetConnected + +/** + * Return if internet is connected or not as [LiveData]. + */ +val isInternetConnectedLiveData: LiveData = NetworkXProvider.isInternetConnectedLiveData + +/** + * Return if internet is connected or not as [MutableStateFlow]. + */ +val isInternetConnectedFlow: MutableStateFlow = NetworkXProvider.isInternetConnectedFlow + +/** + * Return [LastKnownSpeed]. + */ +val lastKnownSpeed: LastKnownSpeed = NetworkXProvider.lastKnownSpeed + +/** + * Return [LastKnownSpeed] as [LiveData] + */ +val lastKnownSpeedLiveData: LiveData = NetworkXProvider.lastKnownSpeedLiveData + +/** + * Return [LastKnownSpeed] as [MutableStateFlow]. + */ +val lastKnownSpeedFlow: MutableStateFlow = NetworkXProvider.lastKnownSpeedFlow + +/** + * Return a default lazy instance of [LastKnownSpeed]. + */ +internal val getDefaultLastKnownSpeed by lazy { + LastKnownSpeed(NetworkSpeedType.NONE, NetworkSpeedType.NONE, NetworkSpeedType.NONE) +} + +/** + * Return a default lazy instance of [CoroutineScope] which works under [Dispatchers.IO]. + */ +internal val getDefaultIOScope by lazy { CoroutineScope(Dispatchers.IO) } + +/** + * Initialize [NetworkXProvider]. + * + * @param config [NetworkXConfig]. + */ +fun enableNetworkX(config: NetworkXConfig) = NetworkXProvider.enable(config) diff --git a/README.md b/README.md index c06da25..46c72e2 100644 --- a/README.md +++ b/README.md @@ -34,7 +34,7 @@ Step 2. Add the dependency. | Releases | ------------- | -| 3.3.0 | +| 3.4.0 | # Usages @@ -51,52 +51,34 @@ Initialize `NetworkX` from your `Application.onCreate()` ```` ## Step 2: -- To check internet connection status, simply call `NetworkXProvider.isInternetConnected` which return a `Boolean` value. +- To check Internet Connection status, simply call extension variable +`isInternetConnected` or `isInternetConnectedLiveData` or `isInternetConnectedFlow`. ```` - val status = NetworkXProvider.isInternetConnected - textView.text = "Internet connection status: $status" -```` - -- To observe the internet connection status, start observing `NetworkXProvider.isInternetConnectedLiveData` - -```` - NetworkXProvider.isInternetConnectedLiveData.observe(this) { status -> - status?.let { +isInternetConnectedFlow.collectLatest { + lifecycleScope.launch { textView.text = "Internet connection status: $it" } } ```` -- To get connected network speed/last known speed call `NetworkXProvider.lastKnownSpeed` which return an `LastKnownSpeed` object +- To get connected network speed/last known speed [`LastKnownSpeed`] call extension variable +`lastKnownSpeed` or `lastKnownSpeedLiveData` or `lastKnownSpeedFlow` ```` - NetworkXProvider.lastKnownSpeed?.let { - textView2.text = - "Last Known Speed: Speed - ${it.speed} | Type - ${it.networkTypeNetwork} | Simplified Speed - ${it.simplifiedSpeed}" - } -```` - -- To obsever current network speed/last known speed start observing `NetworkXProvider.lastKnownSpeedLiveData` - -```` - NetworkXProvider.lastKnownSpeedLiveData.observe(this) { - it?.let { - textView2.text = - "Last Known Speed: Speed - ${it.speed} | Type - ${it.networkTypeNetwork} | Simplified Speed - ${it.simplifiedSpeed}" - } - } +lastKnownSpeed?.let { + textView2.text ="S-${it.speed}|T-${it.networkTypeNetwork}|SS-${it.simplifiedSpeed}" +} ```` ## Notes: - - NetworkX (including Speed Meter) only works when the app is in the foreground - - The default value for `NetworkXProvider.isInternetConnected` is `false` - - The default value for `NetworkXProvider.isInternetConnectedLiveData` is `null` - - The default value for `NetworkXProvider.lastKnownSpeed` is `null` - - The default value for `NetworkXProvider.lastKnownSpeedLiveData` is `null` + - **NetworkX** (including **Speed Meter**) only works when the **Application** is in the **Forground Only**. + - To emit (**`MutableStateFlow`**) **Last Known Speed** or **Internet Connection Status**,required **`CoroutineScope`** works under a **`Dispatchers.IO`** context. + - The default value for **Internet Connection Status** is `false`. + - The default value for **LastKnownSpeed** is `NONE`. --- -### How to show the `NoInternetDialog`? +### How to show the **`NoInternetDialog`**? ```kotlin NoInternetDialog diff --git a/app/src/main/java/com/rommansabbir/networkobserverexample/MainActivity.kt b/app/src/main/java/com/rommansabbir/networkobserverexample/MainActivity.kt index 4897520..aef5054 100644 --- a/app/src/main/java/com/rommansabbir/networkobserverexample/MainActivity.kt +++ b/app/src/main/java/com/rommansabbir/networkobserverexample/MainActivity.kt @@ -3,8 +3,13 @@ package com.rommansabbir.networkobserverexample import android.annotation.SuppressLint import android.os.Bundle import androidx.appcompat.app.AppCompatActivity +import androidx.lifecycle.lifecycleScope import com.rommansabbir.networkx.NetworkXProvider +import com.rommansabbir.networkx.NetworkXProvider.isInternetConnectedFlow +import com.rommansabbir.networkx.NetworkXProvider.lastKnownSpeedFlow import kotlinx.android.synthetic.main.activity_main.* +import kotlinx.coroutines.flow.collect +import kotlinx.coroutines.launch class MainActivity : AppCompatActivity() { @SuppressLint("SetTextI18n") @@ -15,25 +20,58 @@ class MainActivity : AppCompatActivity() { val status = NetworkXProvider.isInternetConnected textView.text = "Internet connection status: $status" - // +/* // NetworkXProvider.isInternetConnectedLiveData.observe(this) { status -> status?.let { textView.text = "Internet connection status: $it" } - } + }*/ - NetworkXProvider.lastKnownSpeed?.let { +/* NetworkXProvider.lastKnownSpeed.let { textView2.text = "Last Known Speed: Speed - ${it.speed} | Type - ${it.networkTypeNetwork} | Simplified Speed - ${it.simplifiedSpeed}" - } + }*/ + lifecycleScope.launchWhenCreated { + try { + lastKnownSpeedFlow.collect { + lifecycleScope.launch { + textView2.text = + "Last Known Speed: Speed - ${it.speed} | Type - ${it.networkTypeNetwork} | Simplified Speed - ${it.simplifiedSpeed}" + } + } + } catch (e: Exception) { + e.printStackTrace() + } + } + lifecycleScope.launchWhenCreated { + try { + isInternetConnectedFlow.collect { + lifecycleScope.launch { + textView.text = "Internet connection status: $it" + } + } + } + catch (e : Exception){ + e.printStackTrace() + } + } +/* NetworkXProvider.lastKnownSpeedLiveData.observe(this) { it?.let { textView2.text = "Last Known Speed: Speed - ${it.speed} | Type - ${it.networkTypeNetwork} | Simplified Speed - ${it.simplifiedSpeed}" } } +*/ - } +/* lifecycleScope.launchWhenCreated { + NetworkXProvider.isInternetConnectedFlow.collectLatest { + lifecycleScope.launch { + textView.text = "Internet connection status: $it" + } + } + }*/ + } } \ No newline at end of file diff --git a/app/src/main/java/com/rommansabbir/networkobserverexample/MyApplication.kt b/app/src/main/java/com/rommansabbir/networkobserverexample/MyApplication.kt index c61fd69..03cbf75 100644 --- a/app/src/main/java/com/rommansabbir/networkobserverexample/MyApplication.kt +++ b/app/src/main/java/com/rommansabbir/networkobserverexample/MyApplication.kt @@ -11,13 +11,13 @@ class MyApplication : Application() { override fun onCreate() { super.onCreate() -// NetworkXProvider.init(this, true) + /*NetworkXProvider.init(this, true)*/ /** * Initialize NetworkX */ - val builder = NetworkXConfig.Builder() + val builder = NetworkXConfig + .Builder() .withApplication(this) - // You can disable speed meter if not required .withEnableSpeedMeter(true) .build() NetworkXProvider.enable(builder)