Merge pull request #12 from rommansabbir/dev

Version 3.4.0

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

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<Boolean> =
         MutableLiveData()
+
     val isInternetConnectedLiveData: LiveData<Boolean>
         get() = isInternetConnectedMutableLiveData
 
+    val isInternetConnectedFlow: MutableStateFlow<Boolean> = 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<LastKnownSpeed> = MutableLiveData(null)
+    private val lastKnownSpeedLiveDataRef: MutableLiveData<LastKnownSpeed> =
+        MutableLiveData(getDefaultLastKnownSpeed)
+
+    val lastKnownSpeedFlow: MutableStateFlow<LastKnownSpeed> =
+        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 {

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<Boolean> = NetworkXProvider.isInternetConnectedLiveData
+
+/**
+ * Return if internet is connected or not as [MutableStateFlow].
+ */
+val isInternetConnectedFlow: MutableStateFlow<Boolean> = NetworkXProvider.isInternetConnectedFlow
+
+/**
+ * Return [LastKnownSpeed].
+ */
+val lastKnownSpeed: LastKnownSpeed = NetworkXProvider.lastKnownSpeed
+
+/**
+ * Return [LastKnownSpeed] as [LiveData]
+ */
+val lastKnownSpeedLiveData: LiveData<LastKnownSpeed> = NetworkXProvider.lastKnownSpeedLiveData
+
+/**
+ * Return [LastKnownSpeed] as [MutableStateFlow].
+ */
+val lastKnownSpeedFlow: MutableStateFlow<LastKnownSpeed> = 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)

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

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"
+                }
+            }
+        }*/
 
+    }
 }

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)