Always fetch network state on process onStart

app/src/main/java/androidx/lifecycle/ProcessLifecycleAccessor.java

@@ -0,0 +1,12 @@
+package androidx.lifecycle;
+
+import android.content.Context;
+
+import androidx.annotation.NonNull;
+
+public class ProcessLifecycleAccessor {
+    public static void init(@NonNull Context context) {
+        LifecycleDispatcher.init(context);
+        ProcessLifecycleOwner.init(context);
+    }
+}

app/src/main/java/com/topjohnwu/magisk/core/App.kt

@@ -5,9 +5,14 @@ import android.app.Application
 import android.content.Context
 import android.content.res.Configuration
 import android.os.Bundle
+import androidx.lifecycle.ProcessLifecycleAccessor
 import com.topjohnwu.magisk.StubApk
 import com.topjohnwu.magisk.core.di.ServiceLocator
-import com.topjohnwu.magisk.core.utils.*
+import com.topjohnwu.magisk.core.utils.DispatcherExecutor
+import com.topjohnwu.magisk.core.utils.RootUtils
+import com.topjohnwu.magisk.core.utils.ShellInit
+import com.topjohnwu.magisk.core.utils.refreshLocale
+import com.topjohnwu.magisk.core.utils.setConfig
 import com.topjohnwu.magisk.ui.surequest.SuRequestActivity
 import com.topjohnwu.magisk.view.Notifications
 import com.topjohnwu.superuser.Shell
@@ -74,6 +79,11 @@ open class App() : Application() {
         Notifications.setup()
     }
 
+    override fun onCreate() {
+        super.onCreate()
+        ProcessLifecycleAccessor.init(this)
+    }
+
     override fun onConfigurationChanged(newConfig: Configuration) {
         if (resources.configuration.diff(newConfig) != 0) {
             resources.setConfig(newConfig)

app/src/main/java/com/topjohnwu/magisk/core/utils/NetworkObserver.kt

@@ -11,6 +11,9 @@ import android.net.NetworkRequest
 import android.os.PowerManager
 import androidx.collection.ArraySet
 import androidx.core.content.getSystemService
+import androidx.lifecycle.DefaultLifecycleObserver
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.ProcessLifecycleOwner
 import com.topjohnwu.magisk.ktx.registerRuntimeReceiver
 
 typealias ConnectionCallback = (Boolean) -> Unit
@@ -18,7 +21,7 @@ typealias ConnectionCallback = (Boolean) -> Unit
 class NetworkObserver(
     context: Context,
     private val callback: ConnectionCallback
-) {
+): DefaultLifecycleObserver {
     private val manager = context.getSystemService<ConnectivityManager>()!!
 
     private val networkCallback = object : ConnectivityManager.NetworkCallback() {
@@ -44,27 +47,33 @@ class NetworkObserver(
             if (context.isIdleMode()) {
                 callback(false)
             } else {
-                getCurrentState()
+                postCurrentState()
             }
         }
     }
 
     init {
-        val builder = NetworkRequest.Builder()
+        val request = NetworkRequest.Builder()
-        builder.addCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)
+            .addCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)
-        manager.registerNetworkCallback(builder.build(), networkCallback)
+            .build()
+        manager.registerNetworkCallback(request, networkCallback)
         val filter = IntentFilter(PowerManager.ACTION_DEVICE_IDLE_MODE_CHANGED)
         context.applicationContext.registerRuntimeReceiver(receiver, filter)
+        ProcessLifecycleOwner.get().lifecycle.addObserver(this)
     }
 
-    fun getCurrentState() {
+    override fun onStart(owner: LifecycleOwner) {
+        postCurrentState()
+    }
+
+    private fun postCurrentState() {
         callback(manager.getNetworkCapabilities(manager.activeNetwork)
             ?.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED) ?: false)
     }
 
     companion object {
         fun observe(context: Context, callback: ConnectionCallback): NetworkObserver {
-            return NetworkObserver(context, callback).apply { getCurrentState() }
+            return NetworkObserver(context, callback).apply { postCurrentState() }
         }
     }
 }