ad firebase

Author: nqmgaming

.idea/appInsightsSettings.xml

@@ -21,6 +21,16 @@ plugins {
 val firebaseConfig = file("src/play/google-services.json")
 val hasFirebaseConfig = firebaseConfig.exists()
 
+// The module root is also on the plugin's search path, and a file there applies to *every*
+// flavor — the `opensource` APK silently gains the Firebase app id and API key as string
+// resources. Android Studio's Firebase assistant puts one here given half a chance, and it is
+// gitignored, so nothing else would ever tell us. Fail loudly instead.
+val strayFirebaseConfig = file("google-services.json")
+require(!strayFirebaseConfig.exists()) {
+    "$strayFirebaseConfig applies to every flavor, including the open-source build. " +
+        "Move it to ${firebaseConfig} — that is the only location the `play` flavor reads."
+}
+
 if (hasFirebaseConfig) {
     apply(plugin = "com.google.gms.google-services")
     apply(plugin = "com.google.firebase.crashlytics")

.idea/gradle.xml

@@ -7,6 +7,8 @@ import app.pwhs.universalinstaller.di.appModule
 import app.pwhs.universalinstaller.di.flavorModule
 import app.pwhs.universalinstaller.presentation.install.controller.BackendSelfHeal
 import app.pwhs.universalinstaller.presentation.install.controller.InstallerBackendFactory
+import app.pwhs.core.data.local.SharedPrefsKeys
+import app.pwhs.core.data.local.dataStore
 import app.pwhs.universalinstaller.telemetry.Telemetry
 import app.pwhs.universalinstaller.telemetry.createTelemetrySink
 import app.pwhs.universalinstaller.util.ApkFileIconFetcher
@@ -16,6 +18,7 @@ import com.topjohnwu.superuser.Shell
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
 import org.koin.android.ext.android.inject
 import org.koin.android.ext.koin.androidContext
@@ -101,10 +104,29 @@ class App : Application(), SingletonImageLoader.Factory {
         // Self-heal stale install-method prefs (Root revoked, Shizuku not running). Runs
         // once per process on a background dispatcher; never blocks app start.
         CoroutineScope(SupervisorJob() + Dispatchers.Default).launch {
+            applyTelemetryPreference()
             BackendSelfHeal.runOnce(this@App, backendFactory)
         }
     }
 
+    /**
+     * Hands the user's choice to the reporting sink at every start.
+     *
+     * Firebase remembers the flag on its own, so this is not what makes the setting stick — it
+     * is what makes the *preference* authoritative, including after a restore onto a new device
+     * where the preference travelled but Firebase's own state did not. Absent means on.
+     *
+     * Runs before [BackendSelfHeal] in the same coroutine deliberately: self-heal is the first
+     * thing that reports, and it must not report on a build the user opted out of.
+     */
+    private suspend fun applyTelemetryPreference() {
+        if (!Telemetry.isCollecting) return
+        val enabled = runCatching { dataStore.data.first()[SharedPrefsKeys.ANALYTICS_ENABLED] }
+            .onFailure { Timber.w(it, "Could not read the analytics preference; leaving it on") }
+            .getOrNull() ?: true
+        Telemetry.setCollectionEnabled(enabled)
+    }
+
     override fun newImageLoader(context: android.content.Context): ImageLoader {
         return ImageLoader.Builder(context)
             .components {

.idea/misc.xml

@@ -25,6 +25,7 @@ import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import app.pwhs.core.domain.ThemeMode
 import app.pwhs.core.presentation.onboarding.OnboardingScreen
+import app.pwhs.universalinstaller.telemetry.Telemetry
 import app.pwhs.core.util.DeviceCompat
 import app.pwhs.core.data.local.dataStore
 import app.pwhs.universalinstaller.presentation.splash.SplashActivity
@@ -113,6 +114,9 @@ class MainActivity : ComponentActivity() {
                         onFinish = { currentRoute = AppRoute.Main },
                         showXiaomiTip = DeviceCompat.isXiaomi,
                         showVirusTotalTip = true,
+                        // Only the build that has reporting asks about it. On `opensource`
+                        // there is no sink, so the page would be a question about nothing.
+                        showAnalyticsConsent = Telemetry.isCollecting,
                     )
                     AppRoute.Main -> {
                         LaunchedEffect(Unit) {

app/build.gradle.kts

@@ -44,6 +44,8 @@ import app.pwhs.universalinstaller.util.SignatureCheck
 import app.pwhs.universalinstaller.presentation.setting.PreferencesKeys
 import app.pwhs.core.util.RootShell
 import app.pwhs.core.data.local.dataStore
+import app.pwhs.universalinstaller.telemetry.Telemetry
+import app.pwhs.universalinstaller.telemetry.TelemetryEvents
 import app.pwhs.universalinstaller.util.extension.getDisplayName
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
@@ -324,6 +326,7 @@ class InstallViewModel(
     }
 
     fun applyProfile(profile: InstallerProfile) {
+        Telemetry.feature(TelemetryEvents.FEATURE_INSTALLER_PROFILE)
         _selectedProfileId.value = profile.id
     }
 
@@ -763,6 +766,7 @@ class InstallViewModel(
         val zipTotal = entries.sumOf { it.sizeBytes.coerceAtLeast(0L) }
         val attachedTotal = attached.sumOf { it.sizeBytes.coerceAtLeast(0L) }
         val combinedTotal = zipTotal + attachedTotal
+        Telemetry.feature(TelemetryEvents.FEATURE_OBB_COPY)
         _obbCopyState.value = ObbCopyState.Running(appName, packageName, 0L, combinedTotal)
         pendingObbCopyJob = ObbCopyJob(sourceUri, entries, attached, packageName, appName)
 
@@ -1177,6 +1181,9 @@ class InstallViewModel(
         val picked = ready.entries.filter { it.selected && it.splitUris.isNotEmpty() }
         _batchState.value = BatchInstallState.Idle
         if (picked.isEmpty()) return
+        // Reported once for the batch, not once per entry — the per-entry installs already
+        // arrive as their own install_started events from the controller.
+        Telemetry.feature(TelemetryEvents.FEATURE_BATCH_INSTALL)
 
         viewModelScope.launch {
             val deleteAfterInstall = readDeleteApkPref()
@@ -1359,6 +1366,7 @@ class InstallViewModel(
             return
         }
         downloadJob?.cancel()
+        Telemetry.feature(TelemetryEvents.FEATURE_URL_DOWNLOAD)
         val displayName = trimmed.substringAfterLast('/').substringBefore('?')
             .ifBlank { "download_${System.currentTimeMillis()}" }
         _downloadState.value = DownloadState.Running(url = trimmed, bytesRead = 0L, totalBytes = -1L)
@@ -1564,6 +1572,7 @@ class InstallViewModel(
         val current = _pendingApkInfo.value ?: return
 
         cancelActiveScan()
+        Telemetry.feature(TelemetryEvents.FEATURE_VIRUSTOTAL)
         scanJob = viewModelScope.launch {
             val apiKey = readVirusTotalApiKey()
             val sizeBytes = current.fileSizeBytes

app/src/main/java/app/pwhs/universalinstaller/Application.kt

@@ -5,6 +5,8 @@ import android.content.pm.PackageManager
 import androidx.datastore.preferences.core.edit
 import app.pwhs.universalinstaller.presentation.setting.PreferencesKeys
 import app.pwhs.core.data.local.dataStore
+import app.pwhs.universalinstaller.telemetry.Telemetry
+import app.pwhs.universalinstaller.telemetry.TelemetryEvents
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.first
 import rikka.shizuku.Shizuku
@@ -45,7 +47,11 @@ object BackendSelfHeal {
                 Timber.w(t, "BackendSelfHeal: root probe threw")
                 RootState.UNAVAILABLE
             }
-            if (state == RootState.UNAVAILABLE || state == RootState.NOT_ROOTED || state == RootState.DENIED) {
+            val healthy = state != RootState.UNAVAILABLE &&
+                state != RootState.NOT_ROOTED &&
+                state != RootState.DENIED
+            reportHealth("root", healthy)
+            if (!healthy) {
                 Timber.i("BackendSelfHeal: USE_ROOT on but root definitively unavailable ($state) — disabling pref")
                 runCatching {
                     application.dataStore.edit { it[PreferencesKeys.USE_ROOT] = false }
@@ -54,14 +60,31 @@ object BackendSelfHeal {
         }
 
         val useShizuku = prefs[PreferencesKeys.USE_SHIZUKU] ?: false
-        if (useShizuku && !awaitShizukuReady()) {
-            Timber.i("BackendSelfHeal: USE_SHIZUKU on but Shizuku not ready — disabling pref")
-            runCatching {
-                application.dataStore.edit { it[PreferencesKeys.USE_SHIZUKU] = false }
+        if (useShizuku) {
+            val healthy = awaitShizukuReady()
+            reportHealth("shizuku", healthy)
+            if (!healthy) {
+                Timber.i("BackendSelfHeal: USE_SHIZUKU on but Shizuku not ready — disabling pref")
+                runCatching {
+                    application.dataStore.edit { it[PreferencesKeys.USE_SHIZUKU] = false }
+                }
             }
         }
     }
 
+    /**
+     * Only backends the user actually turned on are reported, so the denominator is "people who
+     * chose this backend" — the population whose setup we can hope to fix. Cold starts where
+     * nothing privileged is enabled say nothing and send nothing.
+     */
+    private fun reportHealth(method: String, healthy: Boolean) {
+        Telemetry.event(
+            TelemetryEvents.BACKEND_HEALTH,
+            TelemetryEvents.PARAM_METHOD to method,
+            TelemetryEvents.PARAM_HEALTHY to healthy,
+        )
+    }
+
     // Shizuku's binder is bound asynchronously after the app starts, so an immediate
     // pingBinder() right at process launch can return false even when Shizuku is healthy.
     // Poll briefly (~2s) to give the binder a chance to land before we conclude it's gone.

app/src/main/java/app/pwhs/universalinstaller/MainActivity.kt

@@ -20,6 +20,8 @@ import app.pwhs.universalinstaller.presentation.install.controller.SystemAppMeth
 import app.pwhs.universalinstaller.presentation.setting.PreferencesKeys
 import app.pwhs.core.data.local.dataStore
 import app.pwhs.universalinstaller.domain.manager.InstallBlacklist
+import app.pwhs.universalinstaller.telemetry.Telemetry
+import app.pwhs.universalinstaller.telemetry.TelemetryEvents
 import androidx.datastore.preferences.core.edit
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -346,6 +348,9 @@ class ManageViewModel(
     ) {
         if (_extractState.value is ExtractState.Running) return
         if (_batchExtractState.value is BatchExtractState.Running) return
+        // Only a real backup counts. Share / Server / Reinstall run the same extractor but are
+        // steps inside other flows, not the feature a user would say they used.
+        if (mode == ExtractMode.Backup) Telemetry.feature(TelemetryEvents.FEATURE_APK_BACKUP)
         extractJob?.cancel()
         _extractState.value = ExtractState.Running(packageName, appName, 0L, 1L, mode)
         extractJob = viewModelScope.launch {
@@ -983,6 +988,7 @@ class ManageViewModel(
     }
 
     fun uninstallApp(packageName: String) {
+        Telemetry.feature(TelemetryEvents.FEATURE_UNINSTALL)
         val app = _apps.value.firstOrNull { it.packageName == packageName }
         if (app != null && app.isSystemApp) {
             viewModelScope.launch {
@@ -1072,6 +1078,7 @@ class ManageViewModel(
     }
 
     private suspend fun runBatchUninstall(packages: List<String>) {
+        Telemetry.feature(TelemetryEvents.FEATURE_UNINSTALL)
         val opts = readUninstallOptions()
         val total = packages.size
         val notifId = notifier.notifyBatchStart(total)