rn-persistent-timer 1.1.0

package/android/src/main/java/com/rnpersistenttimer/RNPersistentTimerModule.java

@@ -0,0 +1,164 @@
+// Android: RNPersistentTimerModule.java
+// Exposes native methods to JS and manages the ForegroundService
+
+package com.rnpersistenttimer;
+
+import android.content.Intent;
+import android.os.Build;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class RNPersistentTimerModule extends ReactContextBaseJavaModule {
+
+    public static final String MODULE_NAME = "RNPersistentTimer";
+    private static ReactApplicationContext reactContext;
+
+    // Active timers map: timerId -> start timestamp (ms)
+    private static final Map<String, Long> activeTimers = new HashMap<>();
+    private static final Map<String, Long> elapsedAtPause = new HashMap<>();
+
+    public RNPersistentTimerModule(ReactApplicationContext context) {
+        super(context);
+        reactContext = context;
+    }
+
+    @NonNull
+    @Override
+    public String getName() {
+        return MODULE_NAME;
+    }
+
+    // ─── JS-Exposed Methods ────────────────────────────────────────────────────
+
+    @ReactMethod
+    public void startTimer(ReadableMap options, Promise promise) {
+        try {
+            String timerId       = options.getString("timerId");
+            String mode          = options.hasKey("mode") ? options.getString("mode") : "stopwatch";
+            int duration         = options.hasKey("duration") ? options.getInt("duration") : 0;
+            int elapsed          = options.hasKey("elapsed") ? options.getInt("elapsed") : 0;
+            long startedAt       = options.hasKey("startedAt") ? (long) options.getDouble("startedAt") : System.currentTimeMillis();
+            boolean showNotif    = !options.hasKey("showNotification") || options.getBoolean("showNotification");
+
+            // Record start
+            activeTimers.put(timerId, startedAt - (elapsed * 1000L));
+
+            // Start foreground service
+            Intent serviceIntent = new Intent(reactContext, TimerForegroundService.class);
+            serviceIntent.putExtra("timerId", timerId);
+            serviceIntent.putExtra("mode", mode);
+            serviceIntent.putExtra("duration", duration);
+            serviceIntent.putExtra("elapsed", elapsed);
+            serviceIntent.putExtra("startedAt", startedAt);
+            serviceIntent.putExtra("showNotification", showNotif);
+            serviceIntent.setAction(TimerForegroundService.ACTION_START);
+
+            // Notification extras
+            if (options.hasKey("notification")) {
+                ReadableMap notif = options.getMap("notification");
+                if (notif != null) {
+                    serviceIntent.putExtra("notif_title",   notif.hasKey("title")   ? notif.getString("title")   : "Timer Running");
+                    serviceIntent.putExtra("notif_body",    notif.hasKey("body")    ? notif.getString("body")    : "{time}");
+                    serviceIntent.putExtra("notif_color",   notif.hasKey("color")   ? notif.getString("color")   : "#2196F3");
+                    serviceIntent.putExtra("notif_icon",    notif.hasKey("icon")    ? notif.getString("icon")    : "ic_notification");
+                    serviceIntent.putExtra("notif_actions", notif.hasKey("showActions") && notif.getBoolean("showActions"));
+                }
+            }
+
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                reactContext.startForegroundService(serviceIntent);
+            } else {
+                reactContext.startService(serviceIntent);
+            }
+
+            promise.resolve(null);
+        } catch (Exception e) {
+            promise.reject("TIMER_START_ERROR", e.getMessage(), e);
+        }
+    }
+
+    @ReactMethod
+    public void stopTimer(String timerId, Promise promise) {
+        try {
+            activeTimers.remove(timerId);
+            elapsedAtPause.remove(timerId);
+
+            Intent serviceIntent = new Intent(reactContext, TimerForegroundService.class);
+            serviceIntent.setAction(TimerForegroundService.ACTION_STOP);
+            serviceIntent.putExtra("timerId", timerId);
+            reactContext.startService(serviceIntent);
+
+            promise.resolve(null);
+        } catch (Exception e) {
+            promise.reject("TIMER_STOP_ERROR", e.getMessage(), e);
+        }
+    }
+
+    @ReactMethod
+    public void getElapsed(String timerId, Promise promise) {
+        Long startedAt = activeTimers.get(timerId);
+        if (startedAt == null) {
+            Long paused = elapsedAtPause.get(timerId);
+            promise.resolve(paused != null ? paused.intValue() : 0);
+        } else {
+            long elapsed = (System.currentTimeMillis() - startedAt) / 1000;
+            promise.resolve((int) elapsed);
+        }
+    }
+
+    @ReactMethod
+    public void getActiveTimers(Promise promise) {
+        WritableArray arr = Arguments.createArray();
+        for (String id : activeTimers.keySet()) {
+            arr.pushString(id);
+        }
+        promise.resolve(arr);
+    }
+
+    @ReactMethod
+    public void cancelAll(Promise promise) {
+        activeTimers.clear();
+        elapsedAtPause.clear();
+        Intent serviceIntent = new Intent(reactContext, TimerForegroundService.class);
+        serviceIntent.setAction(TimerForegroundService.ACTION_CANCEL_ALL);
+        reactContext.startService(serviceIntent);
+        promise.resolve(null);
+    }
+
+    @ReactMethod
+    public void isKilledStateSupported(Promise promise) {
+        // Android supports killed-state via WorkManager + AsyncStorage restore
+        promise.resolve(true);
+    }
+
+    // ─── Event Emitter to JS ─────────────────────────────────────────────────
+
+    public static void sendEvent(String eventName, WritableMap params) {
+        if (reactContext != null && reactContext.hasActiveReactInstance()) {
+            reactContext
+                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                .emit(eventName, params);
+        }
+    }
+
+    // Required for NativeEventEmitter
+    @ReactMethod
+    public void addListener(String eventName) {}
+    @ReactMethod
+    public void removeListeners(Integer count) {}
+}

