expo-app-icon 1.0.0

package/README.md

@@ -0,0 +1,62 @@
+# expo-app-icon
+
+Programmatically change your app's icon at runtime in Expo, with proper Android adaptive-icon support.
+
+## Install
+
+```sh
+npx expo install expo-app-icon
+```
+
+## Configure
+
+Add the plugin to your app config and declare your icons. Each icon needs an `ios` and/or `android` image path:
+
+```json
+{
+  "expo": {
+    "plugins": [
+      [
+        "expo-app-icon",
+        {
+          "red": {
+            "ios": "./assets/icons/red.png",
+            "android": "./assets/icons/red.png"
+          },
+          "blue": {
+            "ios": "./assets/icons/blue.png",
+            "android": "./assets/icons/blue.png"
+          }
+        }
+      ]
+    ]
+  }
+}
+```
+
+Then create a new build (the plugin runs during prebuild):
+
+```sh
+npx expo prebuild --clean
+```
+
+## Usage
+
+```ts
+import { getAppIcon, setAppIcon } from "expo-app-icon";
+
+// Get the name of the current icon ("DEFAULT" when none is set)
+const current = getAppIcon();
+
+// Switch to one of your configured icons by key
+setAppIcon("red");
+
+// Reset back to the default icon
+setAppIcon(null);
+```
+
+## Notes
+
+- Icon keys are the keys you define in the plugin config.
+- Android icons are generated as adaptive icons. Source images are scaled into the adaptive safe zone, so design your artwork edge-to-edge — it will be centered automatically.
+- Changing the icon on Android briefly closes and reopens the app.

package/android/build.gradle

