expo-app-blocker 0.1.0

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

@@ -0,0 +1,116 @@
+package expo.modules.appblocker
+
+import android.Manifest
+import android.app.AppOpsManager
+import android.content.Context
+import android.content.Intent
+import android.content.pm.ApplicationInfo
+import android.content.pm.PackageManager
+import android.net.Uri
+import android.os.Build
+import android.os.Process
+import android.provider.Settings
+import android.util.Log
+import androidx.core.app.ActivityCompat
+import androidx.core.content.ContextCompat
+import expo.modules.kotlin.exception.Exceptions
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+
+private const val TAG = "ExpoAppBlocker"
+private const val NOTIFICATION_PERMISSION_REQUEST_CODE = 9003
+
+class ExpoAppBlockerModule : Module() {
+  private val context: Context
+    get() = appContext.reactContext ?: throw Exceptions.ReactContextLost()
+
+  override fun definition() = ModuleDefinition {
+    Name("ExpoAppBlocker")
+
+    OnCreate {
+      requestNotificationPermissionIfNeeded()
+      AppBlockerService.start(context)
+      Log.d(TAG, "Module OnCreate: started AppBlockerService")
+    }
+
+    AsyncFunction("checkOverlayPermission") {
+      Settings.canDrawOverlays(context)
+    }
+
+    AsyncFunction("checkUsageStatsPermission") {
+      val appOps = context.getSystemService(Context.APP_OPS_SERVICE) as AppOpsManager
+      val mode = appOps.unsafeCheckOpNoThrow(
+        AppOpsManager.OPSTR_GET_USAGE_STATS,
+        Process.myUid(),
+        context.packageName
+      )
+      mode == AppOpsManager.MODE_ALLOWED
+    }
+
+    Function("openOverlaySettings") {
+      val intent = Intent(
+        Settings.ACTION_MANAGE_OVERLAY_PERMISSION,
+        Uri.parse("package:${context.packageName}")
+      ).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+      context.startActivity(intent)
+    }
+
+    Function("openUsageStatsSettings") {
+      val intent = Intent(Settings.ACTION_USAGE_ACCESS_SETTINGS)
+        .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+      context.startActivity(intent)
+    }
+
+    Function("setBlockedApps") { packageNames: List<String> ->
+      AppBlockerPrefs.setBlockedPackages(context, packageNames)
+      Log.d(TAG, "setBlockedApps: $packageNames")
+    }
+
+    Function("getBlockedApps") {
+      AppBlockerPrefs.getBlockedPackages(context).toList()
+    }
+
+    Function("startMonitoring") {
+      AppBlockerService.start(context)
+      Log.d(TAG, "startMonitoring called")
+    }
+
+    Function("stopMonitoring") {
+      AppBlockerService.stop(context)
+      Log.d(TAG, "stopMonitoring called")
+    }
+
+    AsyncFunction("getInstalledApps") {
+      val pm = context.packageManager
+      val intent = Intent(Intent.ACTION_MAIN).apply {
+        addCategory(Intent.CATEGORY_LAUNCHER)
+      }
+      val apps = pm.queryIntentActivities(intent, 0)
+      apps.mapNotNull { resolveInfo ->
+        val appInfo = resolveInfo.activityInfo.applicationInfo
+        if (appInfo.flags and ApplicationInfo.FLAG_SYSTEM != 0) return@mapNotNull null
+        if (appInfo.packageName == context.packageName) return@mapNotNull null
+
+        mapOf(
+          "packageName" to appInfo.packageName,
+          "name" to (pm.getApplicationLabel(appInfo)?.toString() ?: appInfo.packageName)
+        )
+      }.sortedBy { it["name"]?.lowercase() }
+    }
+  }
+
+  private fun requestNotificationPermissionIfNeeded() {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) return
+    val granted = ContextCompat.checkSelfPermission(
+      context,
+      Manifest.permission.POST_NOTIFICATIONS
+    ) == PackageManager.PERMISSION_GRANTED
+    if (granted) return
+    val activity = appContext.currentActivity ?: return
+    ActivityCompat.requestPermissions(
+      activity,
+      arrayOf(Manifest.permission.POST_NOTIFICATIONS),
+      NOTIFICATION_PERMISSION_REQUEST_CODE
+    )
+  }
+}

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

