react-native-icon-switcher 0.1.6 → 0.1.7

package/README.md

@@ -242,7 +242,7 @@ it('applies a pending switch', async () => {
 
 Deferred apply, task recreation when aliases toggle, the `applyPending()` foreground guard, cold-start behaviour, and launcher shortcuts are documented in [docs/guides/android.md](docs/guides/android.md).
 
-Summary: with default `applyOn: 'background'`, `set()` returns `pending` and the launcher updates after the user leaves the app; the process usually survives but the next open may look like a cold start. `applyPending()` in the foreground is refused with `foreground`.
+Summary: with default `applyOn: 'background'`, `set()` returns `pending` and the launcher updates when the last screen stops (including swipe-away from Recents) or after you background the app; listening starts at process start via AndroidX Startup. The process usually survives but the next open may look like a cold start. `applyPending()` in the foreground is refused with `foreground`.
 
 ## Requirements
 

package/android/build.gradle

@@ -43,6 +43,7 @@ android {
 dependencies {
   implementation "com.facebook.react:react-android"
   implementation "androidx.lifecycle:lifecycle-process:2.8.7"
+  implementation "androidx.startup:startup-runtime:1.2.0"
 
   testImplementation "androidx.test:core:1.7.0"
   testImplementation "junit:junit:4.13.2"

package/android/src/main/AndroidManifest.xml

@@ -1,2 +1,16 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+  xmlns:tools="http://schemas.android.com/tools">
+
+  <application>
+    <provider
+      android:name="androidx.startup.InitializationProvider"
+      android:authorities="${applicationId}.androidx-startup"
+      android:exported="false"
+      tools:node="merge">
+      <meta-data
+        android:name="com.iconswitcher.IconSwitcherInitializer"
+        android:value="androidx.startup"
+        tools:node="merge" />
+    </provider>
+  </application>
 </manifest>

package/android/src/main/java/com/iconswitcher/IconSwitcher.kt

@@ -1,5 +1,7 @@
 package com.iconswitcher
 
+import android.app.Activity
+import android.app.Application
 import android.content.ComponentName
 import android.content.Context
 import android.content.pm.ApplicationInfo
@@ -7,6 +9,7 @@ import android.content.pm.PackageManager
 import android.os.Build
 import android.os.Handler
 import android.os.Looper
+import androidx.annotation.VisibleForTesting
 import androidx.lifecycle.DefaultLifecycleObserver
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.LifecycleOwner
@@ -25,9 +28,13 @@ class IconSwitcher internal constructor(
   private val packageName: String,
   private val prefs: android.content.SharedPreferences,
   private val lifecycleRegistrar: (DefaultLifecycleObserver) -> Unit,
+  private val activityLifecycleRegistrar: (Application.ActivityLifecycleCallbacks) -> Unit,
   private val isInForeground: () -> Boolean,
 ) {
   private val writeExecutor = Executors.newSingleThreadExecutor()
+  private val processStartLock = Any()
+  private var processStartInitialized = false
+  private var startedActivityCount = 0
 
   private val markedAliases: Map<String, ComponentName> by lazy { discoverMarkedAliases() }
   private val applyOn: String by lazy { readApplyOn() }
@@ -53,6 +60,9 @@ class IconSwitcher internal constructor(
         }
       }
     },
+    activityLifecycleRegistrar = { callbacks ->
+      (context.applicationContext as Application).registerActivityLifecycleCallbacks(callbacks)
+    },
     isInForeground = {
       ProcessLifecycleOwner.get().lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)
     },
@@ -67,21 +77,33 @@ class IconSwitcher internal constructor(
     packageName = context.applicationContext.packageName,
     prefs = context.applicationContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE),
     lifecycleRegistrar = { },
+    activityLifecycleRegistrar = { },
     isInForeground = { false },
   )
 
   fun onModuleCreate() {
-    lifecycleRegistrar(
-      object : DefaultLifecycleObserver {
-        override fun onStop(owner: LifecycleOwner) {
-          val pending = prefs.getString(KEY_PENDING, null)
-          if (pending != null) {
-            runApply(pending, deferred = true)
+    onProcessStart()
+  }
+
+  fun onProcessStart() {
+    synchronized(processStartLock) {
+      if (processStartInitialized) {
+        return
+      }
+      activityLifecycleRegistrar(createActivityLifecycleCallbacks())
+      lifecycleRegistrar(
+        object : DefaultLifecycleObserver {
+          override fun onStop(owner: LifecycleOwner) {
+            val pending = prefs.getString(KEY_PENDING, null)
+            if (pending != null) {
+              runApply(pending, deferred = true)
+            }
           }
-        }
-      },
-    )
-    runColdStart()
+        },
+      )
+      runColdStart()
+      processStartInitialized = true
+    }
   }
 
   fun current(): String {
@@ -126,6 +148,41 @@ class IconSwitcher internal constructor(
     return SetResult(STATUS_APPLIED)
   }
 
+  private fun createActivityLifecycleCallbacks(): Application.ActivityLifecycleCallbacks {
+    return object : Application.ActivityLifecycleCallbacks {
+      override fun onActivityStarted(activity: Activity) {
+        startedActivityCount++
+      }
+
+      override fun onActivityStopped(activity: Activity) {
+        // Clamped: when registered late (no startup provider, so from the module),
+        // activities that started earlier were never counted.
+        startedActivityCount = maxOf(0, startedActivityCount - 1)
+        if (startedActivityCount == 0 && !activity.isChangingConfigurations) {
+          val pending = prefs.getString(KEY_PENDING, null)
+          if (pending != null) {
+            applyPendingOnLastActivityStop(pending)
+          }
+        }
+      }
+
+      override fun onActivityCreated(activity: Activity, savedInstanceState: android.os.Bundle?) {}
+      override fun onActivityResumed(activity: Activity) {}
+      override fun onActivityPaused(activity: Activity) {}
+      override fun onActivitySaveInstanceState(activity: Activity, outState: android.os.Bundle) {}
+      override fun onActivityDestroyed(activity: Activity) {}
+    }
+  }
+
+  private fun applyPendingOnLastActivityStop(name: String) {
+    val future = submitOnWriteExecutor { applyOnExecutor(name, deferred = true) }
+    try {
+      future.get()
+    } catch (_: Exception) {
+      // applyOnExecutor stores lastError for deferred failures; never propagate here.
+    }
+  }
+
   private fun runColdStart() {
     if (prefs.getString(KEY_PENDING, null) != null) {
       return
@@ -376,5 +433,23 @@ class IconSwitcher internal constructor(
     const val STATUS_APPLIED = "applied"
     const val STATUS_PENDING = "pending"
     const val STATUS_NONE = "none"
+
+    @Volatile
+    private var instance: IconSwitcher? = null
+
+    fun getInstance(context: Context): IconSwitcher {
+      val appContext = context.applicationContext
+      instance?.let { return it }
+      return synchronized(this) {
+        instance ?: IconSwitcher(appContext).also { instance = it }
+      }
+    }
+
+    @VisibleForTesting
+    internal fun clearInstanceForTests() {
+      synchronized(this) {
+        instance = null
+      }
+    }
   }
 }

package/android/src/main/java/com/iconswitcher/IconSwitcherInitializer.kt

@@ -0,0 +1,15 @@
+package com.iconswitcher
+
+import android.content.Context
+import androidx.lifecycle.ProcessLifecycleInitializer
+import androidx.startup.Initializer
+
+class IconSwitcherInitializer : Initializer<Unit> {
+  override fun create(context: Context) {
+    IconSwitcher.getInstance(context).onProcessStart()
+  }
+
+  override fun dependencies(): List<Class<out Initializer<*>>> {
+    return listOf(ProcessLifecycleInitializer::class.java)
+  }
+}

package/android/src/main/java/com/iconswitcher/IconSwitcherModule.kt

@@ -8,7 +8,7 @@ import com.facebook.react.bridge.WritableMap
 class IconSwitcherModule(reactContext: ReactApplicationContext) :
   NativeIconSwitcherSpec(reactContext) {
 
-  private val switcher = IconSwitcher(reactApplicationContext)
+  private val switcher = IconSwitcher.getInstance(reactApplicationContext)
 
   override fun initialize() {
     super.initialize()

package/android/src/test/java/com/iconswitcher/IconSwitcherTest.kt

@@ -1,5 +1,7 @@
 package com.iconswitcher
 
+import android.app.Activity
+import android.app.Application
 import android.content.ComponentName
 import android.content.Context
 import android.content.pm.ActivityInfo
@@ -34,6 +36,7 @@ class IconSwitcherTest {
 
   @Before
   fun setUp() {
+    IconSwitcher.clearInstanceForTests()
     context = ApplicationProvider.getApplicationContext()
     context.getSharedPreferences(IconSwitcher.PREFS_NAME, Context.MODE_PRIVATE)
       .edit()
@@ -205,6 +208,7 @@ class IconSwitcherTest {
       packageName = packageName,
       prefs = prefs,
       lifecycleRegistrar = { lifecycleObserver = it },
+      activityLifecycleRegistrar = { },
       isInForeground = { false },
     )
 
@@ -331,6 +335,231 @@ class IconSwitcherTest {
     ShadowLooper.idleMainLooper()
   }
 
+  @Test
+  fun initializer_starts_singleton_without_react_module() {
+    IconSwitcherInitializer().create(context)
+    val fromInitializer = IconSwitcher.getInstance(context)
+    assertTrue(fromInitializer.isSupported)
+  }
+
+  @Test
+  fun on_process_start_twice_registers_activity_callbacks_once() {
+    var registrationCount = 0
+    val pm = mockk<PackageManager>(relaxed = true)
+    every { pm.getPackageInfo(any<String>(), any<Int>()) } returns robolectricPackageInfo(context.packageName)
+    every { pm.getApplicationInfo(any<String>(), any<Int>()) } returns robolectricApplicationInfo()
+    val switcher = switcherWithActivityCallbacks(
+      pm = pm,
+      onRegister = { registrationCount++ },
+    )
+    switcher.onProcessStart()
+    switcher.onProcessStart()
+    assertEquals(1, registrationCount)
+  }
+
+  @Test
+  fun getInstance_is_shared_between_initializer_calls() {
+    IconSwitcherInitializer().create(context)
+    val first = IconSwitcher.getInstance(context)
+    val second = IconSwitcher.getInstance(context)
+    assertTrue(first === second)
+  }
+
+  @Test
+  fun last_activity_stop_applies_pending_before_on_activity_stopped_returns() {
+    val pm = mockk<PackageManager>(relaxed = true)
+    val packageName = context.packageName
+    every { pm.getPackageInfo(any<String>(), any<Int>()) } returns robolectricPackageInfo(packageName)
+    every { pm.getApplicationInfo(any<String>(), any<Int>()) } returns robolectricApplicationInfo()
+    val settingsSlot = slot<List<PackageManager.ComponentEnabledSetting>>()
+    every { pm.setComponentEnabledSettings(capture(settingsSlot)) } returns Unit
+    every { pm.getComponentEnabledSetting(any()) } answers {
+      val component = firstArg<ComponentName>()
+      if (component.className == ".IconSwitcher_halloween") {
+        PackageManager.COMPONENT_ENABLED_STATE_ENABLED
+      } else {
+        PackageManager.COMPONENT_ENABLED_STATE_DISABLED
+      }
+    }
+
+    val prefs = context.getSharedPreferences(IconSwitcher.PREFS_NAME, Context.MODE_PRIVATE)
+    prefs.edit().putString(IconSwitcher.KEY_PENDING, "halloween").apply()
+
+    var callbacks: Application.ActivityLifecycleCallbacks? = null
+    val switcher = switcherWithActivityCallbacks(pm) { callbacks = it }
+    switcher.onProcessStart()
+
+    val activity = mockk<Activity>(relaxed = true)
+    every { activity.isChangingConfigurations } returns false
+    callbacks!!.onActivityStarted(activity)
+    callbacks!!.onActivityStopped(activity)
+
+    assertTrue(
+      settingsSlot.captured.any {
+        it.componentName!!.className == ".IconSwitcher_halloween" &&
+          it.enabledFlags == PackageManager.DONT_KILL_APP
+      },
+    )
+    assertEquals(null, prefs.getString(IconSwitcher.KEY_PENDING, null))
+    assertEquals("halloween", prefs.getString(IconSwitcher.KEY_CURRENT, null))
+  }
+
+  @Test
+  fun last_activity_stop_applies_when_callbacks_were_registered_after_it_started() {
+    // No startup provider: listening starts from the module while a screen is
+    // already open, so its start was never counted.
+    val pm = mockk<PackageManager>(relaxed = true)
+    val packageName = context.packageName
+    every { pm.getPackageInfo(any<String>(), any<Int>()) } returns robolectricPackageInfo(packageName)
+    every { pm.getApplicationInfo(any<String>(), any<Int>()) } returns robolectricApplicationInfo()
+    val settingsSlot = slot<List<PackageManager.ComponentEnabledSetting>>()
+    every { pm.setComponentEnabledSettings(capture(settingsSlot)) } returns Unit
+    every { pm.getComponentEnabledSetting(any()) } answers {
+      val component = firstArg<ComponentName>()
+      if (component.className == ".IconSwitcher_halloween") {
+        PackageManager.COMPONENT_ENABLED_STATE_ENABLED
+      } else {
+        PackageManager.COMPONENT_ENABLED_STATE_DISABLED
+      }
+    }
+
+    val prefs = context.getSharedPreferences(IconSwitcher.PREFS_NAME, Context.MODE_PRIVATE)
+    prefs.edit().putString(IconSwitcher.KEY_PENDING, "halloween").apply()
+
+    var callbacks: Application.ActivityLifecycleCallbacks? = null
+    val switcher = switcherWithActivityCallbacks(pm) { callbacks = it }
+    switcher.onProcessStart()
+
+    val activity = mockk<Activity>(relaxed = true)
+    every { activity.isChangingConfigurations } returns false
+    callbacks!!.onActivityStopped(activity)
+
+    assertTrue(settingsSlot.isCaptured)
+    assertEquals(null, prefs.getString(IconSwitcher.KEY_PENDING, null))
+    assertEquals("halloween", prefs.getString(IconSwitcher.KEY_CURRENT, null))
+  }
+
+  @Test
+  fun last_activity_stop_with_two_activities_applies_only_after_both_stop() {
+    val pm = mockk<PackageManager>(relaxed = true)
+    val packageName = context.packageName
+    every { pm.getPackageInfo(any<String>(), any<Int>()) } returns robolectricPackageInfo(packageName)
+    every { pm.getApplicationInfo(any<String>(), any<Int>()) } returns robolectricApplicationInfo()
+
+    val prefs = context.getSharedPreferences(IconSwitcher.PREFS_NAME, Context.MODE_PRIVATE)
+    prefs.edit().putString(IconSwitcher.KEY_PENDING, "halloween").apply()
+
+    var callbacks: Application.ActivityLifecycleCallbacks? = null
+    val switcher = switcherWithActivityCallbacks(pm) { callbacks = it }
+    switcher.onProcessStart()
+
+    val first = mockk<Activity>(relaxed = true)
+    val second = mockk<Activity>(relaxed = true)
+    every { first.isChangingConfigurations } returns false
+    every { second.isChangingConfigurations } returns false
+
+    callbacks!!.onActivityStarted(first)
+    callbacks!!.onActivityStarted(second)
+    callbacks!!.onActivityStopped(second)
+    verify(exactly = 0) { pm.setComponentEnabledSettings(any()) }
+
+    every { pm.getComponentEnabledSetting(any()) } answers {
+      val component = firstArg<ComponentName>()
+      if (component.className == ".IconSwitcher_halloween") {
+        PackageManager.COMPONENT_ENABLED_STATE_ENABLED
+      } else {
+        PackageManager.COMPONENT_ENABLED_STATE_DISABLED
+      }
+    }
+    every { pm.setComponentEnabledSettings(any<List<PackageManager.ComponentEnabledSetting>>()) } returns Unit
+
+    callbacks!!.onActivityStopped(first)
+    verify(exactly = 1) { pm.setComponentEnabledSettings(any()) }
+  }
+
+  @Test
+  fun last_activity_stop_during_configuration_change_does_not_apply() {
+    val pm = mockk<PackageManager>(relaxed = true)
+    every { pm.getPackageInfo(any<String>(), any<Int>()) } returns robolectricPackageInfo(context.packageName)
+    every { pm.getApplicationInfo(any<String>(), any<Int>()) } returns robolectricApplicationInfo()
+
+    context.getSharedPreferences(IconSwitcher.PREFS_NAME, Context.MODE_PRIVATE)
+      .edit()
+      .putString(IconSwitcher.KEY_PENDING, "halloween")
+      .apply()
+
+    var callbacks: Application.ActivityLifecycleCallbacks? = null
+    val switcher = switcherWithActivityCallbacks(pm) { callbacks = it }
+    switcher.onProcessStart()
+
+    val activity = mockk<Activity>(relaxed = true)
+    every { activity.isChangingConfigurations } returns true
+    callbacks!!.onActivityStarted(activity)
+    callbacks!!.onActivityStopped(activity)
+
+    verify(exactly = 0) { pm.setComponentEnabledSettings(any()) }
+  }
+
+  @Test
+  fun last_activity_stop_without_pending_does_nothing() {
+    val pm = mockk<PackageManager>(relaxed = true)
+    every { pm.getPackageInfo(any<String>(), any<Int>()) } returns robolectricPackageInfo(context.packageName)
+    every { pm.getApplicationInfo(any<String>(), any<Int>()) } returns robolectricApplicationInfo()
+
+    var callbacks: Application.ActivityLifecycleCallbacks? = null
+    val switcher = switcherWithActivityCallbacks(pm) { callbacks = it }
+    switcher.onProcessStart()
+
+    val activity = mockk<Activity>(relaxed = true)
+    every { activity.isChangingConfigurations } returns false
+    callbacks!!.onActivityStarted(activity)
+    callbacks!!.onActivityStopped(activity)
+
+    verify(exactly = 0) { pm.setComponentEnabledSettings(any()) }
+  }
+
+  @Test
+  fun last_activity_stop_apply_failure_stores_last_error_without_throwing() {
+    val pm = mockk<PackageManager>(relaxed = true)
+    every { pm.getPackageInfo(any<String>(), any<Int>()) } returns robolectricPackageInfo(context.packageName)
+    every { pm.getApplicationInfo(any<String>(), any<Int>()) } returns robolectricApplicationInfo()
+    every { pm.setComponentEnabledSettings(any<List<PackageManager.ComponentEnabledSetting>>()) } throws
+      RuntimeException("pm failed")
+    every { pm.getComponentEnabledSetting(any()) } returns PackageManager.COMPONENT_ENABLED_STATE_DISABLED
+
+    val prefs = context.getSharedPreferences(IconSwitcher.PREFS_NAME, Context.MODE_PRIVATE)
+    prefs.edit().putString(IconSwitcher.KEY_PENDING, "halloween").apply()
+
+    var callbacks: Application.ActivityLifecycleCallbacks? = null
+    val switcher = switcherWithActivityCallbacks(pm) { callbacks = it }
+    switcher.onProcessStart()
+
+    val activity = mockk<Activity>(relaxed = true)
+    every { activity.isChangingConfigurations } returns false
+    callbacks!!.onActivityStarted(activity)
+    callbacks!!.onActivityStopped(activity)
+
+    assertEquals("halloween", prefs.getString(IconSwitcher.KEY_PENDING, null))
+    assertEquals("pm failed", prefs.getString(IconSwitcher.KEY_LAST_ERROR, null))
+  }
+
+  private fun switcherWithActivityCallbacks(
+    pm: PackageManager,
+    prefs: android.content.SharedPreferences =
+      context.getSharedPreferences(IconSwitcher.PREFS_NAME, Context.MODE_PRIVATE),
+    onRegister: (Application.ActivityLifecycleCallbacks) -> Unit = { },
+  ): IconSwitcher {
+    return IconSwitcher(
+      context = context,
+      packageManager = pm,
+      packageName = context.packageName,
+      prefs = prefs,
+      lifecycleRegistrar = { },
+      activityLifecycleRegistrar = onRegister,
+      isInForeground = { false },
+    )
+  }
+
   private fun switcherWithForeground(
     pm: PackageManager,
     inForeground: Boolean,
@@ -343,6 +572,7 @@ class IconSwitcherTest {
       packageName = context.packageName,
       prefs = prefs,
       lifecycleRegistrar = { },
+      activityLifecycleRegistrar = { },
       isInForeground = { inForeground },
     )
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-icon-switcher",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "Switch the app icon at runtime on React Native and Expo from one config file, with the native wiring generated for you",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",