@@ -0,0 +1,43 @@
+apply plugin: 'com.android.library'
+
+group = 'expo.modules.dynamicappicon'
+version = '0.6.0'
+
+def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
+apply from: expoModulesCorePlugin
+applyKotlinExpoModulesCorePlugin()
+useCoreDependencies()
+useExpoPublishing()
+
+// If you want to use the managed Android SDK versions from expo-modules-core, set this to true.
+// The Android SDK versions will be bumped from time to time in SDK releases and may introduce breaking changes in your module code.
+// Most of the time, you may like to manage the Android SDK versions yourself.
+def useManagedAndroidSdkVersions = false
+if (useManagedAndroidSdkVersions) {
+  useDefaultAndroidSdkVersions()
+} else {
+  buildscript {
+    // Simple helper that allows the root project to override versions declared by this library.
+    ext.safeExtGet = { prop, fallback ->
+      rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+    }
+  }
+  project.android {
+    compileSdkVersion safeExtGet("compileSdkVersion", 34)
+    defaultConfig {
+      minSdkVersion safeExtGet("minSdkVersion", 21)
+      targetSdkVersion safeExtGet("targetSdkVersion", 34)
+    }
+  }
+}
+
+android {
+  namespace "expo.modules.dynamicappicon"
+  defaultConfig {
+    versionCode 1
+    versionName "0.6.0"
+  }
+  lintOptions {
+    abortOnError false
+  }
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest>
+</manifest>

package/android/src/main/java/expo/modules/dynamicappicon/ExpoAppIconChangerModule.kt

@@ -0,0 +1,81 @@
+package expo.modules.dynamicappicon
+
+import android.content.Context
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+
+class ExpoAppIconChangerModule : Module() {
+
+    override fun definition() = ModuleDefinition {
+        Name("ExpoAppIconChanger")
+
+        Function("setAppIcon") { name: String? ->
+            try {
+                SharedObject.packageName = context.packageName
+                SharedObject.pm = pm
+                SharedObject.shouldChangeIcon = true
+
+                var result: String
+
+                // The default icon is served by a dedicated alias so the real
+                // MainActivity is never disabled (see the config plugin).
+                val defaultIcon = context.packageName + ".MainActivity" + "DEFAULT"
+
+                if (name == null) {
+                    // Resetting to default icon if nothing passed
+                    var currentIcon =
+                            if (!SharedObject.icon.isEmpty()) SharedObject.icon
+                            else defaultIcon
+
+                    SharedObject.classesToKill.add(currentIcon)
+                    SharedObject.icon = defaultIcon
+                    result = "DEFAULT"
+                } else {
+                    var newIcon = context.packageName + ".MainActivity" + name
+                    var currentIcon =
+                            if (!SharedObject.icon.isEmpty()) SharedObject.icon
+                            else defaultIcon
+
+                    if (currentIcon == newIcon) {
+                        return@Function name
+                    }
+
+                    SharedObject.classesToKill.add(currentIcon)
+                    SharedObject.icon = newIcon
+                    result = name
+                }
+
+                // background the app to trigger icon change
+                try {
+                    currentActivity.moveTaskToBack(true)
+                } catch (e: Exception) {
+                    // do nothing
+                }
+
+                return@Function result
+            } catch (e: Exception) {
+                return@Function false
+            }
+        }
+
+        Function("getAppIcon") {
+            val componentClass: String = currentActivity.componentName.className
+            val currentIcon: String =
+                    if (SharedObject.icon.isNotEmpty()) SharedObject.icon else componentClass
+            val parts = currentIcon.split("MainActivity")
+            val currentIconName = if (parts.size > 1) parts[1] else ""
+
+            return@Function if (currentIconName.isEmpty() || currentIconName == "DEFAULT") "DEFAULT"
+            else currentIconName
+        }
+    }
+
+    private val context: Context
+        get() = requireNotNull(appContext.reactContext) { "React Application Context is null" }
+
+    private val currentActivity
+        get() = requireNotNull(appContext.activityProvider?.currentActivity)
+
+    private val pm
+        get() = requireNotNull(currentActivity.packageManager)
+}

package/android/src/main/java/expo/modules/dynamicappicon/ExpoAppIconChangerPackage.kt

@@ -0,0 +1,13 @@
+package expo.modules.dynamicappicon
+
+import android.content.Context
+import expo.modules.core.interfaces.Package
+import expo.modules.core.interfaces.ReactActivityLifecycleListener
+
+class ExpoAppIconChangerPackage : Package {
+    override fun createReactActivityLifecycleListeners(
+            activityContext: Context
+    ): List<ReactActivityLifecycleListener> {
+        return listOf(ExpoAppIconChangerReactActivityLifecycleListener())
+    }
+}

package/android/src/main/java/expo/modules/dynamicappicon/ExpoAppIconChangerReactActivityLifecycleListener.kt

@@ -0,0 +1,224 @@
+package expo.modules.dynamicappicon
+
+import android.app.Activity
+import android.content.ComponentName
+import android.content.Context
+import android.content.pm.PackageManager
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import expo.modules.core.interfaces.ReactActivityLifecycleListener
+
+object SharedObject {
+    var packageName: String = ""
+    var classesToKill = ArrayList<String>()
+    var icon: String = ""
+    var pm: PackageManager? = null
+    var shouldChangeIcon: Boolean = false
+}
+
+class ExpoAppIconChangerReactActivityLifecycleListener : ReactActivityLifecycleListener {
+    private var currentActivity: Activity? = null
+    private val handler = Handler(Looper.getMainLooper())
+
+    override fun onPause(activity: Activity) {
+        currentActivity = activity
+        // Apply icon change immediately when app goes to background
+        if (SharedObject.shouldChangeIcon) {
+            applyIconChange(activity)
+            // Force close the app after icon change to ensure clean restart
+            handler.postDelayed(
+                    { forceCloseApp(activity) },
+                    500
+            ) // Small delay to ensure icon change completes
+        }
+    }
+
+    override fun onResume(activity: Activity) {
+        currentActivity = activity
+        // Repair any non-icon activities that were incorrectly disabled by older versions
+        repairIncorrectlyDisabledActivities(activity)
+    }
+
+    override fun onDestroy(activity: Activity) {
+        if (SharedObject.shouldChangeIcon) {
+            applyIconChange(activity)
+        }
+        if (currentActivity === activity) {
+            currentActivity = null
+        }
+    }
+
+    private fun forceCloseApp(activity: Activity) {
+        try {
+            // Force close the app process to ensure clean restart
+            activity.finishAffinity()
+            android.os.Process.killProcess(android.os.Process.myPid())
+        } catch (e: Exception) {
+            Log.e("IconChange", "Error force closing app", e)
+        }
+    }
+
+    private fun applyIconChange(activity: Activity) {
+        SharedObject.icon.takeIf { it.isNotEmpty() }?.let { icon ->
+            val pm = SharedObject.pm ?: return
+            val newComponent = ComponentName(SharedObject.packageName, icon)
+
+            if (!doesComponentExist(newComponent)) {
+                SharedObject.shouldChangeIcon = false
+                return
+            }
+
+            try {
+                // Get all launcher activities and disable all icon aliases except the new one
+                val packageInfo =
+                        pm.getPackageInfo(
+                                SharedObject.packageName,
+                                PackageManager.GET_ACTIVITIES or
+                                        PackageManager.GET_DISABLED_COMPONENTS
+                        )
+
+                // Only disable activities that are icon aliases (named MainActivity*).
+                // The bare MainActivity is deliberately excluded: it must stay
+                // enabled so tools that launch it by explicit component (e.g. the
+                // Expo dev client) keep working. Its launcher role is owned by the
+                // DEFAULT alias instead (see the config plugin).
+                val mainActivityPrefix = "${SharedObject.packageName}.MainActivity"
+                val bareMainActivity = "${SharedObject.packageName}.MainActivity"
+
+                packageInfo.activities?.forEach { activityInfo ->
+                    val componentName = ComponentName(SharedObject.packageName, activityInfo.name)
+                    val state = pm.getComponentEnabledSetting(componentName)
+
+                    // Only manage the icon aliases, leave MainActivity and other activities alone
+                    val isIconAlias = activityInfo.name.startsWith(mainActivityPrefix) &&
+                            activityInfo.name != bareMainActivity
+
+                    if (isIconAlias &&
+                                    activityInfo.name != icon &&
+                                    state != PackageManager.COMPONENT_ENABLED_STATE_DISABLED
+                    ) {
+                        pm.setComponentEnabledSetting(
+                                componentName,
+                                PackageManager.COMPONENT_ENABLED_STATE_DISABLED,
+                                PackageManager.DONT_KILL_APP
+                        )
+                        Log.i("IconChange", "Disabled component: ${activityInfo.name}")
+                    }
+                }
+
+                // Enable the new icon
+                pm.setComponentEnabledSetting(
+                        newComponent,
+                        PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
+                        PackageManager.DONT_KILL_APP
+                )
+                Log.i("IconChange", "Enabled new icon: $icon")
+            } catch (e: Exception) {
+                Log.e("IconChange", "Error during icon change", e)
+            } finally {
+                SharedObject.shouldChangeIcon = false
+            }
+
+            // Ensure at least one component is enabled
+            ensureAtLeastOneComponentEnabled(activity)
+        }
+    }
+
+    private fun ensureAtLeastOneComponentEnabled(context: Context) {
+        val pm = SharedObject.pm ?: return
+        val packageInfo =
+                pm.getPackageInfo(
+                        SharedObject.packageName,
+                        PackageManager.GET_ACTIVITIES or PackageManager.GET_DISABLED_COMPONENTS
+                )
+
+        val hasEnabledComponent =
+                packageInfo.activities?.any { activityInfo ->
+                    val componentName = ComponentName(SharedObject.packageName, activityInfo.name)
+                    pm.getComponentEnabledSetting(componentName) ==
+                            PackageManager.COMPONENT_ENABLED_STATE_ENABLED
+                }
+                        ?: false
+
+        if (!hasEnabledComponent) {
+            // Fall back to the DEFAULT alias (the launcher), not the bare
+            // MainActivity, which intentionally has no launcher filter.
+            val defaultAlias = "${SharedObject.packageName}.MainActivityDEFAULT"
+            val defaultComponent = ComponentName(SharedObject.packageName, defaultAlias)
+            try {
+                pm.setComponentEnabledSetting(
+                        defaultComponent,
+                        PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
+                        PackageManager.DONT_KILL_APP
+                )
+                Log.i("IconChange", "No active component found. Re-enabling $defaultAlias")
+            } catch (e: Exception) {
+                Log.e("IconChange", "Error enabling fallback DEFAULT alias", e)
+            }
+        }
+    }
+
+    /**
+     * Repair activities that were incorrectly disabled by older versions of this library.
+     * Re-enables any non-icon-alias activities that are currently disabled.
+     */
+    private fun repairIncorrectlyDisabledActivities(activity: Activity) {
+        val pm = activity.packageManager
+        val packageName = activity.packageName
+
+        try {
+            val packageInfo =
+                    pm.getPackageInfo(
+                            packageName,
+                            PackageManager.GET_ACTIVITIES or PackageManager.GET_DISABLED_COMPONENTS
+                    )
+
+            val mainActivityPrefix = "${packageName}.MainActivity"
+            val bareMainActivity = "${packageName}.MainActivity"
+
+            packageInfo.activities?.forEach { activityInfo ->
+                // The bare MainActivity is not an icon alias and must stay enabled,
+                // so a previously-disabled MainActivity gets repaired here too.
+                val isIconAlias = activityInfo.name.startsWith(mainActivityPrefix) &&
+                        activityInfo.name != bareMainActivity
+
+                // If it's NOT an icon alias, it should never have been disabled by us
+                if (!isIconAlias) {
+                    val componentName = ComponentName(packageName, activityInfo.name)
+                    val state = pm.getComponentEnabledSetting(componentName)
+
+                    // Re-enable if it was explicitly disabled
+                    if (state == PackageManager.COMPONENT_ENABLED_STATE_DISABLED) {
+                        pm.setComponentEnabledSetting(
+                                componentName,
+                                PackageManager.COMPONENT_ENABLED_STATE_DEFAULT,
+                                PackageManager.DONT_KILL_APP
+                        )
+                        Log.i("IconChange", "Repaired incorrectly disabled activity: ${activityInfo.name}")
+                    }
+                }
+            }
+        } catch (e: Exception) {
+            Log.e("IconChange", "Error repairing disabled activities", e)
+        }
+    }
+
+    /** Check if a component exists in the manifest (including disabled ones). */
+    private fun doesComponentExist(componentName: ComponentName): Boolean {
+        return try {
+            val packageInfo =
+                    SharedObject.pm?.getPackageInfo(
+                            SharedObject.packageName,
+                            PackageManager.GET_ACTIVITIES or PackageManager.GET_DISABLED_COMPONENTS
+                    )
+
+            val activityExists =
+                    packageInfo?.activities?.any { it.name == componentName.className } == true
+
+            activityExists
+        } catch (e: Exception) {
+            false
+        }
+    }
+}

package/android/src/main/java/expo/modules/dynamicappicon/ExpoAppIconChangerView.kt

@@ -0,0 +1,8 @@
+package expo.modules.dynamicappicon
+
+import android.content.Context
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.views.ExpoView
+
+class ExpoAppIconChangerView(context: Context, appContext: AppContext) :
+        ExpoView(context, appContext)

package/app.plugin.js

@@ -0,0 +1 @@
+module.exports = require("./plugin/build");

package/build/ExpoAppIconChangerModule.d.ts

@@ -0,0 +1,3 @@
+declare const _default: any;
+export default _default;
+//# sourceMappingURL=ExpoAppIconChangerModule.d.ts.map

package/build/ExpoAppIconChangerModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoAppIconChangerModule.d.ts","sourceRoot":"","sources":["../src/ExpoAppIconChangerModule.ts"],"names":[],"mappings":";AAIA,wBAAyD"}

package/build/ExpoAppIconChangerModule.js

@@ -0,0 +1,5 @@
+import { requireNativeModule } from 'expo';
+// It loads the native module object from the JSI or falls back to
+// the bridge module (from NativeModulesProxy) if the remote debugger is on.
+export default requireNativeModule('ExpoAppIconChanger');
+//# sourceMappingURL=ExpoAppIconChangerModule.js.map

package/build/ExpoAppIconChangerModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoAppIconChangerModule.js","sourceRoot":"","sources":["../src/ExpoAppIconChangerModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,MAAM,CAAC;AAE3C,kEAAkE;AAClE,4EAA4E;AAC5E,eAAe,mBAAmB,CAAC,oBAAoB,CAAC,CAAC","sourcesContent":["import { requireNativeModule } from 'expo';\n\n// It loads the native module object from the JSI or falls back to\n// the bridge module (from NativeModulesProxy) if the remote debugger is on.\nexport default requireNativeModule('ExpoAppIconChanger');\n"]}

package/build/index.d.ts

@@ -0,0 +1,21 @@
+import type { DynamicAppIconRegistry } from "./types";
+/**
+ * Union of the icon keys declared in the plugin config (widened to string when none).
+ */
+export type IconName = DynamicAppIconRegistry["IconName"];
+/**
+ * Value reported / accepted for the project's default launcher icon.
+ */
+export declare const DEFAULT_ICON: "DEFAULT";
+/**
+ * Switch the launcher icon at runtime.
+ *
+ * @param name A configured icon key, or `null` to reset to the default icon.
+ * @returns The applied icon name, `"DEFAULT"`, or `false` if unsupported.
+ */
+export declare function setAppIcon(name: IconName | null): IconName | typeof DEFAULT_ICON | false;
+/**
+ * Get the currently active icon name, or `"DEFAULT"` when none is set.
+ */
+export declare function getAppIcon(): IconName | typeof DEFAULT_ICON;
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAGtD;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,sBAAsB,CAAC,UAAU,CAAC,CAAC;AAE1D;;GAEG;AACH,eAAO,MAAM,YAAY,EAAG,SAAkB,CAAC;AAE/C;;;;;GAKG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,QAAQ,GAAG,IAAI,GACpB,QAAQ,GAAG,OAAO,YAAY,GAAG,KAAK,CAExC;AAED;;GAEG;AACH,wBAAgB,UAAU,IAAI,QAAQ,GAAG,OAAO,YAAY,CAE3D"}

package/build/index.js

@@ -0,0 +1,21 @@
+import NativeAppIcon from "./ExpoAppIconChangerModule";
+/**
+ * Value reported / accepted for the project's default launcher icon.
+ */
+export const DEFAULT_ICON = "DEFAULT";
+/**
+ * Switch the launcher icon at runtime.
+ *
+ * @param name A configured icon key, or `null` to reset to the default icon.
+ * @returns The applied icon name, `"DEFAULT"`, or `false` if unsupported.
+ */
+export function setAppIcon(name) {
+    return NativeAppIcon.setAppIcon(name);
+}
+/**
+ * Get the currently active icon name, or `"DEFAULT"` when none is set.
+ */
+export function getAppIcon() {
+    return NativeAppIcon.getAppIcon();
+}
+//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,aAAa,MAAM,4BAA4B,CAAC;AAOvD;;GAEG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,SAAkB,CAAC;AAE/C;;;;;GAKG;AACH,MAAM,UAAU,UAAU,CACxB,IAAqB;IAErB,OAAO,aAAa,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;AACxC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,UAAU;IACxB,OAAO,aAAa,CAAC,UAAU,EAAE,CAAC;AACpC,CAAC","sourcesContent":["import type { DynamicAppIconRegistry } from \"./types\";\nimport NativeAppIcon from \"./ExpoAppIconChangerModule\";\n\n/**\n * Union of the icon keys declared in the plugin config (widened to string when none).\n */\nexport type IconName = DynamicAppIconRegistry[\"IconName\"];\n\n/**\n * Value reported / accepted for the project's default launcher icon.\n */\nexport const DEFAULT_ICON = \"DEFAULT\" as const;\n\n/**\n * Switch the launcher icon at runtime.\n *\n * @param name A configured icon key, or `null` to reset to the default icon.\n * @returns The applied icon name, `\"DEFAULT\"`, or `false` if unsupported.\n */\nexport function setAppIcon(\n  name: IconName | null\n): IconName | typeof DEFAULT_ICON | false {\n  return NativeAppIcon.setAppIcon(name);\n}\n\n/**\n * Get the currently active icon name, or `\"DEFAULT\"` when none is set.\n */\nexport function getAppIcon(): IconName | typeof DEFAULT_ICON {\n  return NativeAppIcon.getAppIcon();\n}\n"]}

package/build/index.web.d.ts

@@ -0,0 +1,12 @@
+import type { DynamicAppIconRegistry } from "./types";
+export type IconName = DynamicAppIconRegistry["IconName"];
+export declare const DEFAULT_ICON: "DEFAULT";
+/**
+ * Web has no launcher icon; this is a no-op that reports failure.
+ */
+export declare function setAppIcon(_name: IconName | null): IconName | typeof DEFAULT_ICON | false;
+/**
+ * Web has no launcher icon; always reports the default.
+ */
+export declare function getAppIcon(): IconName | typeof DEFAULT_ICON;
+//# sourceMappingURL=index.web.d.ts.map

package/build/index.web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.web.d.ts","sourceRoot":"","sources":["../src/index.web.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAEtD,MAAM,MAAM,QAAQ,GAAG,sBAAsB,CAAC,UAAU,CAAC,CAAC;AAE1D,eAAO,MAAM,YAAY,EAAG,SAAkB,CAAC;AAE/C;;GAEG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,QAAQ,GAAG,IAAI,GACrB,QAAQ,GAAG,OAAO,YAAY,GAAG,KAAK,CAGxC;AAED;;GAEG;AACH,wBAAgB,UAAU,IAAI,QAAQ,GAAG,OAAO,YAAY,CAG3D"}

package/build/index.web.js

@@ -0,0 +1,16 @@
+export const DEFAULT_ICON = "DEFAULT";
+/**
+ * Web has no launcher icon; this is a no-op that reports failure.
+ */
+export function setAppIcon(_name) {
+    console.error("setAppIcon is not supported on web");
+    return false;
+}
+/**
+ * Web has no launcher icon; always reports the default.
+ */
+export function getAppIcon() {
+    console.error("getAppIcon is not supported on web");
+    return DEFAULT_ICON;
+}
+//# sourceMappingURL=index.web.js.map

package/build/index.web.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.web.js","sourceRoot":"","sources":["../src/index.web.ts"],"names":[],"mappings":"AAIA,MAAM,CAAC,MAAM,YAAY,GAAG,SAAkB,CAAC;AAE/C;;GAEG;AACH,MAAM,UAAU,UAAU,CACxB,KAAsB;IAEtB,OAAO,CAAC,KAAK,CAAC,oCAAoC,CAAC,CAAC;IACpD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,UAAU;IACxB,OAAO,CAAC,KAAK,CAAC,oCAAoC,CAAC,CAAC;IACpD,OAAO,YAAY,CAAC;AACtB,CAAC","sourcesContent":["import type { DynamicAppIconRegistry } from \"./types\";\n\nexport type IconName = DynamicAppIconRegistry[\"IconName\"];\n\nexport const DEFAULT_ICON = \"DEFAULT\" as const;\n\n/**\n * Web has no launcher icon; this is a no-op that reports failure.\n */\nexport function setAppIcon(\n  _name: IconName | null\n): IconName | typeof DEFAULT_ICON | false {\n  console.error(\"setAppIcon is not supported on web\");\n  return false;\n}\n\n/**\n * Web has no launcher icon; always reports the default.\n */\nexport function getAppIcon(): IconName | typeof DEFAULT_ICON {\n  console.error(\"getAppIcon is not supported on web\");\n  return DEFAULT_ICON;\n}\n"]}