@@ -0,0 +1,145 @@
+package expo.modules.appblocker
+
+import android.content.Context
+import android.content.Intent
+import android.graphics.Color
+import android.graphics.PixelFormat
+import android.net.Uri
+import android.os.Build
+import android.util.Log
+import android.view.Gravity
+import android.view.View
+import android.view.WindowManager
+import android.widget.TextView
+
+class OverlayManager(private val context: Context) {
+  private val windowManager: WindowManager =
+    context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
+
+  private var overlayView: View? = null
+
+  fun show(blockedPackageName: String? = null) {
+    if (overlayView != null) {
+      Log.d(TAG, "Overlay already visible")
+      if (blockedPackageName != null) {
+        navigateToApp(blockedPackageName)
+      } else {
+        bringAppToFront()
+      }
+      return
+    }
+
+    val view = buildOverlayView()
+    try {
+      windowManager.addView(view, buildLayoutParams())
+      overlayView = view
+      Log.d(TAG, "Overlay shown")
+    } catch (e: Exception) {
+      Log.e(TAG, "Failed to add overlay view", e)
+      return
+    }
+
+    if (blockedPackageName != null) {
+      navigateToApp(blockedPackageName)
+    } else {
+      bringAppToFront()
+    }
+  }
+
+  fun hide() {
+    val view = overlayView ?: return
+    try {
+      windowManager.removeView(view)
+      Log.d(TAG, "Overlay hidden")
+    } catch (e: Exception) {
+      Log.e(TAG, "Failed to remove overlay view", e)
+    }
+    overlayView = null
+  }
+
+  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
+    }
+
+    // Use the app's own scheme for deep linking
+    val scheme = getAppScheme()
+    val deepLinkIntent = Intent(
+      Intent.ACTION_VIEW,
+      Uri.parse("${scheme}://blocked?app=${Uri.encode(appName)}&package=${Uri.encode(blockedPackageName)}")
+    ).apply {
+      addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
+    }
+
+    try {
+      context.startActivity(deepLinkIntent)
+    } catch (e: Exception) {
+      Log.e(TAG, "Failed to deep link", e)
+      bringAppToFront()
+    }
+  }
+
+  private fun bringAppToFront() {
+    val launchIntent = context.packageManager
+      .getLaunchIntentForPackage(context.packageName)
+      ?.apply {
+        addFlags(
+          Intent.FLAG_ACTIVITY_NEW_TASK or
+            Intent.FLAG_ACTIVITY_REORDER_TO_FRONT
+        )
+      }
+
+    if (launchIntent == null) {
+      Log.w(TAG, "No launch intent for package ${context.packageName}")
+      return
+    }
+
+    context.startActivity(launchIntent)
+  }
+
+  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(".", "-")
+    }
+  }
+
+  private fun buildOverlayView(): View {
+    val textView = TextView(context).apply {
+      text = ""
+      setBackgroundColor(Color.parseColor("#F0000000"))
+      gravity = Gravity.CENTER
+    }
+    return textView
+  }
+
+  private fun buildLayoutParams(): WindowManager.LayoutParams {
+    @Suppress("DEPRECATION")
+    val type = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY
+    } else {
+      WindowManager.LayoutParams.TYPE_PHONE
+    }
+
+    return WindowManager.LayoutParams(
+      WindowManager.LayoutParams.MATCH_PARENT,
+      WindowManager.LayoutParams.MATCH_PARENT,
+      type,
+      WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE,
+      PixelFormat.TRANSLUCENT
+    ).apply {
+      gravity = Gravity.TOP or Gravity.START
+    }
+  }
+
+  companion object {
+    private const val TAG = "ExpoAppBlocker"
+  }
+}

package/app.plugin.js

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

package/expo-module.config.json

