@elizaos/capacitor-appblocker 1.0.0

package/ElizaosCapacitorAppblocker.podspec

@@ -0,0 +1,18 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name = 'ElizaosCapacitorAppblocker'
+  s.version = package['version']
+  s.summary = package['description']
+  s.license = package['license'] || { :type => 'MIT' }
+  s.homepage = 'https://elizaos.ai'
+  s.authors = { 'elizaOS' => 'dev@elizaos.ai' }
+  s.source = { :git => 'https://github.com/elizaOS/eliza.git', :tag => s.version.to_s }
+  s.source_files = 'ios/Sources/**/*.{swift,h,m,c,cc,mm,cpp}'
+  s.ios.deployment_target = '15.0'
+  s.frameworks = 'FamilyControls', 'ManagedSettings'
+  s.dependency 'Capacitor'
+  s.swift_version = '5.1'
+end

package/android/build.gradle

@@ -0,0 +1,51 @@
+ext {
+    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.2'
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.6.1'
+    androidxCoreVersion = project.hasProperty('androidxCoreVersion') ? rootProject.ext.androidxCoreVersion : '1.12.0'
+    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.1.5'
+    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.5.1'
+}
+
+apply plugin: 'com.android.library'
+android {
+    namespace = "ai.eliza.plugins.appblocker"
+    compileSdk project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 34
+
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 26
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 34
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+
+}
+
+repositories {
+    google()
+    maven {
+        url = uri(rootProject.ext.mavenCentralMirrorUrl)
+    }
+    mavenCentral()
+}
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':capacitor-android')
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    implementation "androidx.core:core-ktx:$androidxCoreVersion"
+
+    testImplementation "junit:junit:$junitVersion"
+    androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
+    androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
+
+    <uses-permission
+        android:name="android.permission.PACKAGE_USAGE_STATS"
+        tools:ignore="ProtectedPermissions" />
+    <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_SPECIAL_USE" />
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+
+    <application>
+        <service
+            android:name=".AppBlockerForegroundService"
+            android:enabled="true"
+            android:exported="false"
+            android:foregroundServiceType="specialUse">
+            <property
+                android:name="android.app.PROPERTY_SPECIAL_USE_FGS_SUBTYPE"
+                android:value="app_blocking_monitor" />
+        </service>
+    </application>
+</manifest>

package/android/src/main/java/ai/eliza/plugins/appblocker/AppBlockerForegroundService.kt

