expo-app-blocker 0.1.25 → 0.1.26

package/android/src/main/java/expo/modules/appblocker/AppBlockerPrefs.kt

@@ -6,6 +6,9 @@ import android.content.SharedPreferences
 object AppBlockerPrefs {
   const val PREFS_NAME = "expo_app_blocker_prefs"
   const val KEY_BLOCKED_PACKAGES = "blocked_packages"
+  private const val KEY_OVERLAY_TEXT = "overlay_text"
+  private const val KEY_NOTIFICATION_TITLE = "notification_title"
+  private const val KEY_NOTIFICATION_TEXT = "notification_text"
 
   fun get(context: Context): SharedPreferences =
     context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
@@ -18,4 +21,26 @@ object AppBlockerPrefs {
       .putStringSet(KEY_BLOCKED_PACKAGES, packages.toSet())
       .apply()
   }
+
+  fun setAndroidConfig(
+    context: Context,
+    overlayText: String?,
+    notificationTitle: String?,
+    notificationText: String?,
+  ) {
+    get(context).edit()
+      .putString(KEY_OVERLAY_TEXT, overlayText)
+      .putString(KEY_NOTIFICATION_TITLE, notificationTitle)
+      .putString(KEY_NOTIFICATION_TEXT, notificationText)
+      .apply()
+  }
+
+  fun getOverlayText(context: Context): String =
+    get(context).getString(KEY_OVERLAY_TEXT, null) ?: "{appName} is blocked."
+
+  fun getNotificationTitle(context: Context): String =
+    get(context).getString(KEY_NOTIFICATION_TITLE, null) ?: "App Blocked"
+
+  fun getNotificationText(context: Context): String =
+    get(context).getString(KEY_NOTIFICATION_TEXT, null) ?: "{appName} is blocked. Tap to manage."
 }

package/android/src/main/java/expo/modules/appblocker/AppBlockerService.kt

@@ -65,7 +65,10 @@ class AppBlockerService : Service() {
       packageName
     }
 
-    val scheme = this.packageName.replace(".", "-")
+    val title = AppBlockerPrefs.getNotificationTitle(this).replace("{appName}", appName)
+    val text = AppBlockerPrefs.getNotificationText(this).replace("{appName}", appName)
+
+    val scheme = getAppScheme()
     val deepLinkIntent = Intent(
       Intent.ACTION_VIEW,
       Uri.parse("${scheme}://blocked?app=${Uri.encode(appName)}&package=${Uri.encode(packageName)}")
@@ -73,14 +76,23 @@ class AppBlockerService : Service() {
       addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
     }
 
+    val launchIntent = packageManager.getLaunchIntentForPackage(this.packageName)
+      ?.apply { addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP) }
+
+    val resolvedIntent = try {
+      deepLinkIntent.resolveActivity(packageManager)?.let { deepLinkIntent } ?: launchIntent
+    } catch (e: Exception) {
+      launchIntent
+    } ?: deepLinkIntent
+
     val pendingIntent = PendingIntent.getActivity(
-      this, 0, deepLinkIntent,
+      this, packageName.hashCode(), resolvedIntent,
       PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
     )
 
     val notification = NotificationCompat.Builder(this, BLOCKED_CHANNEL_ID)
-      .setContentTitle("App Blocked")
-      .setContentText("$appName is blocked. Tap to earn free time!")
+      .setContentTitle(title)
+      .setContentText(text)
       .setSmallIcon(applicationInfo.icon)
       .setAutoCancel(true)
       .setPriority(NotificationCompat.PRIORITY_HIGH)
@@ -91,6 +103,17 @@ class AppBlockerService : Service() {
     manager.notify(BLOCKED_NOTIFICATION_ID, notification)
   }
 
+  private fun getAppScheme(): String {
+    val resId = resources.getIdentifier("expo_app_blocker_scheme", "string", packageName)
+    if (resId != 0) return getString(resId)
+    return try {
+      packageManager.getLaunchIntentForPackage(packageName)?.data?.scheme
+        ?: packageName.replace(".", "-")
+    } catch (e: Exception) {
+      packageName.replace(".", "-")
+    }
+  }
+
   override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
     Log.d(TAG, "AppBlockerService onStartCommand")
     return START_STICKY

package/android/src/main/java/expo/modules/appblocker/ExpoAppBlockerModule.kt

@@ -61,6 +61,16 @@ class ExpoAppBlockerModule : Module() {
       context.startActivity(intent)
     }
 