@@ -0,0 +1,9 @@
+{
+  "platforms": ["android", "apple"],
+  "android": {
+    "modules": ["expo.modules.appblocker.ExpoAppBlockerModule"]
+  },
+  "apple": {
+    "modules": ["ExpoAppBlockerModule"]
+  }
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "expo-app-blocker",
+  "version": "0.1.0",
+  "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",
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf build"
+  },
+  "keywords": [
+    "expo",
+    "react-native",
+    "app-blocker",
+    "screen-time",
+    "family-controls",
+    "digital-wellbeing",
+    "parental-controls",
+    "usage-stats"
+  ],
+  "author": "",
+  "license": "MIT",
+  "homepage": "https://github.com/eylonshm/expo-app-blocker",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/eylonshm/expo-app-blocker.git"
+  },
+  "bugs": {
+    "url": "https://github.com/eylonshm/expo-app-blocker/issues"
+  },
+  "dependencies": {
+    "@bacons/apple-targets": "^4.0.0"
+  },
+  "peerDependencies": {
+    "expo": ">=54.0.0",
+    "expo-modules-core": ">=3.0.0",
+    "react": ">=18.0.0",
+    "react-native": ">=0.74.0"
+  },
+  "devDependencies": {
+    "typescript": "~5.9.2",
+    "expo-modules-core": "^3.0.0"
+  }
+}

package/plugin/src/index.js

