@saltcorn/mobile-app 1.6.0 → 1.7.0-alpha.0

package/optional_sources/background.js

@@ -0,0 +1,134 @@
+import { BackgroundFetch } from "@transistorsoft/capacitor-background-fetch";
+import { performSync, performHeartbeat } from "./background_tasks.js";
+
+const SYNC_TASK_ID = "com.transistorsoft.background_sync";
+const HEARTBEAT_TASK_ID = "com.transistorsoft.push_sync_heartbeat";
+
+let isConfigured = false;
+
+/**
+ * Call BackgroundFetch.configure() with a task-routing callback.
+ * Sets isConfigured on success.
+ * @param {number} minimumFetchInterval hint to the OS in minutes
+ */
+async function configure(minimumFetchInterval) {
+  const status = await BackgroundFetch.configure(
+    { minimumFetchInterval },
+    async (taskId) => {
+      switch (taskId) {
+        case SYNC_TASK_ID:
+          try {
+            await performSync();
+          } catch (e) {
+            console.error("Background sync error:", e);
+          }
+          break;
+        case HEARTBEAT_TASK_ID:
+          try {
+            await performHeartbeat();
+          } catch (e) {
+            console.error("Heartbeat error:", e);
+          }
+          break;
+        default:
+          console.log("[BackgroundFetch] unknown task:", taskId);
+      }
+      BackgroundFetch.finish(taskId);
+    },
+    async (taskId) => {
+      console.log("[BackgroundFetch] TIMEOUT:", taskId);
+      BackgroundFetch.finish(taskId);
+    }
+  );
+
+  if (status === BackgroundFetch.STATUS_AVAILABLE) {
+    isConfigured = true;
+    console.log("BackgroundFetch configured successfully");
+  } else if (status === BackgroundFetch.STATUS_DENIED) {
+    console.log("BackgroundFetch: user denied background behavior");
+  } else if (status === BackgroundFetch.STATUS_RESTRICTED) {
+    console.log("BackgroundFetch: background updates restricted");
+  }
+}
+
+/**
+ * Schedule the configured named tasks via BackgroundFetch.scheduleTask.
+ * @param {number|undefined} syncInterval background-sync interval in minutes
+ * @param {number|undefined} heartbeatInterval push-sync heartbeat interval in minutes
+ */
+async function scheduleTasks(syncInterval, heartbeatInterval) {
+  if (syncInterval > 0) {
+    try {
+      await BackgroundFetch.scheduleTask({
+        taskId: SYNC_TASK_ID,
+        delay: syncInterval * 60 * 1000,
+        periodic: true,
+        requiresNetworkConnectivity: true,
+      });
+      console.log(
+        `Background sync scheduled, interval: ${syncInterval} minute(s)`
+      );
+    } catch (e) {
+      console.error("Error scheduling sync task:", e);
+    }
+  }
+
+  if (heartbeatInterval > 0) {
+    try {
+      await BackgroundFetch.scheduleTask({
+        taskId: HEARTBEAT_TASK_ID,
+        delay: heartbeatInterval * 60 * 1000,
+        periodic: true,
+        requiresNetworkConnectivity: true,
+      });
+      console.log(
+        `Push sync heartbeat scheduled, interval: ${heartbeatInterval} minute(s)`
+      );
+    } catch (e) {
+      console.error("Error scheduling heartbeat task:", e);
+    }
+  }
+}
+
+/**
+ * Init background tasks. Routes task IDs to performSync / performHeartbeat
+ * from background_tasks.js. Only tasks with a configured interval are scheduled.
+ * @param {number|undefined} syncInterval background-sync interval in minutes
+ * @param {number|undefined} heartbeatInterval push-sync heartbeat interval in minutes
+ * @returns {Promise<boolean>} true if BackgroundFetch was configured successfully
+ */
+export async function initBackground(syncInterval, heartbeatInterval) {
+  const hasSyncInterval = syncInterval && syncInterval > 0;
+  const hasHeartbeatInterval = heartbeatInterval && heartbeatInterval > 0;
+
+  if (!hasSyncInterval && !hasHeartbeatInterval) {
+    console.log("initBackground: no intervals configured, skipping");
+    return false;
+  }
+
+  if (!isConfigured) {
+    const minimumFetchInterval = Math.min(
+      hasSyncInterval ? syncInterval : Infinity,
+      hasHeartbeatInterval ? heartbeatInterval : Infinity
+    );
+    await configure(minimumFetchInterval);
+  }
+
+  if (isConfigured) await scheduleTasks(syncInterval, heartbeatInterval);
+
+  return isConfigured;
+}
+
+/**
+ * Stop all background tasks (sync + heartbeat). Call on logout.
+ */
+export async function stopBackground() {
+  if (!isConfigured) return;
+  try {
+    await BackgroundFetch.stop();
+    isConfigured = false;
+    console.log("Background tasks stopped");
+  } catch (e) {
+    console.error("Error stopping background tasks:", e);
+  }
+}