package/android/src/main/java/com/rnpersistenttimer/RNPersistentTimerPackage.java

@@ -0,0 +1,27 @@
+// RNPersistentTimerPackage.java — React Native Package Registration
+
+package com.rnpersistenttimer;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class RNPersistentTimerPackage implements ReactPackage {
+
+    @Override
+    public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
+        List<NativeModule> modules = new ArrayList<>();
+        modules.add(new RNPersistentTimerModule(reactContext));
+        return modules;
+    }
+
+    @Override
+    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+        return Collections.emptyList();
+    }
+}

package/android/src/main/java/com/rnpersistenttimer/TimerForegroundService.java

@@ -0,0 +1,280 @@
+// Android: TimerForegroundService.java
+// Keeps the timer alive in background with a persistent notification
+
+package com.rnpersistenttimer;
+
+import android.app.Notification;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.app.Service;
+import android.content.Intent;
+import android.graphics.Color;
+import android.os.Build;
+import android.os.Handler;
+import android.os.IBinder;
+import android.os.Looper;
+
+import androidx.annotation.Nullable;
+import androidx.core.app.NotificationCompat;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableMap;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Locale;
+
+public class TimerForegroundService extends Service {
+
+    public static final String ACTION_START      = "ACTION_START";
+    public static final String ACTION_STOP       = "ACTION_STOP";
+    public static final String ACTION_CANCEL_ALL = "ACTION_CANCEL_ALL";
+    public static final String ACTION_PAUSE      = "ACTION_PAUSE";
+    public static final String ACTION_RESUME     = "ACTION_RESUME";
+
+    private static final String CHANNEL_ID   = "rn_persistent_timer_channel";
+    private static final String CHANNEL_NAME = "Timer Notifications";
+    private static final int    NOTIF_ID     = 7771;
+
+    // Active timers: timerId -> startedAtMs (adjusted for elapsed)
+    private final Map<String, Long>    timerStartTimes = new HashMap<>();
+    private final Map<String, Integer> timerDurations  = new HashMap<>();
+    private final Map<String, String>  timerModes      = new HashMap<>();
+
+    private Handler  handler;
+    private Runnable tickRunnable;
+    private boolean  running = false;
+
+    // Notification config (last started timer drives the notification)
+    private String notifTitle   = "Timer Running";
+    private String notifBody    = "{time}";
+    private String notifColor   = "#2196F3";
+    private boolean showActions = true;
+
+    @Override
+    public void onCreate() {
+        super.onCreate();
+        handler = new Handler(Looper.getMainLooper());
+        createNotificationChannel();
+    }
+
+    @Override
+    public int onStartCommand(Intent intent, int flags, int startId) {
+        if (intent == null) return START_STICKY;
+
+        String action = intent.getAction();
+        if (action == null) return START_STICKY;
+
+        switch (action) {
+            case ACTION_START:
+                handleStart(intent);
+                break;
+            case ACTION_STOP:
+                handleStop(intent.getStringExtra("timerId"));
+                break;
+            case ACTION_CANCEL_ALL:
+                handleCancelAll();
+                break;
+            case ACTION_PAUSE:
+                // handled from notification button
+                break;
+        }
+        return START_STICKY; // Restart if system kills service
+    }
+
+    private void handleStart(Intent intent) {
+        String  timerId    = intent.getStringExtra("timerId");
+        String  mode       = intent.getStringExtra("mode");
+        int     elapsed    = intent.getIntExtra("elapsed", 0);
+        long    startedAt  = intent.getLongExtra("startedAt", System.currentTimeMillis());
+        int     duration   = intent.getIntExtra("duration", 0);
+        boolean showNotif  = intent.getBooleanExtra("showNotification", true);
+
+        notifTitle   = intent.getStringExtra("notif_title") != null ? intent.getStringExtra("notif_title") : notifTitle;
+        notifBody    = intent.getStringExtra("notif_body")  != null ? intent.getStringExtra("notif_body")  : notifBody;
+        notifColor   = intent.getStringExtra("notif_color") != null ? intent.getStringExtra("notif_color") : notifColor;
+        showActions  = intent.getBooleanExtra("notif_actions", true);
+
+        // Adjust startedAt for already-elapsed seconds
+        long adjustedStart = startedAt - ((long) elapsed * 1000);
+        timerStartTimes.put(timerId, adjustedStart);
+        timerModes.put(timerId, mode != null ? mode : "stopwatch");
+        timerDurations.put(timerId, duration);
+
+        if (!running) {
+            running = true;
+            Notification notification = showNotif ? buildNotification("00:00:00") : buildSilentNotification();
+            startForeground(NOTIF_ID, notification);
+            startTicking();
+        }
+    }
+
+    private void handleStop(String timerId) {
+        if (timerId == null) return;
+        timerStartTimes.remove(timerId);
+        timerModes.remove(timerId);
+        timerDurations.remove(timerId);
+
+        if (timerStartTimes.isEmpty()) {
+            stopTicking();
+            stopForeground(true);
+            stopSelf();
+            running = false;
+        }
+    }
+
+    private void handleCancelAll() {
+        timerStartTimes.clear();
+        timerModes.clear();
+        timerDurations.clear();
+        stopTicking();
+        stopForeground(true);
+        stopSelf();
+        running = false;
+    }
+
+    private void startTicking() {
+        tickRunnable = new Runnable() {
+            @Override
+            public void run() {
+                if (!running) return;
+
+                long now = System.currentTimeMillis();
+                String displayTime = "00:00:00";
+
+                for (Map.Entry<String, Long> entry : timerStartTimes.entrySet()) {
+                    String timerId   = entry.getKey();
+                    long   startedAt = entry.getValue();
+                    String mode      = timerModes.getOrDefault(timerId, "stopwatch");
+                    int    duration  = timerDurations.getOrDefault(timerId, 0);
+
+                    long elapsedSeconds = (now - startedAt) / 1000;
+
+                    int displaySeconds;
+                    if ("countdown".equals(mode)) {
+                        displaySeconds = (int) Math.max(0, duration - elapsedSeconds);
+                        if (displaySeconds == 0) {
+                            // Timer completed
+                            WritableMap params = Arguments.createMap();
+                            params.putString("timerId", timerId);
+                            RNPersistentTimerModule.sendEvent("RNPersistentTimer_complete", params);
+                        }
+                    } else {
+                        displaySeconds = (int) elapsedSeconds;
+                    }
+
+                    displayTime = formatSeconds(displaySeconds);
+
+                    // Emit tick to JS
+                    WritableMap params = Arguments.createMap();
+                    params.putString("timerId", timerId);
+                    params.putInt("elapsed", (int) elapsedSeconds);
+                    params.putInt("remaining", "countdown".equals(mode) ? (int) Math.max(0, duration - elapsedSeconds) : -1);
+                    RNPersistentTimerModule.sendEvent("RNPersistentTimer_tick", params);
+                }
+
+                // Update notification with last timer's display time
+                updateNotification(displayTime);
+
+                handler.postDelayed(this, 1000);
+            }
+        };
+        handler.post(tickRunnable);
+    }
+
+    private void stopTicking() {
+        if (tickRunnable != null) {
+            handler.removeCallbacks(tickRunnable);
+            tickRunnable = null;
+        }
+    }
+
+    // ─── Notification ─────────────────────────────────────────────────────────
+
+    private void createNotificationChannel() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            NotificationChannel channel = new NotificationChannel(
+                CHANNEL_ID, CHANNEL_NAME, NotificationManager.IMPORTANCE_LOW
+            );
+            channel.setDescription("Persistent timer notifications");
+            channel.setSound(null, null);
+            NotificationManager nm = getSystemService(NotificationManager.class);
+            if (nm != null) nm.createNotificationChannel(channel);
+        }
+    }
+
+    private Notification buildNotification(String timeStr) {
+        Intent openApp = getPackageManager().getLaunchIntentForPackage(getPackageName());
+        PendingIntent pendingIntent = PendingIntent.getActivity(
+            this, 0, openApp,
+            Build.VERSION.SDK_INT >= Build.VERSION_CODES.M
+                ? PendingIntent.FLAG_IMMUTABLE : 0
+        );
+
+        int colorInt;
+        try { colorInt = Color.parseColor(notifColor); }
+        catch (Exception e) { colorInt = Color.parseColor("#2196F3"); }
+
+        String body = notifBody.replace("{time}", timeStr);
+
+        NotificationCompat.Builder builder = new NotificationCompat.Builder(this, CHANNEL_ID)
+            .setContentTitle(notifTitle)
+            .setContentText(body)
+            .setSmallIcon(android.R.drawable.ic_dialog_info)
+            .setColor(colorInt)
+            .setOngoing(true)
+            .setOnlyAlertOnce(true)
+            .setSilent(true)
+            .setContentIntent(pendingIntent);
+
+        if (showActions) {
+            Intent pauseIntent = new Intent(this, TimerForegroundService.class);
+            pauseIntent.setAction(ACTION_PAUSE);
+            PendingIntent pausePending = PendingIntent.getService(
+                this, 1, pauseIntent,
+                Build.VERSION.SDK_INT >= Build.VERSION_CODES.M
+                    ? PendingIntent.FLAG_IMMUTABLE : 0
+            );
+            builder.addAction(android.R.drawable.ic_media_pause, "Pause", pausePending);
+        }
+
+        return builder.build();
+    }
+
+    private Notification buildSilentNotification() {
+        return new NotificationCompat.Builder(this, CHANNEL_ID)
+            .setContentTitle("Timer")
+            .setSmallIcon(android.R.drawable.ic_dialog_info)
+            .setOngoing(true)
+            .setSilent(true)
+            .setPriority(NotificationCompat.PRIORITY_MIN)
+            .build();
+    }
+
+    private void updateNotification(String timeStr) {
+        Notification notification = buildNotification(timeStr);
+        NotificationManager nm = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
+        if (nm != null) nm.notify(NOTIF_ID, notification);
+    }
+
+    private static String formatSeconds(int totalSeconds) {
+        int h = totalSeconds / 3600;
+        int m = (totalSeconds % 3600) / 60;
+        int s = totalSeconds % 60;
+        return String.format(Locale.US, "%02d:%02d:%02d", h, m, s);
+    }
+
+    @Nullable
+    @Override
+    public IBinder onBind(Intent intent) {
+        return null;
+    }
+
+    @Override
+    public void onDestroy() {
+        stopTicking();
+        running = false;
+        super.onDestroy();
+    }
+}

package/ios/RNPersistentTimer.h

@@ -0,0 +1,10 @@
+/*
+ * RNPersistentTimer.h
+ * Public header for the iOS native module.
+ */
+
+#import <React/RCTEventEmitter.h>
+#import <React/RCTBridgeModule.h>
+
+@interface RNPersistentTimer : RCTEventEmitter <RCTBridgeModule>
+@end