@@ -0,0 +1,196 @@
+// Resolve from the app's node_modules, not the package's
+const resolve = (mod) => {
+  try { return require(mod); } catch {}
+  try { return require(require.resolve(mod, { paths: [process.cwd()] })); } catch {}
+  throw new Error(`Cannot find module '${mod}'. Make sure 'expo' is installed.`);
+};
+const {
+  withAndroidManifest,
+  withEntitlementsPlist,
+  withInfoPlist,
+  withDangerousMod,
+  createRunOncePlugin,
+} = resolve("expo/config-plugins");
+const fs = require("fs");
+const path = require("path");
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Android
+// ──────────────────────────────────────────────────────────────────────────────
+
+function withAppBlockerAndroid(config, pluginConfig) {
+  return withAndroidManifest(config, (config) => {
+    const manifest = config.modResults;
+    const mainApplication = manifest.manifest.application?.[0];
+    if (!mainApplication) return config;
+
+    if (!manifest.manifest["uses-permission"]) {
+      manifest.manifest["uses-permission"] = [];
+    }
+    const permissions = manifest.manifest["uses-permission"];
+
+    const requiredPermissions = [
+      "android.permission.SYSTEM_ALERT_WINDOW",
+      "android.permission.FOREGROUND_SERVICE",
+      "android.permission.FOREGROUND_SERVICE_SPECIAL_USE",
+      "android.permission.RECEIVE_BOOT_COMPLETED",
+      "android.permission.POST_NOTIFICATIONS",
+    ];
+
+    // PACKAGE_USAGE_STATS needs tools:ignore
+    if (!permissions.some((p) => p.$?.["android:name"] === "android.permission.PACKAGE_USAGE_STATS")) {
+      permissions.push({
+        $: { "android:name": "android.permission.PACKAGE_USAGE_STATS", "tools:ignore": "ProtectedPermissions" },
+      });
+    }
+
+    for (const perm of requiredPermissions) {
+      if (!permissions.some((p) => p.$?.["android:name"] === perm)) {
+        permissions.push({ $: { "android:name": perm } });
+      }
+    }
+
+    if (!manifest.manifest.$) manifest.manifest.$ = {};
+    manifest.manifest.$["xmlns:tools"] = "http://schemas.android.com/tools";
+
+    // Add AppBlockerService
+    if (!mainApplication.service) mainApplication.service = [];
+    if (!mainApplication.service.some((s) => s.$?.["android:name"] === "expo.modules.appblocker.AppBlockerService")) {
+      mainApplication.service.push({
+        $: {
+          "android:name": "expo.modules.appblocker.AppBlockerService",
+          "android:enabled": "true",
+          "android:exported": "false",
+          "android:foregroundServiceType": "specialUse",
+        },
+      });
+    }
+
+    // Add BootReceiver
+    if (!mainApplication.receiver) mainApplication.receiver = [];
+    if (!mainApplication.receiver.some((r) => r.$?.["android:name"] === "expo.modules.appblocker.BootReceiver")) {
+      mainApplication.receiver.push({
+        $: { "android:name": "expo.modules.appblocker.BootReceiver", "android:enabled": "true", "android:exported": "true" },
+        "intent-filter": [{ action: [{ $: { "android:name": "android.intent.action.BOOT_COMPLETED" } }] }],
+      });
+    }
+
+    return config;
+  });
+}
+
+// ──────────────────────────────────────────────────────────────────────────────
+// iOS
+// ──────────────────────────────────────────────────────────────────────────────
+
+function withAppBlockerIOS(config, pluginConfig) {
+  const appGroup = pluginConfig?.ios?.appGroup || "group.expo.app-blocker";
+
+  config = withEntitlementsPlist(config, (config) => {
+    config.modResults["com.apple.developer.family-controls"] = true;
+    config.modResults["com.apple.security.application-groups"] = [appGroup];
+    return config;
+  });
+
+  config = withInfoPlist(config, (config) => {
+    config.modResults.BGTaskSchedulerPermittedIdentifiers = [
+      `${config.ios?.bundleIdentifier || "expo.app-blocker"}.relock`,
+    ];
+    return config;
+  });
+
+  config = withDangerousMod(config, [
+    "ios",
+    (config) => {
+      const platformRoot = config.modRequest.platformProjectRoot;
+      const projectName = config.modRequest.projectName;
+
+      // Patch Podfile deployment target (pod itself is auto-linked via expo-module.config.json)
+      const podfilePath = path.join(platformRoot, "Podfile");
+      if (fs.existsSync(podfilePath)) {
+        let podfile = fs.readFileSync(podfilePath, "utf-8");
+
+        podfile = podfile.replace(
+          /platform :ios, podfile_properties\['ios\.deploymentTarget'\] \|\| '[\d.]+'/,
+          "platform :ios, podfile_properties['ios.deploymentTarget'] || '16.0'"
+        );
+
+        fs.writeFileSync(podfilePath, podfile);
+      }
+
+      // Patch deployment target in pbxproj
+      const pbxprojPath = path.join(platformRoot, `${projectName}.xcodeproj`, "project.pbxproj");
+      if (fs.existsSync(pbxprojPath)) {
+        let pbxproj = fs.readFileSync(pbxprojPath, "utf-8");
+        pbxproj = pbxproj.replace(/IPHONEOS_DEPLOYMENT_TARGET = \d+\.\d+;/g, "IPHONEOS_DEPLOYMENT_TARGET = 16.0;");
+        fs.writeFileSync(pbxprojPath, pbxproj);
+      }
+
+      // Patch AppDelegate with localhost fallback
+      const appDelegatePath = path.join(platformRoot, projectName, "AppDelegate.swift");
+      if (fs.existsSync(appDelegatePath)) {
+        let appDelegate = fs.readFileSync(appDelegatePath, "utf-8");
+        const original = 'return RCTBundleURLProvider.sharedSettings().jsBundleURL(forBundleRoot: ".expo/.virtual-metro-entry")';
+        const replacement = `if let url = RCTBundleURLProvider.sharedSettings().jsBundleURL(forBundleRoot: ".expo/.virtual-metro-entry") {
+      return url
+    }
+    return URL(string: "http://localhost:8081/.expo/.virtual-metro-entry.bundle?platform=ios&dev=true&lazy=true&minify=false")`;
+        if (appDelegate.includes(original)) {
+          appDelegate = appDelegate.replace(original, replacement);
+          fs.writeFileSync(appDelegatePath, appDelegate);
+        }
+      }
+
+      // Inject app group into extension Swift files
+      const targetsDir = path.join(path.dirname(platformRoot), "targets");
+      if (fs.existsSync(targetsDir)) {
+        const dirs = fs.readdirSync(targetsDir);
+        for (const dir of dirs) {
+          const dirPath = path.join(targetsDir, dir);
+          if (!fs.statSync(dirPath).isDirectory()) continue;
+          const files = fs.readdirSync(dirPath);
+          for (const file of files) {
+            if (!file.endsWith(".swift")) continue;
+            const filePath = path.join(dirPath, file);
+            let content = fs.readFileSync(filePath, "utf-8");
+            if (content.includes("APP_GROUP_PLACEHOLDER")) {
+              content = content.replace(/APP_GROUP_PLACEHOLDER/g, appGroup);
+              fs.writeFileSync(filePath, content);
+            }
+          }
+        }
+      }
+
+      // Copy shield icon to ShieldConfiguration target assets
+      const shieldIcon = pluginConfig?.ios?.shield?.icon;
+      if (shieldIcon) {
+        const projectRoot = path.dirname(platformRoot);
+        const iconSrc = path.resolve(projectRoot, shieldIcon);
+        const assetsDir = path.join(targetsDir, "ShieldConfiguration", "assets");
+        if (fs.existsSync(iconSrc)) {
+          if (!fs.existsSync(assetsDir)) {
+            fs.mkdirSync(assetsDir, { recursive: true });
+          }
+          const iconDest = path.join(assetsDir, "shield-icon.png");
+          fs.copyFileSync(iconSrc, iconDest);
+        }
+      }
+
+      return config;
+    },
+  ]);
+
+  return config;
+}
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Combined
+// ──────────────────────────────────────────────────────────────────────────────
+
+function withAppBlocker(config, pluginConfig = {}) {
+  config = withAppBlockerAndroid(config, pluginConfig);
+  config = withAppBlockerIOS(config, pluginConfig);
+  return config;
+}
+
+module.exports = createRunOncePlugin(withAppBlocker, "expo-app-blocker", "0.1.0");