@@ -0,0 +1,345 @@
+package ai.eliza.plugins.appblocker
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.Service
+import android.app.usage.UsageEvents
+import android.app.usage.UsageStatsManager
+import android.content.ActivityNotFoundException
+import android.content.Context
+import android.content.Intent
+import android.graphics.Color
+import android.graphics.PixelFormat
+import android.os.Build
+import android.os.Handler
+import android.os.IBinder
+import android.os.Looper
+import android.provider.Settings
+import android.view.Gravity
+import android.view.View
+import android.view.WindowManager
+import android.widget.Button
+import android.widget.FrameLayout
+import android.widget.LinearLayout
+import android.widget.TextView
+import androidx.core.app.NotificationCompat
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+
+class AppBlockerForegroundService : Service() {
+    private val handler = Handler(Looper.getMainLooper())
+    private var polling = false
+    private var ownPackageName = ""
+    private var overlayView: View? = null
+    private var windowManager: WindowManager? = null
+
+    private val pollRunnable = object : Runnable {
+        override fun run() {
+            if (!polling) {
+                return
+            }
+            checkForegroundApp()
+            if (polling) {
+                handler.postDelayed(this, POLL_INTERVAL_MS)
+            }
+        }
+    }
+
+    override fun onBind(intent: Intent?): IBinder? = null
+
+    override fun onCreate() {
+        super.onCreate()
+        ownPackageName = packageName
+        windowManager = getSystemService(WINDOW_SERVICE) as? WindowManager
+        createNotificationChannel()
+    }
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        when (intent?.action) {
+            ACTION_STOP -> {
+                stopPolling()
+                hideBlockingOverlay()
+                stopForegroundCompat()
+                stopSelf()
+                return START_NOT_STICKY
+            }
+            ACTION_START, null -> Unit
+            else -> return START_NOT_STICKY
+        }
+
+        val saved = AppBlockerStateStore.load(this)
+        if (saved == null || saved.packageNames.isEmpty()) {
+            stopSelf()
+            return START_NOT_STICKY
+        }
+
+        startForeground(NOTIFICATION_ID, buildNotification(saved))
+        startPolling()
+
+        val endsAtEpochMs = saved.endsAtEpochMs
+        if (endsAtEpochMs != null) {
+            val delayMs = endsAtEpochMs - System.currentTimeMillis()
+            if (delayMs > 0) {
+                handler.postDelayed({
+                    AppBlockerStateStore.clear(this)
+                    stopPolling()
+                    hideBlockingOverlay()
+                    stopForegroundCompat()
+                    stopSelf()
+                }, delayMs)
+            } else {
+                AppBlockerStateStore.clear(this)
+                stopSelf()
+                return START_NOT_STICKY
+            }
+        }
+
+        return START_STICKY
+    }
+
+    override fun onDestroy() {
+        stopPolling()
+        hideBlockingOverlay()
+        super.onDestroy()
+    }
+
+    private fun startPolling() {
+        if (polling) {
+            return
+        }
+        polling = true
+        handler.post(pollRunnable)
+    }
+
+    private fun stopPolling() {
+        polling = false
+        handler.removeCallbacks(pollRunnable)
+    }
+
+    private fun checkForegroundApp() {
+        val saved = AppBlockerStateStore.load(this)
+        if (saved == null || saved.packageNames.isEmpty()) {
+            hideBlockingOverlay()
+            stopPolling()
+            stopForegroundCompat()
+            stopSelf()
+            return
+        }
+
+        if (!Settings.canDrawOverlays(this)) {
+            hideBlockingOverlay()
+            return
+        }
+
+        val foregroundPackage = getForegroundPackage() ?: return
+        val shouldBlock = foregroundPackage != ownPackageName &&
+            foregroundPackage != "com.android.launcher" &&
+            !foregroundPackage.contains("launcher", ignoreCase = true) &&
+            AppBlockerStateStore.isBlocked(this, foregroundPackage)
+
+        if (shouldBlock) {
+            showBlockingOverlay(saved)
+        } else {
+            hideBlockingOverlay()
+        }
+    }
+
+    private fun getForegroundPackage(): String? {
+        val usageStatsManager = getSystemService("usagestats") as? UsageStatsManager ?: return null
+        val now = System.currentTimeMillis()
+        val usageEvents = usageStatsManager.queryEvents(now - 2_000, now)
+        val event = UsageEvents.Event()
+        var packageName: String? = null
+        while (usageEvents.hasNextEvent()) {
+            usageEvents.getNextEvent(event)
+            if (event.eventType == UsageEvents.Event.MOVE_TO_FOREGROUND) {
+                packageName = event.packageName
+            }
+        }
+        return packageName
+    }
+
+    private fun showBlockingOverlay(saved: SavedAppBlock) {
+        if (overlayView != null) {
+            updateOverlayMessage(saved)
+            return
+        }
+
+        val overlayCard = LinearLayout(this).apply {
+            orientation = LinearLayout.VERTICAL
+            gravity = Gravity.CENTER
+            setPadding(64, 64, 64, 64)
+            setBackgroundColor(Color.parseColor("#E8EFE2"))
+        }
+
+        val titleView = TextView(this).apply {
+            id = View.generateViewId()
+            text = "App Blocked"
+            textSize = 28f
+            setTextColor(Color.parseColor("#132011"))
+            gravity = Gravity.CENTER
+        }
+
+        val messageView = TextView(this).apply {
+            id = View.generateViewId()
+            tag = "message"
+            textSize = 16f
+            setTextColor(Color.parseColor("#2D3C2B"))
+            gravity = Gravity.CENTER
+            setPadding(0, 24, 0, 32)
+        }
+
+        val homeButton = Button(this).apply {
+            text = "Go Home"
+            setOnClickListener { goHome() }
+        }
+
+        overlayCard.addView(
+            titleView,
+            LinearLayout.LayoutParams(
+                LinearLayout.LayoutParams.MATCH_PARENT,
+                LinearLayout.LayoutParams.WRAP_CONTENT,
+            ),
+        )
+        overlayCard.addView(
+            messageView,
+            LinearLayout.LayoutParams(
+                LinearLayout.LayoutParams.MATCH_PARENT,
+                LinearLayout.LayoutParams.WRAP_CONTENT,
+            ),
+        )
+        overlayCard.addView(
+            homeButton,
+            LinearLayout.LayoutParams(
+                LinearLayout.LayoutParams.WRAP_CONTENT,
+                LinearLayout.LayoutParams.WRAP_CONTENT,
+            ),
+        )
+
+        val overlayRoot = FrameLayout(this).apply {
+            setBackgroundColor(Color.parseColor("#CC132011"))
+            addView(
+                overlayCard,
+                FrameLayout.LayoutParams(
+                    FrameLayout.LayoutParams.MATCH_PARENT,
+                    FrameLayout.LayoutParams.WRAP_CONTENT,
+                    Gravity.CENTER,
+                ).apply {
+                    marginStart = 48
+                    marginEnd = 48
+                },
+            )
+        }
+
+        val windowType = if (Build.VERSION.SDK_INT >= 26) {
+            WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY
+        } else {
+            @Suppress("DEPRECATION")
+            WindowManager.LayoutParams.TYPE_PHONE
+        }
+
+        val layoutParams = WindowManager.LayoutParams(
+            WindowManager.LayoutParams.MATCH_PARENT,
+            WindowManager.LayoutParams.MATCH_PARENT,
+            windowType,
+            768,
+            PixelFormat.TRANSLUCENT,
+        ).apply {
+            gravity = Gravity.CENTER
+        }
+
+        updateOverlayMessage(saved, messageView)
+
+        try {
+            windowManager?.addView(overlayRoot, layoutParams)
+            overlayView = overlayRoot
+        } catch (_: Exception) {
+            overlayView = null
+        }
+    }
+
+    private fun updateOverlayMessage(saved: SavedAppBlock, messageView: TextView? = findOverlayMessageView()) {
+        val message = saved.endsAtEpochMs?.let { endsAtEpochMs ->
+            val formatter = SimpleDateFormat("h:mm a", Locale.getDefault())
+            "This app is blocked by Eliza until ${formatter.format(Date(endsAtEpochMs))}."
+        } ?: "This app is blocked by Eliza until you unblock it."
+        messageView?.text = message
+    }
+
+    private fun findOverlayMessageView(): TextView? {
+        val root = overlayView as? FrameLayout ?: return null
+        return root.findViewWithTag("message") as? TextView
+    }
+
+    private fun hideBlockingOverlay() {
+        val currentOverlay = overlayView ?: return
+        try {
+            windowManager?.removeView(currentOverlay)
+            overlayView = null
+        } catch (_: Exception) {
+            overlayView = null
+        }
+    }
+
+    private fun goHome() {
+        val intent = Intent(Intent.ACTION_MAIN).apply {
+            addCategory(Intent.CATEGORY_HOME)
+            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+        }
+        try {
+            startActivity(intent)
+        } catch (_: ActivityNotFoundException) {
+        }
+    }
+
+    private fun createNotificationChannel() {
+        val channel = NotificationChannel(
+            CHANNEL_ID,
+            "App Blocker",
+            NotificationManager.IMPORTANCE_LOW,
+        ).apply {
+            description = "Eliza is monitoring and blocking selected apps."
+        }
+        val notificationManager = getSystemService(NotificationManager::class.java)
+        notificationManager?.createNotificationChannel(channel)
+    }
+
+    private fun buildNotification(saved: SavedAppBlock): Notification {
+        val count = saved.packageNames.size
+        val countSuffix = if (count == 1) "" else "s"
+        val contentText = if (saved.endsAtEpochMs != null) {
+            val formatter = SimpleDateFormat("h:mm a", Locale.getDefault())
+            val endsAt = formatter.format(Date(saved.endsAtEpochMs))
+            "Blocking $count app$countSuffix until $endsAt."
+        } else {
+            val pronoun = if (count == 1) "it" else "them"
+            "Blocking $count app$countSuffix until you unblock $pronoun."
+        }
+        return NotificationCompat.Builder(this, CHANNEL_ID)
+            .setContentTitle("App Blocker Active")
+            .setContentText(contentText)
+            .setSmallIcon(android.R.drawable.ic_lock_lock)
+            .setOngoing(true)
+            .build()
+    }
+
+    private fun stopForegroundCompat() {
+        if (Build.VERSION.SDK_INT >= 24) {
+            stopForeground(STOP_FOREGROUND_REMOVE)
+        } else {
+            @Suppress("DEPRECATION")
+            stopForeground(true)
+        }
+    }
+
+    companion object {
+        const val ACTION_START = "ai.eliza.plugins.appblocker.ACTION_START"
+        const val ACTION_STOP = "ai.eliza.plugins.appblocker.ACTION_STOP"
+
+        private const val CHANNEL_ID = "eliza_app_blocker"
+        private const val NOTIFICATION_ID = 9201
+        private const val POLL_INTERVAL_MS = 500L
+    }
+}