package/build/types.d.ts

@@ -0,0 +1,4 @@
+export interface DynamicAppIconRegistry {
+    IconName: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/build/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,MAAM,CAAC;CAClB"}

package/build/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/build/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"","sourcesContent":["export interface DynamicAppIconRegistry {\n  IconName: string;\n}\n"]}

package/expo-module.config.json

@@ -0,0 +1,9 @@
+{
+  "platforms": ["ios", "android", "web"],
+  "ios": {
+    "modules": ["ExpoAppIconChangerModule"]
+  },
+  "android": {
+    "modules": ["expo.modules.dynamicappicon.ExpoAppIconChangerModule"]
+  }
+}

package/ios/ExpoAppIconChanger.podspec

@@ -0,0 +1,27 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name           = 'ExpoAppIconChanger'
+  s.version        = package['version']
+  s.summary        = package['description']
+  s.description    = package['description']
+  s.license        = package['license']
+  s.author         = package['author']
+  s.homepage       = package['homepage']
+  s.platform       = :ios, '13.0'
+  s.swift_version  = '5.4'
+  s.source         = { git: 'https://github.com/outsung/expo-dynamic-app-icon' }
+  s.static_framework = true
+
+  s.dependency 'ExpoModulesCore'
+
+  # Swift/Objective-C compatibility
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES',
+    'SWIFT_COMPILATION_MODE' => 'wholemodule'
+  }
+  
+  s.source_files = "**/*.{h,m,swift}"
+end

