@klyftig/android-perms 0.1.0

package/README.md

@@ -0,0 +1,23 @@
+# @klyftig/android-perms
+
+Expo native module (Android only): the alarm-permission probes and settings
+deep links that notifee does not expose. Extracted from Sleepwise's
+`modules/sleepwise-android-perms` (2026-09-15); the Kotlin identifier is still
+`SleepwiseAndroidPerms`.
+
+```ts
+import {
+  canUseFullScreenIntent,            // Android 14+: revocable for non-alarm-category apps
+  isNotificationPolicyAccessGranted, // DND bypass
+  canDrawOverlays,                   // SYSTEM_ALERT_WINDOW
+  getManufacturer,                   // for OEM battery-killer guidance
+  openAndroidSettings,               // deep link to the matching system screen
+} from '@klyftig/android-perms';
+```
+
+`@klyftig/alarm-core`'s `getAlarmPermissionStatus()` / `openPermissionScreen`
+compose these with notifee's own probes into one status object for onboarding
+and the Settings "alarm health" rows.
+
+Off-device (iOS / web / jest) every probe returns a safe default. Autolinks
+from `node_modules`; needs a dev client.

package/android/build.gradle

@@ -0,0 +1,19 @@
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+group = 'expo.modules.sleepwiseandroidperms'
+version = '0.1.0'
+
+def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
+apply from: expoModulesCorePlugin
+applyKotlinExpoModulesCorePlugin()
+useCoreDependencies()
+useDefaultAndroidSdkVersions()
+useExpoPublishing()
+
+android {
+  namespace "expo.modules.sleepwiseandroidperms"
+  defaultConfig {
+    minSdkVersion 24
+  }
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" />

package/android/src/main/java/expo/modules/sleepwiseandroidperms/SleepwiseAndroidPermsModule.kt

@@ -0,0 +1,95 @@
+package expo.modules.sleepwiseandroidperms
+
+import android.app.NotificationManager
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import android.os.Build
+import android.provider.Settings
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+
+/**
+ * The alarm grants notifee doesn't expose (Phase 3 guided permissions):
+ *
+ * - USE_FULL_SCREEN_INTENT: on Android 14+ (API 34) it is a per-app grant that
+ *   Play can revoke for non-alarm apps; without it the full-screen ringing
+ *   screen never appears over the lock screen (only a heads-up).
+ * - Notification-policy ("Do Not Disturb") access: without it the channel's
+ *   bypassDnd stays false and a phone in DND swallows the alarm.
+ * - SYSTEM_ALERT_WINDOW (overlay): Alarmy asks for it on Android 10+ as an
+ *   extra guarantee for drawing over other apps.
+ *
+ * Each has a status read + a deep link to the exact system screen.
+ */
+class SleepwiseAndroidPermsModule : Module() {
+  override fun definition() = ModuleDefinition {
+    Name("SleepwiseAndroidPerms")
+
+    Function("canUseFullScreenIntent") {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+        notificationManager().canUseFullScreenIntent()
+      } else {
+        true // auto-granted before API 34
+      }
+    }
+
+    Function("openFullScreenIntentSettings") {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+        startSettings(Intent(Settings.ACTION_MANAGE_APP_USE_FULL_SCREEN_INTENT).apply {
+          data = Uri.parse("package:${context.packageName}")
+        })
+      } else {
+        openAppDetails()
+      }
+    }
+
+    Function("isNotificationPolicyAccessGranted") {
+      notificationManager().isNotificationPolicyAccessGranted
+    }
+
+    Function("openNotificationPolicyAccessSettings") {
+      startSettings(Intent(Settings.ACTION_NOTIFICATION_POLICY_ACCESS_SETTINGS))
+    }
+
+    Function("canDrawOverlays") {
+      Settings.canDrawOverlays(context)
+    }
+
+    Function("openOverlaySettings") {
+      startSettings(Intent(Settings.ACTION_MANAGE_OVERLAY_PERMISSION).apply {
+        data = Uri.parse("package:${context.packageName}")
+      })
+    }
+
+    Function("openAppDetailsSettings") {
+      openAppDetails()
+    }
+
+    Function("getManufacturer") {
+      Build.MANUFACTURER ?: ""
+    }
+  }
+
+  private val context: Context
+    get() = requireNotNull(appContext.reactContext) { "React context unavailable" }
+
+  private fun notificationManager(): NotificationManager =
+    context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+
+  private fun openAppDetails() {
+    startSettings(Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS).apply {
+      data = Uri.parse("package:${context.packageName}")
+    })
+  }
+
+  private fun startSettings(intent: Intent) {
+    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+    try {
+      context.startActivity(intent)
+    } catch (_: Exception) {
+      // Some OEM builds lack the specific screen — fall back to the app's page.
+      if (intent.action != Settings.ACTION_APPLICATION_DETAILS_SETTINGS) openAppDetails()
+    }
+  }
+}

