feat(dhizuku): unfreeze server via AMS-mediated provider call

Wake the server with a real ContentProvider transaction instead of only
launching the Dhizuku app's UI, so cached/frozen servers recover without a
launcher activity.

Background: a server that keeps no foreground service (e.g. OwnDroid's
built-in server) is frozen by the OS once backgrounded. The first bind to a
frozen process returns "error -74 (sent to frozen apps)". Acquiring the
client or a raw binder call does not unfreeze it; an AMS-mediated provider
call does — delivering the transaction is what forces the thaw.

- New wakeDhizukuServer(): resolves the server's provider authority from the
  active device owner (DhizukuVariables.getProviderAuthorityName) and pokes
  it with a throwaway call(). Best-effort, fully guarded.
- ensureDhizukuAlive() now wakes via the provider (and re-wakes each poll,
  since the process can re-freeze mid-wait) and no longer hard-returns when
  com.rosan.dhizuku is absent — launching the standalone app's UI becomes an
  additional path rather than a prerequisite.

Pairs with the server-agnostic-discovery change: that one lets isDhizukuAlive
recognise a running built-in server, this one revives it when it's frozen.
Together they make a frozen OwnDroid server usable; each stands alone too
(this one also lets a frozen standalone Dhizuku recover without a UI bounce).

  ┌─────────────────────────────────────────────────────────────┐
  │ This change was written with AI assistance (Claude / Claude  │
  │ Code). Please review the behavior on real hardware before    │
  │ merging.                                                      │
  └─────────────────────────────────────────────────────────────┘

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: 2 people

app/src/main/kotlin/com/looker/droidify/installer/installers/dhizuku/DhizukuPermission.kt

@@ -4,10 +4,13 @@ import android.content.ComponentName
 import android.content.Context
 import android.content.Intent
 import android.content.pm.PackageManager
+import android.net.Uri
+import android.util.Log
 import com.looker.droidify.utility.common.extension.getLauncherActivities
 import com.looker.droidify.utility.common.extension.intent
 import com.rosan.dhizuku.api.Dhizuku
 import com.rosan.dhizuku.api.DhizukuRequestPermissionListener
+import com.rosan.dhizuku.shared.DhizukuVariables
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.suspendCancellableCoroutine
 import kotlin.coroutines.resume
@@ -64,13 +67,36 @@ private const val DHIZUKU_WAKE_POLL_ATTEMPTS = 15
 private const val DHIZUKU_WAKE_POLL_DELAY_MS = 200L
 private const val DHIZUKU_INSTALLER_READY_ATTEMPTS = 25
 private const val DHIZUKU_INSTALLER_STABILITY_DELAY_MS = 200L
+private const val TAG = "DhizukuPermission"
+
+/**
+ * Gracefully unfreezes the Dhizuku server process. Built-in servers such as OwnDroid keep no
+ * foreground service, so the process is frozen once backgrounded and the first bind returns
+ * "error -74 (sent to frozen apps)". A *real* ContentProvider transaction is AMS-mediated and
+ * unfreezes the target — unlike acquiring the client alone or a raw binder call. Best-effort; the
+ * result is irrelevant, delivering the call is what forces the unfreeze. Callers still poll after.
+ */
+fun wakeDhizukuServer(context: Context) {
+    runCatching {
+        val authority = DhizukuVariables.getProviderAuthorityName(Dhizuku.getOwnerPackageName())
+        val uri = Uri.parse("content://$authority")
+        context.contentResolver.acquireUnstableContentProviderClient(uri)?.use { client ->
+            runCatching { client.call("ping", null, null) }
+        }
+    }.onFailure { Log.w(TAG, "wakeDhizukuServer failed: ${it.message}") }
+}
 
 suspend fun ensureDhizukuAlive(context: Context): Boolean {
     if (isDhizukuAlive(context)) return true
-    if (!isDhizukuInstalled(context)) return false
-    launchDhizuku(context)
+    // Unfreeze a cached server (e.g. OwnDroid) without needing a launcher activity. The standalone
+    // Dhizuku app additionally needs its UI launched to start the server; built-in servers have no
+    // launcher and simply no-op here. Either way, poll until the server answers — and keep waking
+    // it each round, since it can be re-frozen between attempts.
+    wakeDhizukuServer(context)
+    if (isDhizukuInstalled(context)) launchDhizuku(context)
     repeat(DHIZUKU_WAKE_POLL_ATTEMPTS) {
         delay(DHIZUKU_WAKE_POLL_DELAY_MS)
+        wakeDhizukuServer(context)
         if (isDhizukuAlive(context)) return true
     }
     return false