react-native-alarms 0.0.0-stage → 0.0.2

package/android/app/src/main/java/com/reactnativealarm/alarm/AlarmPackage.kt

@@ -0,0 +1,24 @@
+package com.alarm
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+class AlarmPackage : BaseReactPackage() {
+  override fun getModule(name: String, ctx: ReactApplicationContext): NativeModule? =
+    if (name == AlarmModule.NAME) AlarmModule(ctx) else null
+
+  override fun getReactModuleInfoProvider() = ReactModuleInfoProvider {
+    mapOf(
+      AlarmModule.NAME to ReactModuleInfo(
+        AlarmModule.NAME, AlarmModule.NAME,
+        false, // canOverrideExistingModule
+        false, // needsEagerInit
+        false, // isCxxModule
+        false  // isTurboModule
+      )
+    )
+  }
+}

package/android/app/src/main/java/com/reactnativealarm/alarm/AlarmReceiver.kt

@@ -0,0 +1,43 @@
+package com.alarm
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.util.Log
+
+/**
+ * AlarmManager fires here at the exact trigger time. The receiver only gets ~10s of
+ * guaranteed execution, so it updates the store and hands off to [AlarmService]
+ * immediately. The service does the actual ringing, screen wake and UI.
+ */
+class AlarmReceiver : BroadcastReceiver() {
+  companion object {
+    private const val TAG = "AlarmReceiver"
+    const val ACTION_FIRE = "com.alarm.FIRE"
+  }
+
+  override fun onReceive(ctx: Context, intent: Intent) {
+    if (intent.action != ACTION_FIRE) return
+    val id = intent.getStringExtra(AlarmScheduler.EXTRA_ID) ?: return
+    val alarm = AlarmStore.get(ctx, id)
+    if (alarm == null) {
+      Log.w(TAG, "Alarm $id fired but is no longer stored")
+      return
+    }
+    Log.i(TAG, "Alarm $id fired (snooze=${intent.getBooleanExtra(AlarmScheduler.EXTRA_SNOOZE, false)})")
+
+    if (!intent.getBooleanExtra(AlarmScheduler.EXTRA_SNOOZE, false)) {
+      if (alarm.repeatType == "none") {
+        alarm.enabled = false
+        AlarmStore.save(ctx, alarm)
+      } else {
+        // Repeating: arm the next occurrence right away so it is guaranteed even
+        // if the user force-stops the ringing screen.
+        runCatching { AlarmScheduler.schedule(ctx, alarm) }
+          .onFailure { Log.e(TAG, "Could not re-arm repeating alarm $id", it) }
+      }
+    }
+
+    AlarmService.start(ctx, id)
+  }
+}

package/android/app/src/main/java/com/reactnativealarm/alarm/AlarmRingActivity.kt

