@saltcorn/mobile-app 1.6.3-beta.1 → 1.7.0-alpha.1

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.3-beta.1",
+  "version": "1.7.0-alpha.1",
   "description": "Saltcorn mobile app for Android and iOS",
   "main": "index.js",
   "scripts": {
@@ -16,7 +16,6 @@
   },
   "dependencies": {
     "universal-router": "9.2.1",
-    "axios": "0.32.0",
     "jwt-decode": "4.0.0",
     "i18next": "24.2.2",
     "i18next-sprintf-postprocessor": "0.2.2",

package/share_extension_files/Info.plist

@@ -2,6 +2,24 @@
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
+    <key>CFBundleDevelopmentRegion</key>
+    <string>en</string>
+    <key>CFBundleDisplayName</key>
+    <string>$(PRODUCT_NAME)</string>
+    <key>CFBundleExecutable</key>
+    <string>$(EXECUTABLE_NAME)</string>
+    <key>CFBundleIdentifier</key>
+    <string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+    <key>CFBundleInfoDictionaryVersion</key>
+    <string>6.0</string>
+    <key>CFBundleName</key>
+    <string>$(PRODUCT_NAME)</string>
+    <key>CFBundlePackageType</key>
+    <string>XPC!</string>
+    <key>CFBundleShortVersionString</key>
+    <string>$(MARKETING_VERSION)</string>
+    <key>CFBundleVersion</key>
+    <string>$(CURRENT_PROJECT_VERSION)</string>
     <key>NSExtension</key>
     <dict>
         <key>NSExtensionAttributes</key>
@@ -24,8 +42,8 @@
                     <false/>
                 </dict>
         </dict>
-        <key>NSExtensionMainStoryboard</key>
-        <string>MainInterface</string>
+        <key>NSExtensionPrincipalClass</key>
+        <string>$(PRODUCT_MODULE_NAME).ShareViewController</string>
         <key>NSExtensionPointIdentifier</key>
         <string>com.apple.share-services</string>
     </dict>

package/share_extension_files/ShareViewController.swift

@@ -10,89 +10,104 @@ import Social
 import UIKit
 
 class ShareItem {
-    
+
     public var title: String?
     public var type: String?
     public var url: String?
 }
 
 class ShareViewController: UIViewController {
-    
+
     private var shareItems: [ShareItem] = []
-    
-    override public func viewDidAppear(_ animated: Bool) {
-       super.viewDidAppear(animated)
-       self.extensionContext!.completeRequest(returningItems: [], completionHandler: nil)
-    }
-    
+
     private func sendData() {
+        // URLComponents.url already percent-encodes queryItems values when
+        // building the final URL string - encoding them here too caused
+        // double-encoding (e.g. "text/plain" arrived as "text%2Fplain"),
+        // which broke type checks like isFileItem() on the JS side.
         let queryItems = shareItems.map {
             [
-                URLQueryItem(
-                    name: "title",
-                    value: $0.title?.addingPercentEncoding(withAllowedCharacters: .urlHostAllowed) ?? ""),
+                URLQueryItem(name: "title", value: $0.title ?? ""),
                 URLQueryItem(name: "description", value: ""),
-                URLQueryItem(
-                    name: "type",
-                    value: $0.type?.addingPercentEncoding(withAllowedCharacters: .urlHostAllowed) ?? ""),
-                URLQueryItem(
-                    name: "url",
-                    value: $0.url?.addingPercentEncoding(withAllowedCharacters: .urlHostAllowed) ?? ""),
+                URLQueryItem(name: "type", value: $0.type ?? ""),
+                URLQueryItem(name: "url", value: $0.url ?? ""),
             ]
         }.flatMap({ $0 })
         var urlComps = URLComponents(string: "scappscheme://")!
         urlComps.queryItems = queryItems
         openURL(urlComps.url!)
     }
-    
+
     fileprivate func createSharedFileUrl(_ url: URL?) -> String {
-        let fileManager = FileManager.default
-        
-        let copyFileUrl =
-        fileManager.containerURL(forSecurityApplicationGroupIdentifier: "YOUR_APP_GROUP_ID")!
-            .absoluteString.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed)! + url!
-            .lastPathComponent.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed)!
-        try? Data(contentsOf: url!).write(to: URL(string: copyFileUrl)!)
-        
-        return copyFileUrl
+        guard let url = url else { return "" }
+        guard let containerURL = FileManager.default.containerURL(
+            forSecurityApplicationGroupIdentifier: "YOUR_APP_GROUP_ID"
+        ) else {
+            return ""
+        }
+        // appendingPathComponent handles escaping correctly on its own -
+        // hand-building a percent-encoded string here and then encoding it
+        // *again* as a URLQueryItem value in sendData() double-encoded it,
+        // so the path JS received didn't match any real file
+        let destinationURL = containerURL.appendingPathComponent(url.lastPathComponent)
+
+        // files vended by the Files app (iCloud, other apps' sandboxes) need
+        // this before they can actually be read - without it, Data(contentsOf:)
+        // fails and this used to silently return a path to a file that was
+        // never written
+        let didStartAccessing = url.startAccessingSecurityScopedResource()
+        defer {
+            if didStartAccessing { url.stopAccessingSecurityScopedResource() }
+        }
+        do {
+            try Data(contentsOf: url).write(to: destinationURL)
+            return destinationURL.absoluteString
+        } catch {
+            print("createSharedFileUrl failed: \(error)")
+            return ""
+        }
     }