package/android/src/main/java/ai/eliza/plugins/appblocker/AppBlockerPlugin.kt

@@ -0,0 +1,260 @@
+package ai.eliza.plugins.appblocker
+
+import android.app.AppOpsManager
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.net.Uri
+import android.os.Build
+import android.os.Process
+import android.provider.Settings
+import androidx.core.content.ContextCompat
+import com.getcapacitor.JSArray
+import com.getcapacitor.JSObject
+import com.getcapacitor.Plugin
+import com.getcapacitor.PluginCall
+import com.getcapacitor.PluginMethod
+import com.getcapacitor.annotation.CapacitorPlugin
+import java.time.Instant
+
+@CapacitorPlugin(name = "ElizaAppBlocker")
+class AppBlockerPlugin : Plugin() {
+    @PluginMethod
+    override fun checkPermissions(call: PluginCall) {
+        call.resolve(buildPermissionResult())
+    }
+
+    @PluginMethod
+    override fun requestPermissions(call: PluginCall) {
+        if (!hasUsageAccess()) {
+            openSettings(Settings.ACTION_USAGE_ACCESS_SETTINGS, null)
+        } else if (!canDrawOverlays()) {
+            openSettings(
+                Settings.ACTION_MANAGE_OVERLAY_PERMISSION,
+                Uri.parse("package:${context.packageName}"),
+            )
+        }
+        call.resolve(buildPermissionResult())
+    }
+
+    @PluginMethod
+    fun getInstalledApps(call: PluginCall) {
+        val launcherIntent = Intent(Intent.ACTION_MAIN).addCategory(Intent.CATEGORY_LAUNCHER)
+        val matches = if (Build.VERSION.SDK_INT >= 33) {
+            context.packageManager.queryIntentActivities(
+                launcherIntent,
+                PackageManager.ResolveInfoFlags.of(0),
+            )
+        } else {
+            @Suppress("DEPRECATION")
+            context.packageManager.queryIntentActivities(launcherIntent, 0)
+        }
+
+        val ownPackageName = context.packageName
+        val apps = matches
+            .asSequence()
+            .mapNotNull { resolveInfo ->
+                val packageName = resolveInfo.activityInfo?.packageName?.trim().orEmpty()
+                if (packageName.isEmpty() || packageName == ownPackageName) {
+                    return@mapNotNull null
+                }
+                val displayName = resolveInfo.loadLabel(context.packageManager)
+                    ?.toString()
+                    ?.trim()
+                    .takeUnless { it.isNullOrEmpty() }
+                    ?: packageName
+                JSObject().apply {
+                    put("packageName", packageName)
+                    put("displayName", displayName)
+                }
+            }
+            .distinctBy { it.getString("packageName") }
+            .sortedBy { it.getString("displayName")?.lowercase() ?: "" }
+            .toList()
+
+        call.resolve(
+            JSObject().apply {
+                put("apps", JSArray(apps))
+            },
+        )
+    }
+
+    @PluginMethod
+    fun selectApps(call: PluginCall) {
+        call.resolve(
+            JSObject().apply {
+                put("apps", JSArray())
+                put("cancelled", true)
+            },
+        )
+    }
+
+    @PluginMethod
+    fun blockApps(call: PluginCall) {
+        if (!hasUsageAccess() || !canDrawOverlays()) {
+            call.resolve(
+                JSObject().apply {
+                    put("success", false)
+                    put("endsAt", null as String?)
+                    put("error", missingPermissionReason())
+                    put("blockedCount", 0)
+                },
+            )
+            return
+        }
+
+        val explicitPackageNames = call.data.optJSONArray("packageNames")
+        val normalizedPackageNames = buildList {
+            if (explicitPackageNames == null) return@buildList
+            for (index in 0 until explicitPackageNames.length()) {
+                val value = explicitPackageNames.optString(index).trim()
+                if (value.isNotEmpty()) {
+                    add(value)
+                }
+            }
+        }
+            .distinct()
+            .sorted()
+
+        if (normalizedPackageNames.isEmpty()) {
+            call.resolve(
+                JSObject().apply {
+                    put("success", false)
+                    put("endsAt", null as String?)
+                    put("error", "Select at least one Android app to block.")
+                    put("blockedCount", 0)
+                },
+            )
+            return
+        }
+
+        val durationMinutes = parseDurationMinutes(call)
+        val endsAtEpochMs = durationMinutes?.let { System.currentTimeMillis() + (it * 60_000L) }
+
+        AppBlockerStateStore.save(
+            context = context,
+            packageNames = normalizedPackageNames,
+            endsAtEpochMs = endsAtEpochMs,
+        )
+
+        val serviceIntent = Intent(context, AppBlockerForegroundService::class.java).apply {
+            action = AppBlockerForegroundService.ACTION_START
+        }
+        ContextCompat.startForegroundService(context, serviceIntent)
+
+        call.resolve(
+            JSObject().apply {
+                put("success", true)
+                put("endsAt", endsAtEpochMs?.let { Instant.ofEpochMilli(it).toString() })
+                put("blockedCount", normalizedPackageNames.size)
+            },
+        )
+    }
+
+    @PluginMethod
+    fun unblockApps(call: PluginCall) {
+        AppBlockerStateStore.clear(context)
+        context.stopService(
+            Intent(context, AppBlockerForegroundService::class.java).apply {
+                action = AppBlockerForegroundService.ACTION_STOP
+            },
+        )
+
+        call.resolve(
+            JSObject().apply {
+                put("success", true)
+            },
+        )
+    }
+
+    @PluginMethod
+    fun getStatus(call: PluginCall) {
+        val saved = AppBlockerStateStore.load(context)
+        val permission = buildPermissionResult()
+        val reason = if (saved != null && (!hasUsageAccess() || !canDrawOverlays())) {
+            missingPermissionReason()
+        } else {
+            permission.getString("reason")
+        }
+
+        call.resolve(
+            JSObject().apply {
+                put("available", true)
+                put("active", saved != null)
+                put("platform", "android")
+                put("engine", "usage-stats-overlay")
+                put("blockedCount", saved?.packageNames?.size ?: 0)
+                put("blockedPackageNames", JSArray(saved?.packageNames ?: emptyList<String>()))
+                put("endsAt", saved?.endsAtEpochMs?.let { Instant.ofEpochMilli(it).toString() })
+                put("permissionStatus", permission.getString("status"))
+                if (!reason.isNullOrBlank()) {
+                    put("reason", reason)
+                }
+            },
+        )
+    }
+
+    private fun parseDurationMinutes(call: PluginCall): Long? {
+        val rawValue = call.data.opt("durationMinutes") ?: return null
+        val duration = when (rawValue) {
+            is Number -> rawValue.toLong()
+            is String -> rawValue.toLongOrNull()
+            else -> null
+        }
+        return duration?.takeIf { it > 0 }
+    }
+
+    private fun buildPermissionResult(): JSObject {
+        val usageAccess = hasUsageAccess()
+        val overlayAccess = canDrawOverlays()
+        return JSObject().apply {
+            put("status", if (usageAccess && overlayAccess) "granted" else "not-determined")
+            put("canRequest", !usageAccess || !overlayAccess)
+            missingPermissionReason()?.let { put("reason", it) }
+        }
+    }
+
+    private fun missingPermissionReason(): String? {
+        val missingUsageAccess = !hasUsageAccess()
+        val missingOverlayAccess = !canDrawOverlays()
+        return when {
+            missingUsageAccess && missingOverlayAccess ->
+                "Android needs Usage Access and Draw Over Other Apps before Eliza can block apps on this phone."
+            missingUsageAccess ->
+                "Android needs Usage Access before Eliza can detect and block foreground apps."
+            missingOverlayAccess ->
+                "Android needs Draw Over Other Apps before Eliza can show the blocking shield."
+            else -> null
+        }
+    }
+
+    private fun hasUsageAccess(): Boolean {
+        val appOps = context.getSystemService("appops") as? AppOpsManager ?: return false
+        val mode = if (Build.VERSION.SDK_INT >= 29) {
+            appOps.unsafeCheckOpNoThrow(
+                AppOpsManager.OPSTR_GET_USAGE_STATS,
+                Process.myUid(),
+                context.packageName,
+            )
+        } else {
+            @Suppress("DEPRECATION")
+            appOps.checkOpNoThrow(
+                AppOpsManager.OPSTR_GET_USAGE_STATS,
+                Process.myUid(),
+                context.packageName,
+            )
+        }
+        return mode == AppOpsManager.MODE_ALLOWED
+    }
+
+    private fun canDrawOverlays(): Boolean {
+        return Build.VERSION.SDK_INT < 23 || Settings.canDrawOverlays(context)
+    }
+
+    private fun openSettings(action: String, uri: Uri?) {
+        val intent = Intent(action).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+        if (uri != null) {
+            intent.data = uri
+        }
+        context.startActivity(intent)
+    }
+}