@@ -0,0 +1,86 @@
+package com.alarm
+
+import android.app.Activity
+import android.content.Intent
+import android.os.Build
+import android.os.Bundle
+import android.view.WindowManager
+import com.facebook.react.ReactActivity
+import com.facebook.react.ReactActivityDelegate
+import com.facebook.react.defaults.DefaultNewArchitectureEntryPoint.fabricEnabled
+import com.facebook.react.defaults.DefaultReactActivityDelegate
+import java.lang.ref.WeakReference
+
+/**
+ * Full-screen ringing UI shown over the lock screen (or on top of the app when it is
+ * open). Hosts the React component registered as [COMPONENT_NAME] and passes the
+ * ringing alarm as its initial props. Mirrors Upupup's RingActivity.
+ */
+class AlarmRingActivity : ReactActivity() {
+
+  override fun getMainComponentName(): String = COMPONENT_NAME
+
+  override fun createReactActivityDelegate(): ReactActivityDelegate =
+    object : DefaultReactActivityDelegate(this, mainComponentName, fabricEnabled) {
+      override fun getLaunchOptions(): Bundle? = AlarmService.current?.toBundle()
+    }
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    // Stale launch (alarm already stopped): don't even spin up the React root.
+    if (AlarmService.current == null) {
+      super.onCreate(null)
+      finish()
+      return
+    }
+    instance = WeakReference(this)
+    super.onCreate(savedInstanceState)
+    showOverLockScreen()
+  }
+
+  private fun showOverLockScreen() {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O_MR1) {
+      setShowWhenLocked(true)
+      setTurnScreenOn(true)
+    } else {
+      @Suppress("DEPRECATION")
+      window.addFlags(
+        WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED or
+          WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON
+      )
+    }
+    window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+  }
+
+  /** The only ways out are Stop and Snooze: swallow the back button. */
+  override fun invokeDefaultOnBackPressed() { /* consume */ }
+
+  override fun onDestroy() {
+    if (instance?.get() === this) instance = null
+    super.onDestroy()
+  }
+
+  companion object {
+    const val COMPONENT_NAME = "AlarmRing"
+
+    private var instance: WeakReference<AlarmRingActivity>? = null
+
+    val isOpen: Boolean get() = instance?.get() != null
+
+    /** Called by [AlarmService] when ringing ends for any reason. */
+    fun finishIfOpen() {
+      instance?.get()?.finish()
+    }
+
+    /**
+     * Brings the ring screen up when an alarm is ringing and the user opens the app
+     * (the full-screen intent only fires when the screen is off/locked).
+     */
+    fun openIfRinging(activity: Activity) {
+      if (AlarmService.current != null && !isOpen) {
+        activity.startActivity(
+          Intent(activity, AlarmRingActivity::class.java).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+        )
+      }
+    }
+  }
+}

package/android/app/src/main/java/com/reactnativealarm/alarm/AlarmScheduler.kt

@@ -0,0 +1,74 @@
+package com.alarm
+
+import android.app.AlarmManager
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import android.util.Log
+
+/**
+ * Registers alarms with [AlarmManager.setAlarmClock]: exact trigger, exempt from Doze
+ * and battery optimisations, and the system shows the alarm-clock status-bar icon.
+ */
+object AlarmScheduler {
+  private const val TAG = "AlarmScheduler"
+  const val EXTRA_ID = "alarmId"
+  const val EXTRA_SNOOZE = "snooze"
+
+  private fun am(ctx: Context) = ctx.getSystemService(AlarmManager::class.java)
+
+  fun canScheduleExact(ctx: Context) =
+    Build.VERSION.SDK_INT < Build.VERSION_CODES.S || am(ctx).canScheduleExactAlarms()
+
+  /** Re-syncs every enabled alarm with AlarmManager. Idempotent. */
+  fun scheduleAll(ctx: Context) {
+    AlarmStore.all(ctx).forEach { a ->
+      if (a.enabled) runCatching { schedule(ctx, a) }
+        .onFailure { Log.e(TAG, "Could not re-arm ${a.id}", it) }
+      else cancel(ctx, a.id)
+    }
+  }
+
+  fun schedule(ctx: Context, a: AlarmData) {
+    val at = a.nextTrigger()
+    if (at > 0) setExact(ctx, at, firePI(ctx, a.id, false))
+    else Log.i(TAG, "Alarm ${a.id} has no future trigger; not scheduled")
+  }
+
+  fun scheduleSnooze(ctx: Context, a: AlarmData, minutes: Int) =
+    setExact(ctx, System.currentTimeMillis() + minutes * 60_000L, firePI(ctx, a.id, true))
+
+  fun cancel(ctx: Context, id: String) {
+    am(ctx).cancel(firePI(ctx, id, false))
+    cancelSnooze(ctx, id)
+  }
+
+  fun cancelSnooze(ctx: Context, id: String) {
+    am(ctx).cancel(firePI(ctx, id, true))
+  }
+
+  private fun setExact(ctx: Context, at: Long, pi: PendingIntent) {
+    if (!canScheduleExact(ctx)) {
+      throw SecurityException("Exact alarm permission (SCHEDULE_EXACT_ALARM) not granted")
+    }
+    // Tapping the status-bar alarm icon opens the app.
+    val launch = ctx.packageManager.getLaunchIntentForPackage(ctx.packageName)
+    val show = launch?.let {
+      PendingIntent.getActivity(ctx, 0, it, PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT)
+    }
+    am(ctx).setAlarmClock(AlarmManager.AlarmClockInfo(at, show), pi)
+    Log.i(TAG, "Alarm set for ${java.util.Date(at)}")
+  }
+
+  private fun firePI(ctx: Context, id: String, snooze: Boolean): PendingIntent {
+    val i = Intent(ctx, AlarmReceiver::class.java)
+      .setAction(AlarmReceiver.ACTION_FIRE)
+      .putExtra(EXTRA_ID, id)
+      .putExtra(EXTRA_SNOOZE, snooze)
+    return PendingIntent.getBroadcast(
+      ctx, (id + if (snooze) "_s" else "").hashCode(), i,
+      PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+    )
+  }
+}