package/ios/ExpoAppIconChangerModule.swift

@@ -0,0 +1,34 @@
+import ExpoModulesCore
+
+public class ExpoAppIconChangerModule: Module {
+  public func definition() -> ModuleDefinition {
+
+    Name("ExpoAppIconChanger")
+
+    Function("setAppIcon") { (name: String?) -> String in
+      self.setAppIcon(name)
+
+      // Return "DEFAULT" if name is nil or empty
+      return name ?? "DEFAULT"
+    }
+
+    Function("getAppIcon") { () -> String in
+      // Return the current alternate icon name or "DEFAULT" if none is set
+      return UIApplication.shared.alternateIconName ?? "DEFAULT"
+    }
+  }
+
+  private func setAppIcon(_ iconName: String?) {
+    if UIApplication.shared.responds(to: #selector(getter: UIApplication.supportsAlternateIcons)) && UIApplication.shared.supportsAlternateIcons {
+      let iconNameToUse = iconName?.isEmpty == false ? iconName : nil // If the icon name is nil or empty, reset to default
+
+      // Set the alternate icon or reset to the default icon
+      UIApplication.shared.setAlternateIconName(iconNameToUse, completionHandler: { error in
+        if let error = error {
+          // Handle error if necessary
+          print("Failed to set app icon: \(error.localizedDescription)")
+        }
+      })
+    }
+  }
+}