+    Function("setAndroidConfig") { config: Map<String, Any?> ->
+      AppBlockerPrefs.setAndroidConfig(
+        context,
+        overlayText = config["overlayText"] as? String,
+        notificationTitle = config["notificationTitle"] as? String,
+        notificationText = config["notificationText"] as? String,
+      )
+      Log.d(TAG, "setAndroidConfig: $config")
+    }
+
     Function("setBlockedApps") { packageNames: List<String> ->
       AppBlockerPrefs.setBlockedPackages(context, packageNames)
       Log.d(TAG, "setBlockedApps: $packageNames")

package/android/src/main/java/expo/modules/appblocker/OverlayManager.kt

@@ -4,12 +4,15 @@ import android.content.Context
 import android.content.Intent
 import android.graphics.Color
 import android.graphics.PixelFormat
+import android.graphics.Typeface
 import android.net.Uri
 import android.os.Build
 import android.util.Log
+import android.util.TypedValue
 import android.view.Gravity
 import android.view.View
 import android.view.WindowManager
+import android.widget.LinearLayout
 import android.widget.TextView
 
 class OverlayManager(private val context: Context) {
@@ -29,7 +32,8 @@ class OverlayManager(private val context: Context) {
       return
     }
 
-    val view = buildOverlayView()
+    val appName = blockedPackageName?.let { resolveAppName(it) } ?: ""
+    val view = buildOverlayView(appName)
     try {
       windowManager.addView(view, buildLayoutParams())
       overlayView = view
@@ -57,14 +61,16 @@ class OverlayManager(private val context: Context) {
     overlayView = null
   }
 
+  private fun resolveAppName(packageName: String): String = try {
+    val pm = context.packageManager
+    val appInfo = pm.getApplicationInfo(packageName, 0)
+    pm.getApplicationLabel(appInfo).toString()
+  } catch (e: Exception) {
+    packageName
+  }
+
   private fun navigateToApp(blockedPackageName: String) {
-    val appName = try {
-      val pm = context.packageManager
-      val appInfo = pm.getApplicationInfo(blockedPackageName, 0)
-      pm.getApplicationLabel(appInfo).toString()
-    } catch (e: Exception) {
-      blockedPackageName
-    }
+    val appName = resolveAppName(blockedPackageName)
 
     // Use the app's own scheme for deep linking
     val scheme = getAppScheme()
@@ -102,22 +108,40 @@ class OverlayManager(private val context: Context) {
   }
 
   private fun getAppScheme(): String {
-    return try {
-      val pm = context.packageManager
-      val intent = pm.getLaunchIntentForPackage(context.packageName)
-      intent?.data?.scheme ?: context.packageName.replace(".", "-")
-    } catch (e: Exception) {
-      context.packageName.replace(".", "-")
-    }
+    val resId = context.resources.getIdentifier("expo_app_blocker_scheme", "string", context.packageName)
+    if (resId != 0) return context.getString(resId)
+    return context.packageName.replace(".", "-")
   }
 
-  private fun buildOverlayView(): View {
-    val textView = TextView(context).apply {
-      text = ""
-      setBackgroundColor(Color.parseColor("#F0000000"))
+  private fun buildOverlayView(appName: String): View {
+    val density = context.resources.displayMetrics.density
+    fun dp(value: Int) = (value * density).toInt()
+
+    val overlayText = AppBlockerPrefs.getOverlayText(context)
+      .replace("{appName}", appName)
+
+    return LinearLayout(context).apply {
+      orientation = LinearLayout.VERTICAL
       gravity = Gravity.CENTER
+      setBackgroundColor(Color.WHITE)
+      setPadding(dp(32), dp(32), dp(32), dp(32))
+
+      addView(TextView(context).apply {
+        text = "App Blocked"
+        setTextColor(Color.parseColor("#111111"))
+        setTextSize(TypedValue.COMPLEX_UNIT_SP, 24f)
+        setTypeface(typeface, Typeface.BOLD)
+        gravity = Gravity.CENTER
+        setPadding(0, 0, 0, dp(12))
+      })
+
+      addView(TextView(context).apply {
+        text = overlayText
+        setTextColor(Color.parseColor("#737373"))
+        setTextSize(TypedValue.COMPLEX_UNIT_SP, 16f)
+        gravity = Gravity.CENTER
+      })
     }
-    return textView
   }
 
   private fun buildLayoutParams(): WindowManager.LayoutParams {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-app-blocker",
-  "version": "0.1.25",
+  "version": "0.1.26",
   "description": "Expo module for cross-platform app blocking. Android: UsageStatsManager + Overlay. iOS: Screen Time API (FamilyControls + ManagedSettings + DeviceActivity).",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/plugin/src/index.js

@@ -18,8 +18,20 @@ const path = require("path");
 // Android
 // ──────────────────────────────────────────────────────────────────────────────
 
+function getAndroidScheme(config, pluginConfig) {
+  if (pluginConfig?.android?.scheme) return pluginConfig.android.scheme;
+  const configScheme = Array.isArray(config.scheme) ? config.scheme[0] : config.scheme;
+  if (configScheme) return configScheme;
+  const pkg = config.android?.package;
+  if (pkg) return pkg.replace(/\./g, "-");
+  return null;
+}
+
 function withAppBlockerAndroid(config, pluginConfig) {
-  return withAndroidManifest(config, (config) => {
+  const scheme = getAndroidScheme(config, pluginConfig);
+
+  // Manifest: permissions, service, receiver, and deep-link intent filter
+  config = withAndroidManifest(config, (config) => {
     const manifest = config.modResults;
     const mainApplication = manifest.manifest.application?.[0];
     if (!mainApplication) return config;
@@ -75,8 +87,64 @@ function withAppBlockerAndroid(config, pluginConfig) {
       });
     }
 
+    // Add deep-link intent filter to MainActivity so notification taps route back to the app
+    if (scheme) {
+      const activities = mainApplication.activity || [];
+      const mainActivity = activities.find(
+        (a) => a.$?.["android:name"] === ".MainActivity" || a.$?.["android:name"]?.endsWith(".MainActivity")
+      );
+      if (mainActivity) {
+        if (!mainActivity["intent-filter"]) mainActivity["intent-filter"] = [];
+        const alreadyHasScheme = mainActivity["intent-filter"].some((f) =>
+          (f.data || []).some((d) => d.$?.["android:scheme"] === scheme)
+        );
+        if (!alreadyHasScheme) {
+          mainActivity["intent-filter"].push({
+            action: [{ $: { "android:name": "android.intent.action.VIEW" } }],
+            category: [
+              { $: { "android:name": "android.intent.category.DEFAULT" } },
+              { $: { "android:name": "android.intent.category.BROWSABLE" } },
+            ],
+            data: [{ $: { "android:scheme": scheme } }],
+          });
+        }
+      }
+    }
+
     return config;
   });
+
+  // Write scheme to strings.xml so AppBlockerService can read it at runtime
+  if (scheme) {
+    config = withDangerousMod(config, [
+      "android",
+      (config) => {
+        const platformRoot = config.modRequest.platformProjectRoot;
+        const valuesDir = path.join(platformRoot, "app", "src", "main", "res", "values");
+        const stringsPath = path.join(valuesDir, "strings.xml");
+
+        if (!fs.existsSync(valuesDir)) {
+          fs.mkdirSync(valuesDir, { recursive: true });
+        }
+
+        let xml = fs.existsSync(stringsPath)
+          ? fs.readFileSync(stringsPath, "utf-8")
+          : '<?xml version="1.0" encoding="utf-8"?>\n<resources>\n</resources>';
+
+        const tag = `<string name="expo_app_blocker_scheme">${scheme}</string>`;
+        if (!xml.includes('name="expo_app_blocker_scheme"')) {
+          xml = xml.replace("</resources>", `    ${tag}\n</resources>`);
+        } else {
+          xml = xml.replace(/<string name="expo_app_blocker_scheme">.*?<\/string>/, tag);
+        }
+
+        fs.writeFileSync(stringsPath, xml);
+        return config;
+      },
+    ]);
+  }
+
+  return config;
 }
 
 // ──────────────────────────────────────────────────────────────────────────────

package/src/ExpoAppBlocker.types.ts

@@ -141,6 +141,15 @@ export interface ShieldConfig {
   icon?: string;
 }
 
+export interface AndroidConfig {
+  /** Text shown on the blocking overlay. Use {appName} as placeholder. Default: "{appName} is blocked." */
+  overlayText?: string;
+  /** Notification title when app is blocked. Use {appName} as placeholder. Default: "App Blocked" */
+  notificationTitle?: string;
+  /** Notification text when app is blocked. Use {appName} as placeholder. */
+  notificationText?: string;
+}
+
 export interface PluginConfig {
   ios?: {
     /** App Group identifier for shared data between app and extensions. Required. */
@@ -148,12 +157,12 @@ export interface PluginConfig {
     /** Shield overlay customization */
     shield?: ShieldConfig;
   };
-  android?: {
-    /** Notification title when app is blocked. Use {appName} as placeholder. */
-    notificationTitle?: string;
-    /** Notification text when app is blocked. Use {appName} as placeholder. */
-    notificationText?: string;
-    /** Text shown on the blocking overlay. Default: "" (empty) */
-    overlayText?: string;
+  android?: AndroidConfig & {
+    /**
+     * URL scheme used for deep-linking back into your app when a blocked app is detected.
+     * Defaults to your app's `scheme` from app.json, or the package name with dots replaced by hyphens.
+     * Must match the scheme registered in your AndroidManifest intent-filter.
+     */
+    scheme?: string;
   };
 }

package/src/index.ts

@@ -11,6 +11,7 @@ import type {
   AndroidPermissions,
   IOSPermissions,
   AndroidBlockableApp,
+  AndroidConfig,
   IOSBlockedItem,
   IOSBlockConfiguration,
   TemporaryUnlockResult,
@@ -30,6 +31,7 @@ export type {
   TemporaryUnlockResult,
   RelockResult,
   ShieldConfig,
+  AndroidConfig,
   PluginConfig,
   FamilyActivityPickerSelectionEvent,
   FamilyActivityPickerViewProps,
@@ -113,6 +115,11 @@ export function getBlockedApps(): string[] {
   return NativeModule.getBlockedApps();
 }
 
+export function configureAndroid(config: AndroidConfig): void {
+  if (Platform.OS !== "android") return;
+  NativeModule.setAndroidConfig(config);
+}
+
 export function startMonitoring(): void {
   if (Platform.OS !== "android") return;
   NativeModule.startMonitoring();