package/optional_sources/ios_silent_push.js

@@ -0,0 +1,31 @@
+/*global saltcorn*/
+
+import { CapacitorSilentNotifications } from "capacitor-plugin-silent-notifications";
+
+let silentNotificationListener = null;
+
+export async function initIosSilentPushListener() {
+  if (silentNotificationListener) {
+    await silentNotificationListener.remove();
+    silentNotificationListener = null;
+  }
+  silentNotificationListener = await CapacitorSilentNotifications.addListener(
+    "silentNotificationReceived",
+    async (notification) => {
+      console.log("iOS silent push received:", notification);
+      const state = saltcorn.data.state.getState();
+      if (state.mobile_push_handler?.["push_sync"]) {
+        try {
+          await state.mobile_push_handler["push_sync"](notification);
+        } catch (error) {
+          console.error("Error handling push_sync silent notification:", error);
+        }
+      }
+    }
+  );
+}
+
+export async function removeIosSilentPushListener() {
+  await silentNotificationListener?.remove();
+  silentNotificationListener = null;
+}

package/optional_sources/notifications.js

@@ -11,28 +11,40 @@ import { Device } from "@capacitor/device";
  */
 async function notifyTokenApi(config, isSubscribe) {
   console.log("notifyTokenApi subscribe:", isSubscribe);
+  if (!config.pushConfiguration) {
+    console.warn("notifyTokenApi: pushConfiguration is not set, skipping");
+    return;
+  }
   const { token, deviceId } = config.pushConfiguration;
   const platform = Capacitor.getPlatform();
   try {
     const response = await apiCall({
       method: "POST",
-      path: `/notifications/mobile-${isSubscribe ? "subscribe" : "remove-subscription"}`,
+      path: `/notifications/mobile-${
+        isSubscribe ? "subscribe" : "remove-subscription"
+      }`,
       body: { token, deviceId, platform },
     });
     const data = response.data;
     if (data.success === "ok")
       console.log(
-        `successfully ${isSubscribe ? "subscribed" : "unsubscribed"} to push notifications`,
+        `successfully ${
+          isSubscribe ? "subscribed" : "unsubscribed"
+        } to push notifications`,
         data
       );
     else
       console.error(
-        `unable to ${isSubscribe ? "subscribe" : "unsubscribe"} to push notifications`,
+        `unable to ${
+          isSubscribe ? "subscribe" : "unsubscribe"
+        } to push notifications`,
         data
       );
   } catch (error) {
     console.error(
-      `unable to ${isSubscribe ? "subscribe" : "unsubscribe"} to push notifications`,
+      `unable to ${
+        isSubscribe ? "subscribe" : "unsubscribe"
+      } to push notifications`,
       error
     );
   }
@@ -45,18 +57,30 @@ async function notifyTokenApi(config, isSubscribe) {
  */
 async function syncTokenApi(config, isSubscribe) {
   console.log("syncTokenApi subscribe:", isSubscribe);
+  if (!config.pushConfiguration) {
+    console.warn("syncTokenApi: pushConfiguration is not set, skipping");
+    return;
+  }
   const { token, deviceId } = config.pushConfiguration;
   const platform = Capacitor.getPlatform();
   try {
     const response = await apiCall({
       method: "POST",
       path: `/sync/push_${isSubscribe ? "subscribe" : "unsubscribe"}`,
-      body: { token, deviceId, synchedTables: config.synchedTables, platform },
+      body: {
+        token,
+        deviceId,
+        synchedTables: config.synchedTables,
+        platform,
+        apnsEnvironment: config.apnsEnvironment,
+      },
     });
     const data = response.data;
     if (data.success === "ok")
       console.log(
-        `successfully ${isSubscribe ? "subscribed" : "unsubscribed"} to push sync`,
+        `successfully ${
+          isSubscribe ? "subscribed" : "unsubscribed"
+        } to push sync`,
         data
       );
     else
@@ -94,7 +118,6 @@ export async function initPushNotifications() {
     await removePushListeners();
     const permStatus = await PushNotifications.requestPermissions();
     if (permStatus.receive === "granted") {
-      await PushNotifications.register();
       registrationListener = PushNotifications.addListener(
         "registration",
         async (token) => {
@@ -109,8 +132,7 @@ export async function initPushNotifications() {
               deviceId: identifier,
             };
             await notifyTokenApi(config, true);
-            if (config.allowOfflineMode && config.pushSync)
-              await syncTokenApi(config, true);
+            if (config.pushSync) await syncTokenApi(config, true);
           }
         }
       );
@@ -126,6 +148,8 @@ export async function initPushNotifications() {
         "pushNotificationReceived",
         messageHandler
       );
+
+      await PushNotifications.register();
     } else {
       console.warn("Push notification permission not granted");
     }
@@ -134,17 +158,29 @@ export async function initPushNotifications() {
 
 export async function unregisterPushNotifications() {
   if (Capacitor.getPlatform() !== "web" && PushNotifications) {
+    const config = saltcorn.data.state.getState().mobileConfig;
     try {
       await PushNotifications.unregister();
-      const config = saltcorn.data.state.getState().mobileConfig;
       await notifyTokenApi(config, false);
-      if (config.allowOfflineMode && config.pushSync)
+      if (config.pushSync) {
         await syncTokenApi(config, false);
-      await removePushListeners();
-      config.pushConfiguration = null;
+        if (Capacitor.getPlatform() === "ios") {
+          try {
+            const { removeIosSilentPushListener } = await import(
+              "../helpers/ios_silent_push.js"
+            );
+            await removeIosSilentPushListener();
+          } catch (e) {
+            console.log("iOS silent push not available:", e);
+          }
+        }
+      }
       console.log("Push notifications unregistered successfully");
     } catch (error) {
       console.error("Error unregistering push notifications:", error);
+    } finally {
+      await removePushListeners();
+      config.pushConfiguration = null;
     }
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@saltcorn/mobile-app",
   "displayName": "Saltcorn mobile app",
-  "version": "1.6.0",
+  "version": "1.7.0-alpha.0",
   "description": "Saltcorn mobile app for Android and iOS",
   "main": "index.js",
   "scripts": {

package/src/helpers/background_tasks.js

@@ -0,0 +1,47 @@
+/*global saltcorn*/
+
+import { Capacitor } from "@capacitor/core";
+import { apiCall } from "./api.js";
+import { sync } from "./offline_mode.js";
+
+/**
+ * Perform one background sync pass.
+ */
+export async function performSync() {
+  console.log("Background sync starting:", new Date().toISOString());
+  await sync(true);
+  console.log("Background sync finished:", new Date().toISOString());
+}
+
+/**
+ * Re-register the push sync subscription with the server.
+ */
+export async function performHeartbeat() {
+  const config = saltcorn.data.state.getState().mobileConfig;
+  if (!config?.pushSync || !config?.pushConfiguration) {
+    console.log("Push sync heartbeat: skipping (push sync not active)");
+    return;
+  }
+  const { token, deviceId } = config.pushConfiguration;
+  const platform = Capacitor.getPlatform();
+  console.log("Push sync heartbeat: re-registering subscription");
+  try {
+    const response = await apiCall({
+      method: "POST",
+      path: "/sync/push_subscribe",
+      body: {
+        token,
+        deviceId,
+        platform,
+        synchedTables: config.synchedTables,
+        apnsEnvironment: config.apnsEnvironment,
+      },
+    });
+    const data = response.data;
+    if (data.success === "ok")
+      console.log("Push sync heartbeat: subscription refreshed");
+    else console.error("Push sync heartbeat: server error", data);
+  } catch (e) {
+    console.error("Push sync heartbeat error:", e);
+  }
+}

package/src/helpers/common.js

@@ -1,6 +1,7 @@
 /*global saltcorn, $*/
 
 import { apiCall } from "./api";
+import { Capacitor } from "@capacitor/core";
 import { Camera, CameraResultType } from "@capacitor/camera";
 import { ScreenOrientation } from "@capacitor/screen-orientation";
 import { SendIntent } from "send-intent";
@@ -224,7 +225,19 @@ export async function tryInitPush(config) {
     try {
       await initPushNotifications();
       if (saltcorn.data.utils.isPushEnabled(config.user)) addPusNotifyHandler();
-      if (config.pushSync) addPushSyncHandler();
+      if (config.pushSync) {
+        addPushSyncHandler();
+        if (Capacitor.getPlatform() === "ios") {
+          try {
+            const { initIosSilentPushListener } = await import(
+              "../helpers/ios_silent_push.js"
+            );
+            await initIosSilentPushListener();
+          } catch (e) {
+            console.log("iOS silent push not available:", e);
+          }
+        }
+      }
     } catch (error) {
       console.error("Error initializing push notifications:", error);
     }
@@ -234,21 +247,26 @@ export async function tryInitPush(config) {
 }
 
 /**
- * init background sync, if available
+ * init background tasks (sync and/or push-sync heartbeat), if available
  */
 export async function tryInitBackgroundSync(config) {
+  if (
+    !(config.syncInterval && config.syncInterval > 0) &&
+    !(config.pushSyncHeartbeatInterval && config.pushSyncHeartbeatInterval > 0)
+  )
+    return;
   try {
-    const { startPeriodicBackgroundSync } = await import(
-      "../helpers/background_sync.js"
-    );
+    const { initBackground } = await import("../helpers/background.js");
     try {
-      if (config.syncInterval && config.syncInterval > 0)
-        await startPeriodicBackgroundSync(config.syncInterval);
+      await initBackground(
+        config.syncInterval,
+        config.pushSyncHeartbeatInterval
+      );
     } catch (error) {
-      console.error("Error initializing background sync:", error);
+      console.error("Error initializing background tasks:", error);
     }
   } catch (error) {
-    console.log("Background sync module not available:", error);
+    console.log("Background module not available:", error);
   }
 }
 
@@ -271,19 +289,17 @@ export async function tryUnregisterPush() {
 }
 
 /**
- * stop background sync, if available
+ * stop background tasks (sync and/or push-sync heartbeat), if available
  */
 export async function tryStopBackgroundSync() {
   try {
-    const { stopPeriodicBackgroundSync } = await import(
-      "../helpers/background_sync.js"
-    );
+    const { stopBackground } = await import("../helpers/background.js");
     try {
-      await stopPeriodicBackgroundSync();
+      await stopBackground();
     } catch (error) {
-      console.error("Error stopping periodic background sync:", error);
+      console.error("Error stopping background tasks:", error);
     }
   } catch (error) {
-    console.error("Push notifications module not available:", error);
+    console.log("Background module not available:", error);
   }
 }

package/add_entitlements.rb

@@ -1,16 +0,0 @@
-require 'xcodeproj'
-
-project_path = 'ios/App/App.xcodeproj'
-target_name  = 'App'
-entitlements_relative_path = 'App/App.entitlements'
-
-project = Xcodeproj::Project.open(project_path)
-target = project.targets.find { |t| t.name == target_name }
-abort("Target '#{target_name}' not found") unless target
-
-target.build_configurations.each do |config|
-  config.build_settings['CODE_SIGN_ENTITLEMENTS'] = entitlements_relative_path
-end
-
-project.save
-puts "Entitlements configured successfully for target '#{target_name}'"

package/optional_sources/background_sync.js

@@ -1,91 +0,0 @@
-import { BackgroundFetch } from "@transistorsoft/capacitor-background-fetch";
-import { sync } from "./offline_mode.js";
-
-let isConfigured = false;
-
-/**
- * Init the periodic background sync with a min interval.
- * This runs the sync even if the app is in background or was swipe closed.
- * If no internet connection is available it fails silently.
- * @param {number} interval min time interval in minutes. The system decides when to actually do it
- * @returns {Promise<boolean>} True if configuration was successful, false otherwise.
- */
-export async function startPeriodicBackgroundSync(interval = 15) {
-  if (isConfigured) {
-    console.log("Background sync is already configured. Skipping.");
-    return true;
-  }
-
-  console.log("Configuring background sync with interval (minutes):", interval);
-
-  const status = await BackgroundFetch.configure(
-    {
-      minimumFetchInterval: interval,
-    },
-    async (taskId) => {
-      console.log(
-        "Starting background sync:",
-        taskId,
-        new Date().toISOString()
-      );
-      await sync(true);
-      console.log(
-        "Background sync finished:",
-        taskId,
-        new Date().toISOString()
-      );
-      BackgroundFetch.finish(taskId);
-    },
-    async (taskId) => {
-      console.log("[BackgroundFetch] TIMEOUT:", taskId);
-      BackgroundFetch.finish(taskId);
-    }
-  );
-
-  if (status === BackgroundFetch.STATUS_AVAILABLE) {
-    console.log("Background sync successfully configured.");
-    isConfigured = true; // Set the flag only on success
-    return true;
-  } else {
-    // Handle error statuses
-    if (status === BackgroundFetch.STATUS_DENIED) {
-      console.log(
-        "The user explicitly disabled background behavior for this app or for the whole system."
-      );
-    } else if (status === BackgroundFetch.STATUS_RESTRICTED) {
-      console.log(
-        "Background updates are unavailable and the user cannot enable them again."
-      );
-    }
-    isConfigured = false;
-    return false;
-  }
-}
-
-/**
- * Stops/Unregisters the periodic background sync.
- * This should be called when the user logs out.
- */
-export async function stopPeriodicBackgroundSync() {
-  if (!isConfigured) {
-    console.log("Background sync is not currently configured. Skipping stop.");
-    return;
-  }
-
-  console.log("Stopping background sync");
-  try {
-    await BackgroundFetch.stop();
-    console.log("Background sync successfully stopped.");
-    isConfigured = false;
-  } catch (error) {
-    console.error("Error stopping background sync:", error);
-  }
-}
-
-/**
- * Check if the background sync is currently configured/enabled.
- * @returns {boolean} True if the sync is configured, false otherwise.
- */
-export function isBackgroundSyncActive() {
-  return isConfigured;
-}