package/android/app/src/main/java/com/reactnativealarm/alarm/AlarmService.kt

@@ -0,0 +1,285 @@
+package com.alarm
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.app.Service
+import android.content.Context
+import android.content.Intent
+import android.content.pm.ServiceInfo
+import android.media.AudioAttributes
+import android.media.MediaPlayer
+import android.media.RingtoneManager
+import android.net.Uri
+import android.os.Build
+import android.os.Handler
+import android.os.IBinder
+import android.os.Looper
+import android.os.PowerManager
+import android.os.VibrationEffect
+import android.os.Vibrator
+import android.util.Log
+import androidx.core.app.NotificationCompat
+import androidx.core.app.ServiceCompat
+
+/**
+ * Foreground service that actually rings: looping sound, vibration, a partial wake
+ * lock and a full-screen notification that pops [AlarmRingActivity] over the lock
+ * screen. Same architecture as Upupup's AlarmService.
+ *
+ * Why a service and not just a notification from the receiver: a BroadcastReceiver
+ * only gets ~10s of execution and the process can be killed right after. A
+ * foreground service keeps the process alive (JS runtime included once started),
+ * keeps the sound looping and is what lets a killed app ring reliably.
+ */
+class AlarmService : Service() {
+
+  private val handler = Handler(Looper.getMainLooper())
+  private var player: MediaPlayer? = null
+  private var vibrator: Vibrator? = null
+  private var wakeLock: PowerManager.WakeLock? = null
+
+  override fun onBind(intent: Intent?): IBinder? = null
+
+  override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+    when (intent?.action) {
+      ACTION_SNOOZE -> {
+        snooze(intent.getIntExtra(EXTRA_SNOOZE_MINUTES, -1))
+        return START_NOT_STICKY
+      }
+      ACTION_DISMISS -> {
+        dismiss()
+        return START_NOT_STICKY
+      }
+    }
+
+    val id = intent?.getStringExtra(AlarmScheduler.EXTRA_ID)
+    val alarm = id?.let { AlarmStore.get(this, it) }
+    if (alarm == null) {
+      Log.w(TAG, "Started without a known alarm (id=$id); stopping")
+      // Must still enter the foreground briefly: we were started with
+      // startForegroundService() and the system expects startForeground().
+      runCatching { startInForeground(placeholderNotification()) }
+      stopSelf()
+      return START_NOT_STICKY
+    }
+    if (current != null) stopRinging() // a second alarm fired while one was ringing
+
+    current = alarm
+    Log.i(TAG, "Ringing alarm ${alarm.id}")
+
+    startInForeground(buildNotification(alarm))
+    acquireWakeLock()
+    startSound(alarm)
+    if (alarm.vibrate) startVibration()
+
+    // The full-screen intent only fires when the screen is off/locked and on some
+    // OEMs (Xiaomi, Oppo, Vivo...) it is unreliable even then. Launching the ring
+    // activity directly works whenever the app has "display over other apps"
+    // (SYSTEM_ALERT_WINDOW) or one of our activities is visible; the system
+    // silently ignores it otherwise, so it is safe to always try.
+    runCatching {
+      startActivity(
+        Intent(this, AlarmRingActivity::class.java)
+          .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+      )
+    }.onFailure { Log.w(TAG, "Could not start ring activity directly", it) }
+
+    AlarmModule.emit(AlarmModule.EVENT_FIRED, alarm)
+
+    // Safety net: never ring forever. Auto-snooze (or stop) after 5 minutes.
+    handler.postDelayed({ if (alarm.snoozeEnabled) snooze(-1) else dismiss() }, AUTO_TIMEOUT_MS)
+    return START_NOT_STICKY
+  }
+
+  private fun startInForeground(notification: Notification) {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+      ServiceCompat.startForeground(
+        this, NOTIFICATION_ID, notification,
+        ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK
+      )
+    } else {
+      startForeground(NOTIFICATION_ID, notification)
+    }
+  }
+
+  private fun snooze(minutes: Int) {
+    val alarm = current ?: run { stopSelf(); return }
+    val mins = if (minutes > 0) minutes else alarm.snoozeMinutes
+    runCatching { AlarmScheduler.scheduleSnooze(this, alarm, mins) }
+      .onFailure { Log.e(TAG, "Could not schedule snooze", it) }
+    AlarmModule.emit(AlarmModule.EVENT_SNOOZED, alarm)
+    stopRinging()
+    stopSelf()
+  }
+
+  private fun dismiss() {
+    val alarm = current ?: run { stopSelf(); return }
+    // A dismissed snoozed alarm must not ring again from its snooze intent.
+    AlarmScheduler.cancelSnooze(this, alarm.id)
+    AlarmModule.emit(AlarmModule.EVENT_DISMISSED, alarm)
+    stopRinging()
+    stopSelf()
+  }
+
+  private fun stopRinging() {
+    handler.removeCallbacksAndMessages(null)
+    runCatching { player?.stop() }
+    runCatching { player?.release() }
+    player = null
+    vibrator?.cancel()
+    vibrator = null
+    wakeLock?.let { if (it.isHeld) it.release() }
+    wakeLock = null
+    current = null
+    AlarmRingActivity.finishIfOpen()
+    ServiceCompat.stopForeground(this, ServiceCompat.STOP_FOREGROUND_REMOVE)
+  }
+
+  override fun onDestroy() {
+    stopRinging()
+    super.onDestroy()
+  }
+
+  // ---- Sound ----
+
+  private fun startSound(alarm: AlarmData) {
+    val uri = alarm.sound.takeIf { it.isNotBlank() && it != "default" }?.let { Uri.parse(it) }
+      ?: RingtoneManager.getDefaultUri(RingtoneManager.TYPE_ALARM)
+      ?: RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE)
+
+    try {
+      val mp = MediaPlayer()
+      player = mp
+      mp.apply {
+        setAudioAttributes(
+          AudioAttributes.Builder()
+            .setUsage(AudioAttributes.USAGE_ALARM)
+            .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
+            .build()
+        )
+        setDataSource(this@AlarmService, uri)
+        isLooping = true
+        prepare()
+        start()
+      }
+    } catch (e: Exception) {
+      Log.e(TAG, "Could not play $uri, vibrating only", e)
+      runCatching { player?.release() }
+      player = null
+      startVibration() // last resort: at least wake the user somehow
+    }
+  }
+
+  // ---- Vibration ----
+
+  @Suppress("DEPRECATION")
+  private fun startVibration() {
+    if (vibrator != null) return
+    val v = getSystemService(Vibrator::class.java) ?: return
+    vibrator = v
+    val pattern = longArrayOf(0, 800, 400, 800, 800)
+    v.vibrate(
+      VibrationEffect.createWaveform(pattern, 0),
+      AudioAttributes.Builder().setUsage(AudioAttributes.USAGE_ALARM).build()
+    )
+  }
+
+  // ---- Plumbing ----
+
+  private fun acquireWakeLock() {
+    val pm = getSystemService(PowerManager::class.java)
+    wakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "rnalarm:ring").apply {
+      acquire(AUTO_TIMEOUT_MS + 60_000)
+    }
+  }
+
+  private fun ensureChannel(): NotificationManager {
+    val manager = getSystemService(NotificationManager::class.java)
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      manager.createNotificationChannel(
+        NotificationChannel(CHANNEL_ID, "Alarms", NotificationManager.IMPORTANCE_HIGH).apply {
+          setSound(null, null) // the service plays its own sound
+          enableVibration(false)
+          setBypassDnd(true)
+        }
+      )
+    }
+    return manager
+  }
+
+  private fun placeholderNotification(): Notification {
+    ensureChannel()
+    return NotificationCompat.Builder(this, CHANNEL_ID)
+      .setSmallIcon(applicationInfo.icon)
+      .setContentTitle("Alarm")
+      .build()
+  }
+
+  private fun buildNotification(alarm: AlarmData): Notification {
+    ensureChannel()
+    val ringIntent = Intent(this, AlarmRingActivity::class.java)
+      .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+    val fullScreen = PendingIntent.getActivity(
+      this, 1, ringIntent, PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
+    )
+    val b = NotificationCompat.Builder(this, CHANNEL_ID)
+      .setSmallIcon(applicationInfo.icon)
+      .setContentTitle(alarm.title.ifBlank { "Alarm" })
+      .setContentText(alarm.body.ifBlank { "Alarm is ringing" })
+      .setPriority(NotificationCompat.PRIORITY_MAX)
+      .setCategory(NotificationCompat.CATEGORY_ALARM)
+      .setOngoing(true)
+      .setAutoCancel(false)
+      .setFullScreenIntent(fullScreen, true)
+      .setContentIntent(fullScreen)
+      .addAction(0, "Stop", commandPI(ACTION_DISMISS, 2))
+    if (alarm.snoozeEnabled) {
+      b.addAction(0, "Snooze", commandPI(ACTION_SNOOZE, 3))
+    }
+    return b.build()
+  }
+
+  private fun commandPI(action: String, code: Int): PendingIntent =
+    PendingIntent.getService(
+      this, code, Intent(this, AlarmService::class.java).setAction(action),
+      PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
+    )
+
+  companion object {
+    private const val TAG = "AlarmService"
+    private const val CHANNEL_ID = "rn_alarm_channel"
+    private const val NOTIFICATION_ID = 1
+    private const val AUTO_TIMEOUT_MS = 5L * 60 * 1000
+
+    const val ACTION_SNOOZE = "com.alarm.service.SNOOZE"
+    const val ACTION_DISMISS = "com.alarm.service.DISMISS"
+    const val EXTRA_SNOOZE_MINUTES = "snoozeMinutes"
+
+    /** The alarm currently ringing, readable by [AlarmRingActivity] and [AlarmModule]. */
+    @Volatile
+    var current: AlarmData? = null
+      private set
+
+    fun start(context: Context, alarmId: String) {
+      androidx.core.content.ContextCompat.startForegroundService(
+        context,
+        Intent(context, AlarmService::class.java).putExtra(AlarmScheduler.EXTRA_ID, alarmId)
+      )
+    }
+
+    fun snooze(context: Context, minutes: Int = -1) =
+      command(context, Intent(context, AlarmService::class.java)
+        .setAction(ACTION_SNOOZE).putExtra(EXTRA_SNOOZE_MINUTES, minutes))
+
+    fun dismiss(context: Context) =
+      command(context, Intent(context, AlarmService::class.java).setAction(ACTION_DISMISS))
+
+    private fun command(context: Context, intent: Intent) {
+      if (current == null) return // nothing ringing; avoid starting a service for nothing
+      runCatching { context.startService(intent) }
+        .onFailure { Log.w(TAG, "Could not send ${intent.action}", it) }
+    }
+  }
+}