package/src/ExpoAppBlocker.types.ts

@@ -0,0 +1,102 @@
+// ──────────────────────────────────────────────────────────────────────────────
+// Permission types
+// ──────────────────────────────────────────────────────────────────────────────
+
+export interface PermissionStatus {
+  allGranted: boolean;
+  details: AndroidPermissions | IOSPermissions;
+}
+
+export interface AndroidPermissions {
+  platform: "android";
+  overlay: boolean;
+  usageStats: boolean;
+}
+
+export interface IOSPermissions {
+  platform: "ios";
+  authorized: boolean;
+  status: "notDetermined" | "denied" | "approved";
+}
+
+// ──────────────────────────────────────────────────────────────────────────────
+// App selection types
+// ──────────────────────────────────────────────────────────────────────────────
+
+export interface AndroidBlockableApp {
+  packageName: string;
+  name: string;
+}
+
+export interface IOSBlockedItem {
+  type: "app" | "category";
+  token: string;
+  bundleIdentifier?: string;
+  displayName?: string;
+  categoryName?: string;
+  iconBase64?: string;
+}
+
+// ──────────────────────────────────────────────────────────────────────────────
+// iOS-specific types
+// ──────────────────────────────────────────────────────────────────────────────
+
+export interface IOSBlockConfiguration {
+  blockedItems: IOSBlockedItem[];
+  isActive: boolean;
+  schedule?: {
+    intervalStart: number;
+    intervalEnd: number;
+    repeats: boolean;
+    warningTime: number;
+  };
+}
+
+export interface TemporaryUnlockResult {
+  unlocked: boolean;
+  expiresAt: number;
+}
+
+export interface RelockResult {
+  locked: boolean;
+}
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Plugin configuration types
+// ──────────────────────────────────────────────────────────────────────────────
+
+export interface ShieldConfig {
+  /** Title shown on the shield. Use {appName} as placeholder. Default: "Hold on!" */
+  title?: string;
+  /** Subtitle shown on the shield. Use {appName} as placeholder. */
+  subtitle?: string;
+  /** Primary button label. Default: "Earn Free Time" */
+  primaryButtonLabel?: string;
+  /** Secondary button label. Set to null to hide. Default: "Not now" */
+  secondaryButtonLabel?: string | null;
+  /** Primary button background color (hex). Default: "#7cb518" */
+  primaryButtonColor?: string;
+  /** Background color (hex). Default: null (uses blur) */
+  backgroundColor?: string | null;
+  /** Background blur style. Default: "systemThickMaterial" */
+  backgroundBlurStyle?: string;
+  /** Path to shield icon image. Optional. */
+  icon?: string;
+}
+
+export interface PluginConfig {
+  ios?: {
+    /** App Group identifier for shared data between app and extensions. Required. */
+    appGroup: string;
+    /** 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;
+  };
+}