-    
+
     func saveScreenshot(_ image: UIImage, _ index: Int) -> String {
-        let fileManager = FileManager.default
-        
-        let copyFileUrl =
-        fileManager.containerURL(forSecurityApplicationGroupIdentifier: "YOUR_APP_GROUP_ID")!
-            .absoluteString.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed)!
-        + "/screenshot_\(index).png"
+        guard let containerURL = FileManager.default.containerURL(
+            forSecurityApplicationGroupIdentifier: "YOUR_APP_GROUP_ID"
+        ) else {
+            return ""
+        }
+        let destinationURL = containerURL.appendingPathComponent("screenshot_\(index).png")
         do {
-            try image.pngData()?.write(to: URL(string: copyFileUrl)!)
-            return copyFileUrl
+            try image.pngData()?.write(to: destinationURL)
+            return destinationURL.absoluteString
         } catch {
-            print(error.localizedDescription)
+            print("saveScreenshot failed: \(error.localizedDescription)")
             return ""
         }
     }
-    
+
     fileprivate func handleTypeUrl(_ attachment: NSItemProvider)
     async throws -> ShareItem
     {
         let results = try await attachment.loadItem(forTypeIdentifier: kUTTypeURL as String, options: nil)
-        let url = results as! URL?
+        guard let url = results as? URL else {
+            throw NSError(domain: "ShareViewController", code: 1, userInfo: [
+                NSLocalizedDescriptionKey: "handleTypeUrl: expected a URL, got \(type(of: results))"
+            ])
+        }
         let shareItem: ShareItem = ShareItem()
-        
-        if url!.isFileURL {
-            shareItem.title = url!.lastPathComponent
-            shareItem.type = "application/" + url!.pathExtension.lowercased()
+
+        if url.isFileURL {
+            shareItem.title = url.lastPathComponent
+            shareItem.type = "application/" + url.pathExtension.lowercased()
             shareItem.url = createSharedFileUrl(url)
         } else {
-            shareItem.title = url!.absoluteString
-            shareItem.url = url!.absoluteString
+            shareItem.title = url.absoluteString
+            shareItem.url = url.absoluteString
             shareItem.type = "text/plain"
         }
-        
+
         return shareItem
     }
-    
+
     fileprivate func handleTypeText(_ attachment: NSItemProvider)
     async throws -> ShareItem
     {
@@ -103,25 +118,29 @@ class ShareViewController: UIViewController {
         shareItem.type = "text/plain"
         return shareItem
     }
-    
+
     fileprivate func handleTypeMovie(_ attachment: NSItemProvider)
     async throws -> ShareItem
     {
         let results = try await attachment.loadItem(forTypeIdentifier: kUTTypeMovie as String, options: nil)
         let shareItem: ShareItem = ShareItem()
-        
-        let url = results as! URL?
-        shareItem.title = url!.lastPathComponent
-        shareItem.type = "video/" + url!.pathExtension.lowercased()
+
+        guard let url = results as? URL else {
+            throw NSError(domain: "ShareViewController", code: 1, userInfo: [
+                NSLocalizedDescriptionKey: "handleTypeMovie: expected a URL, got \(type(of: results))"
+            ])
+        }
+        shareItem.title = url.lastPathComponent
+        shareItem.type = "video/" + url.pathExtension.lowercased()
         shareItem.url = createSharedFileUrl(url)
         return shareItem
     }
-    
+
     fileprivate func handleTypeImage(_ attachment: NSItemProvider, _ index: Int)
     async throws -> ShareItem
     {
         let data = try await attachment.loadItem(forTypeIdentifier: kUTTypeImage as String, options: nil)
-        
+
         let shareItem: ShareItem = ShareItem()
             switch data {
                 case let image as UIImage:
@@ -137,48 +156,58 @@ class ShareViewController: UIViewController {
         }
         return shareItem
     }
-    
+
     override public func viewDidLoad() {
         super.viewDidLoad()
-        
+
         shareItems.removeAll()
-        
+
         let extensionItem = extensionContext?.inputItems[0] as! NSExtensionItem
         Task {
-            try await withThrowingTaskGroup(
-                of: ShareItem.self,
-                body: { taskGroup in
-                    
-                    for (index, attachment) in extensionItem.attachments!.enumerated() {
-                        if attachment.hasItemConformingToTypeIdentifier(kUTTypeURL as String) {
-                            taskGroup.addTask {
-                                return try await self.handleTypeUrl(attachment)
-                            }
-                        } else if attachment.hasItemConformingToTypeIdentifier(kUTTypeText as String) {
-                            taskGroup.addTask {
-                                return try await self.handleTypeText(attachment)
-                            }
-                        } else if attachment.hasItemConformingToTypeIdentifier(kUTTypeMovie as String) {
-                            taskGroup.addTask {
-                                return try await self.handleTypeMovie(attachment)
-                            }
-                        } else if attachment.hasItemConformingToTypeIdentifier(kUTTypeImage as String) {
-                            taskGroup.addTask {
-                                return try await self.handleTypeImage(attachment, index)
+            do {
+                try await withThrowingTaskGroup(
+                    of: ShareItem.self,
+                    body: { taskGroup in
+
+                        for (index, attachment) in extensionItem.attachments!.enumerated() {
+                            if attachment.hasItemConformingToTypeIdentifier(kUTTypeURL as String) {
+                                taskGroup.addTask {
+                                    return try await self.handleTypeUrl(attachment)
+                                }
+                            } else if attachment.hasItemConformingToTypeIdentifier(kUTTypeText as String) {
+                                taskGroup.addTask {
+                                    return try await self.handleTypeText(attachment)
+                                }
+                            } else if attachment.hasItemConformingToTypeIdentifier(kUTTypeMovie as String) {
+                                taskGroup.addTask {
+                                    return try await self.handleTypeMovie(attachment)
+                                }
+                            } else if attachment.hasItemConformingToTypeIdentifier(kUTTypeImage as String) {
+                                taskGroup.addTask {
+                                    return try await self.handleTypeImage(attachment, index)
+                                }
                             }
                         }
-                    }
-                    
-                    for try await item in taskGroup {
-                        self.shareItems.append(item)
-                    }
-                })
-            
+
+                        for try await item in taskGroup {
+                            self.shareItems.append(item)
+                        }
+                    })
+            } catch {
+                // a bad attachment (e.g. an unexpected type) still needs to
+                // complete the request below, or the share sheet hangs
+                print("viewDidLoad: task group failed: \(error)")
+            }
+
             self.sendData()
-            
+            // only complete (letting the OS tear this extension down) once
+            // sendData() has actually handed off to the host app - doing
+            // this in viewDidAppear instead raced the async work above and
+            // usually won, killing the extension before openURL() ran
+            self.extensionContext!.completeRequest(returningItems: [], completionHandler: nil)
         }
     }
-    
+
     @objc func openURL(_ url: URL) {
         var responder: UIResponder? = self
         while responder != nil {
@@ -189,5 +218,5 @@ class ShareViewController: UIViewController {
             responder = responder?.next
         }
     }
-    
-}
+
+}