package/android/app/src/main/java/com/reactnativealarm/alarm/AlarmStore.kt

@@ -0,0 +1,13 @@
+package com.alarm
+
+import android.content.Context
+
+object AlarmStore {
+  private fun prefs(ctx: Context) = ctx.getSharedPreferences("rn_alarms", Context.MODE_PRIVATE)
+
+  fun save(ctx: Context, a: AlarmData) = prefs(ctx).edit().putString(a.id, a.toJson()).apply()
+  fun get(ctx: Context, id: String) = prefs(ctx).getString(id, null)?.let { AlarmData.fromJson(it) }
+  fun all(ctx: Context) = prefs(ctx).all.values.mapNotNull { (it as? String)?.let(AlarmData::fromJson) }
+  fun remove(ctx: Context, id: String) = prefs(ctx).edit().remove(id).apply()
+  fun clear(ctx: Context) = prefs(ctx).edit().clear().apply()
+}

package/android/app/src/main/java/com/reactnativealarm/alarm/BootReceiver.kt

@@ -0,0 +1,29 @@
+package com.alarm
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.util.Log
+
+/**
+ * AlarmManager registrations do not survive a reboot (or an app update, or a clock
+ * change that could make a computed trigger wrong). This receiver re-arms them all.
+ */
+class BootReceiver : BroadcastReceiver() {
+
+  override fun onReceive(context: Context, intent: Intent) {
+    when (intent.action) {
+      Intent.ACTION_BOOT_COMPLETED,
+      Intent.ACTION_MY_PACKAGE_REPLACED,
+      Intent.ACTION_TIME_CHANGED,
+      Intent.ACTION_TIMEZONE_CHANGED -> {
+        Log.i(TAG, "Re-arming alarms after ${intent.action}")
+        AlarmScheduler.scheduleAll(context)
+      }
+    }
+  }
+
+  companion object {
+    private const val TAG = "BootReceiver"
+  }
+}