package/expo-module.config.json

@@ -0,0 +1,6 @@
+{
+  "platforms": ["android"],
+  "android": {
+    "modules": ["expo.modules.sleepwiseandroidperms.SleepwiseAndroidPermsModule"]
+  }
+}

package/index.ts

@@ -0,0 +1,49 @@
+/**
+ * JS surface for `sleepwise-android-perms` — the alarm grants notifee doesn't
+ * expose. Android-only; every call degrades to a safe value elsewhere (and in
+ * jest), so the permissions helper never has to branch on platform itself.
+ */
+import { Platform } from 'react-native';
+import { requireNativeModule } from 'expo-modules-core';
+
+interface NativePerms {
+  canUseFullScreenIntent(): boolean;
+  openFullScreenIntentSettings(): void;
+  isNotificationPolicyAccessGranted(): boolean;
+  openNotificationPolicyAccessSettings(): void;
+  canDrawOverlays(): boolean;
+  openOverlaySettings(): void;
+  openAppDetailsSettings(): void;
+  getManufacturer(): string;
+}
+
+let native: NativePerms | null = null;
+if (Platform.OS === 'android') {
+  try {
+    native = requireNativeModule<NativePerms>('SleepwiseAndroidPerms');
+  } catch {
+    native = null;
+  }
+}
+
+export const isAndroidPermsAvailable = native != null;
+
+/** null = unknown (not Android / module missing). */
+export function canUseFullScreenIntent(): boolean | null {
+  return native ? native.canUseFullScreenIntent() : null;
+}
+export function isNotificationPolicyAccessGranted(): boolean | null {
+  return native ? native.isNotificationPolicyAccessGranted() : null;
+}
+export function canDrawOverlays(): boolean | null {
+  return native ? native.canDrawOverlays() : null;
+}
+export function getManufacturer(): string {
+  return native ? native.getManufacturer() : '';
+}
+export const openAndroidSettings = {
+  fullScreenIntent: () => native?.openFullScreenIntentSettings(),
+  notificationPolicy: () => native?.openNotificationPolicyAccessSettings(),
+  overlay: () => native?.openOverlaySettings(),
+  appDetails: () => native?.openAppDetailsSettings(),
+};

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@klyftig/android-perms",
+  "version": "0.1.0",
+  "description": "Android alarm-permission status + settings deep links notifee doesn't cover (full-screen intent, DND access, overlay, manufacturer)",
+  "main": "index.ts",
+  "types": "index.ts",
+  "files": [
+    "index.ts",
+    "expo-module.config.json",
+    "android/build.gradle",
+    "android/src",
+    "ios"
+  ],
+  "keywords": [
+    "expo",
+    "expo-module",
+    "react-native",
+    "alarm",
+    "klyftig"
+  ],
+  "license": "UNLICENSED",
+  "peerDependencies": {
+    "expo": "*",
+    "expo-modules-core": "*"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}