package/android/app/src/main/res/drawable/rn_edit_text_material.xml

@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2014 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<inset xmlns:android="http://schemas.android.com/apk/res/android"
+       android:insetLeft="@dimen/abc_edit_text_inset_horizontal_material"
+       android:insetRight="@dimen/abc_edit_text_inset_horizontal_material"
+       android:insetTop="@dimen/abc_edit_text_inset_top_material"
+       android:insetBottom="@dimen/abc_edit_text_inset_bottom_material"
+       >
+
+    <selector>
+        <!--
+          This file is a copy of abc_edit_text_material (https://bit.ly/3k8fX7I).
+          The item below with state_pressed="false" and state_focused="false" causes a NullPointerException.
+          NullPointerException:tempt to invoke virtual method 'android.graphics.drawable.Drawable android.graphics.drawable.Drawable$ConstantState.newDrawable(android.content.res.Resources)'
+
+          <item android:state_pressed="false" android:state_focused="false" android:drawable="@drawable/abc_textfield_default_mtrl_alpha"/>
+
+          For more info, see https://bit.ly/3CdLStv (react-native/pull/29452) and https://bit.ly/3nxOMoR.
+        -->
+        <item android:state_enabled="false" android:drawable="@drawable/abc_textfield_default_mtrl_alpha"/>
+        <item android:drawable="@drawable/abc_textfield_activated_mtrl_alpha"/>
+    </selector>
+
+</inset>

package/android/app/src/main/res/values/strings.xml

@@ -0,0 +1,3 @@
+<resources>
+    <string name="app_name">ReactNativeAlarm</string>
+</resources>

package/android/app/src/main/res/values/styles.xml

@@ -0,0 +1,9 @@
+<resources>
+
+    <!-- Base application theme. -->
+    <style name="AppTheme" parent="Theme.AppCompat.DayNight.NoActionBar">
+        <!-- Customize your theme here. -->
+        <item name="android:editTextBackground">@drawable/rn_edit_text_material</item>
+    </style>
+
+</resources>

package/android/build.gradle

@@ -0,0 +1,21 @@
+buildscript {
+    ext {
+        buildToolsVersion = "37.0.0"
+        minSdkVersion = 24
+        compileSdkVersion = 37
+        targetSdkVersion = 36
+        ndkVersion = "27.1.12297006"
+        kotlinVersion = "2.2.0"
+    }
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath("com.android.tools.build:gradle")
+        classpath("com.facebook.react:react-native-gradle-plugin")
+        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin")
+    }
+}
+
+apply plugin: "com.facebook.react.rootproject"

package/android/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,7 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.4.1-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists