@saltcorn/mobile-app 1.5.0-beta.8 → 1.5.0-rc.1

package/optional_sources/background_sync.js

@@ -0,0 +1,91 @@
+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;
+}

package/optional_sources/notifications.js

@@ -0,0 +1,172 @@
+/*global saltcorn*/
+
+import { Capacitor } from "@capacitor/core";
+import { apiCall } from "./api";
+import { showToasts } from "./common";
+import { PushNotifications } from "@capacitor/push-notifications";
+import { Device } from "@capacitor/device";
+
+/**
+ * internal helper to subscribe or unsubscribe to push notifications (server side)
+ */
+async function notifyTokenApi(config, isSubscribe) {
+  console.log("notifyTokenApi subscribe:", isSubscribe);
+  const { token, deviceId } = config.pushConfiguration;
+  try {
+    const response = await apiCall({
+      method: "POST",
+      path: `/notifications/mobile-${isSubscribe ? "subscribe" : "remove-subscription"}`,
+      body: { token, deviceId },
+    });
+    const data = response.data;
+    if (data.success === "ok")
+      console.log(
+        `successfully ${isSubscribe ? "subscribed" : "unsubscribed"} to push notifications`,
+        data
+      );
+    else
+      console.error(
+        `unable to ${isSubscribe ? "subscribe" : "unsubscribe"} to push notifications`,
+        data
+      );
+  } catch (error) {
+    console.error(
+      `unable to ${isSubscribe ? "subscribe" : "unsubscribe"} to push notifications`,
+      error
+    );
+  }
+}
+
+/**
+ * internal helper to subscribe or unsubscribe to push sync (server side)
+ * @param {*} config
+ * @param {*} isSubscribe
+ */
+async function syncTokenApi(config, isSubscribe) {
+  console.log("syncTokenApi subscribe:", isSubscribe);
+  const { token, deviceId } = config.pushConfiguration;
+  try {
+    const response = await apiCall({
+      method: "POST",
+      path: `/sync/push_${isSubscribe ? "subscribe" : "unsubscribe"}`,
+      body: { token, deviceId, synchedTables: config.synchedTables },
+    });
+    const data = response.data;
+    if (data.success === "ok")
+      console.log(
+        `successfully ${isSubscribe ? "subscribed" : "unsubscribed"} to push sync`,
+        data
+      );
+    else
+      console.error(
+        `unable to ${isSubscribe ? "subscribe" : "unsubscribe"} to push sync`,
+        data
+      );
+  } catch (error) {
+    console.error(
+      `unable to ${isSubscribe ? "subscribe" : "unsubscribe"} to push sync`,
+      error
+    );
+  }
+}
+
+async function messageHandler(notification) {
+  console.log("Push received:", notification);
+  const state = saltcorn.data.state.getState();
+  const type = notification.data?.type;
+  if (type && state.mobile_push_handler?.[type]) {
+    try {
+      await state.mobile_push_handler[type](notification);
+    } catch (error) {
+      console.error(`Error handling '${type}' push notification:`, error);
+    }
+  }
+}
+
+let registrationListener = null;
+let registrationErrorListener = null;
+let pushReceivedListener = null;
+
+export async function initPushNotifications() {
+  if (Capacitor.getPlatform() !== "web" && PushNotifications) {
+    await removePushListeners();
+    const permStatus = await PushNotifications.requestPermissions();
+    if (permStatus.receive === "granted") {
+      await PushNotifications.register();
+      registrationListener = PushNotifications.addListener(
+        "registration",
+        async (token) => {
+          console.log("Push registration success, token:", token.value);
+          const config = saltcorn.data.state.getState().mobileConfig;
+          if (config.pushConfiguration) {
+            console.log("Push already registered");
+          } else {
+            const { identifier } = await Device.getId();
+            config.pushConfiguration = {
+              token: token.value,
+              deviceId: identifier,
+            };
+            await notifyTokenApi(config, true);
+            if (config.allowOfflineMode && config.pushSync)
+              await syncTokenApi(config, true);
+          }
+        }
+      );
+
+      registrationErrorListener = PushNotifications.addListener(
+        "registrationError",
+        (err) => {
+          console.error("Push registration error:", err);
+        }
+      );
+
+      pushReceivedListener = PushNotifications.addListener(
+        "pushNotificationReceived",
+        messageHandler
+      );
+    } else {
+      console.warn("Push notification permission not granted");
+    }
+  }
+}
+
+export async function unregisterPushNotifications() {
+  if (Capacitor.getPlatform() !== "web" && PushNotifications) {
+    try {
+      await PushNotifications.unregister();
+      const config = saltcorn.data.state.getState().mobileConfig;
+      await notifyTokenApi(config, false);
+      if (config.allowOfflineMode && config.pushSync)
+        await syncTokenApi(config, false);
+      await removePushListeners();
+      config.pushConfiguration = null;
+      console.log("Push notifications unregistered successfully");
+    } catch (error) {
+      console.error("Error unregistering push notifications:", error);
+    }
+  }
+}
+
+export function addPusNotifyHandler() {
+  const state = saltcorn.data.state.getState();
+  state.mobile_push_handler["push_notification"] = (notification) => {
+    console.log("Push notification received:", notification);
+    showToasts([
+      {
+        type: "info",
+        msg: notification.body,
+        title: notification.title,
+      },
+    ]);
+  };
+}
+
+async function removePushListeners() {
+  await registrationListener?.remove();
+  await registrationErrorListener?.remove();
+  await pushReceivedListener?.remove();
+
+  registrationListener = null;
+  registrationErrorListener = null;
+  pushReceivedListener = null;
+}

package/package.json

@@ -1,14 +1,12 @@
 {
   "name": "@saltcorn/mobile-app",
   "displayName": "Saltcorn mobile app",
-  "version": "1.5.0-beta.8",
+  "version": "1.5.0-rc.1",
   "description": "Saltcorn mobile app for Android and iOS",
   "main": "index.js",
   "scripts": {
     "build": "webpack",
     "add-platform": "npx cap add",
-    "modify-gradle-cfg": "node build_scripts/modify_gradle_cfg.js",
-    "modify-android-manifest": "node build_scripts/modify_android_manifest.js",
     "test": "echo NO TESTS"
   },
   "author": "Christian Hugo",

package/src/helpers/auth.js

@@ -5,12 +5,14 @@ import i18next from "i18next";
 import { apiCall } from "./api";
 import { router } from "../routing/index";
 import { getLastOfflineSession, deleteOfflineData, sync } from "./offline_mode";
-import { addRoute, replaceIframe } from "../helpers/navigation";
-import { showAlerts } from "./common";
+import { addRoute, replaceIframe, clearHistory } from "../helpers/navigation";
 import {
-  initPushNotifications,
-  unregisterPushNotifications,
-} from "../helpers/notifications";
+  showToasts,
+  tryInitBackgroundSync,
+  tryInitPush,
+  tryStopBackgroundSync,
+  tryUnregisterPush,
+} from "./common";
 
 /**
  * internal helper for the normal login/signup and public login
@@ -45,80 +47,98 @@ async function loginRequest({ email, password, isSignup, isPublic }) {
 }
 
 /**
- * helper for normal logins and auth provider logins
- * @param {string} token
+ * internal helper to process a JWT token
+ * @param {string} tokenStr
  */
-export async function handleToken(token) {
-  const decodedJwt = jwtDecode(token);
-  const state = saltcorn.data.state.getState();
-  const config = state.mobileConfig;
-  config.user = decodedJwt.user;
+const handleToken = async (tokenStr, config) => {
+  const token = jwtDecode(tokenStr);
+  const user = token.user;
+  config.user = user;
   config.isPublicUser = false;
   config.isOfflineMode = false;
-  await insertUser(config.user);
-  await setJwt(token);
-  config.jwt = token;
-  i18next.changeLanguage(config.user.language);
+  await insertUser(user);
+  await setJwt(tokenStr);
+  config.jwt = tokenStr;
+  i18next.changeLanguage(user.language);
+};
+
+/**
+ * internal helper to run the first sync
+ */
+const initialSync = async (config) => {
   const alerts = [];
-  if (config.allowOfflineMode) {
-    const { offlineUser, hasOfflineData } =
-      (await getLastOfflineSession()) || {};
-    if (!offlineUser || offlineUser === config.user.email) {
-      await sync();
-    } else {
-      if (hasOfflineData)
-        alerts.push({
-          type: "warning",
-          msg: `'${offlineUser}' has not yet uploaded offline data.`,
-        });
-      else {
-        await deleteOfflineData(true);
-        await sync();
-      }
-    }
-  }
-  if (saltcorn.data.utils.isPushEnabled(config.user)) {
-    initPushNotifications();
+  const { offlineUser, hasOfflineData } = (await getLastOfflineSession()) || {};
+  if (!offlineUser || offlineUser === config.user.email) {
+    await sync(true, true, alerts);
   } else {
-    await unregisterPushNotifications();
+    if (hasOfflineData)
+      alerts.push({
+        type: "warning",
+        msg: `'${offlineUser}' has not yet uploaded offline data.`,
+      });
+    else {
+      await deleteOfflineData(true);
+      await sync(true, true, alerts);
+    }
   }
-  alerts.push({
-    type: "success",
-    msg: i18next.t("Welcome, %s!", {
-      postProcess: "sprintf",
-      sprintf: [config.user.email],
-    }),
-  });
+  return alerts;
+};
 
+/**
+ * internal helper to get the path to the first page
+ */
+const getEntryPoint = (config) => {
   let entryPoint = null;
   if (config.entryPointType === "byrole") {
+    const state = saltcorn.data.state.getState();
     const homepageByRole = state.getConfig("home_page_by_role", {})[
       config.user.role_id
     ];
     if (homepageByRole) entryPoint = `get/page/${homepageByRole}`;
     else throw new Error("No homepage defined for this role.");
   } else entryPoint = config.entry_point;
+  return entryPoint;
+};
 
-  addRoute({ route: entryPoint, query: undefined });
-  const page = await router.resolve({
-    pathname: entryPoint,
-    fullWrap: true,
-    alerts,
-  });
-  if (page.content) await replaceIframe(page.content, page.isFile);
-}
-
-export async function login({ email, password, isSignup }) {
-  const loginResult = await loginRequest({
-    email,
-    password,
-    isSignup,
-  });
+/**
+ * For normal login/signup email and password are used
+ * When called from auth provider login (see google-auth plugin), token is used
+ * @param {*} param0
+ */
+export async function login({ email, password, isSignup, token }) {
+  const loginResult = !token
+    ? await loginRequest({
+        email,
+        password,
+        isSignup,
+      })
+    : token;
   if (typeof loginResult === "string") {
-    // use it as a token
-    await handleToken(loginResult);
+    const alerts = [];
+    const config = saltcorn.data.state.getState().mobileConfig;
+    await handleToken(loginResult, config);
+    if (config.allowOfflineMode) alerts.push(await initialSync(config));
+    await tryInitPush(config);
+    await tryInitBackgroundSync(config);
+    alerts.push({
+      type: "success",
+      msg: i18next.t("Welcome, %s!", {
+        postProcess: "sprintf",
+        sprintf: [config.user.email],
+      }),
+    });
+
+    // open first page
+    const entryPoint = getEntryPoint(config);
+    addRoute({ route: entryPoint, query: undefined });
+    const page = await router.resolve({
+      pathname: entryPoint,
+      fullWrap: true,
+      alerts,
+    });
+    if (page.content) await replaceIframe(page.content, page.isFile);
   } else if (loginResult?.alerts) {
-    showAlerts(loginResult?.alerts);
+    showToasts(loginResult?.alerts);
   } else {
     throw new Error("The login failed.");
   }
@@ -160,13 +180,13 @@ export async function publicLogin(entryPoint) {
       });
       if (page.content) await replaceIframe(page.content, page.isFile);
     } else if (loginResult?.alerts) {
-      showAlerts(loginResult?.alerts);
+      showToasts(loginResult?.alerts);
     } else {
       throw new Error("The login failed.");
     }
   } catch (error) {
     console.error(error);
-    showAlerts([
+    showToasts([
       {
         type: "error",
         msg: error.message ? error.message : "An error occured.",
@@ -179,14 +199,23 @@ export async function publicLogin(entryPoint) {
 export async function logout() {
   try {
     const config = saltcorn.data.state.getState().mobileConfig;
-    const page = await router.resolve({
-      pathname: "get/auth/logout",
-      entryView: config.entry_point,
-      versionTag: config.version_tag,
-    });
-    await replaceIframe(page.content);
+    await tryUnregisterPush();
+    await tryStopBackgroundSync();
+    const response = await apiCall({ method: "GET", path: "/auth/logout" });
+    if (response.data.success) {
+      await removeJwt();
+      clearHistory();
+      config.jwt = undefined;
+      const page = await router.resolve({
+        pathname: "get/auth/login",
+        entryView: config.entry_point,
+        versionTag: config.version_tag,
+      });
+      await replaceIframe(page.content);
+    } else throw new Error("Unable to logout.");
   } catch (error) {
-    showAlerts([
+    console.error("unable to logout:", error);
+    showToasts([
       {
         type: "error",
         msg: error.message ? error.message : "An error occured.",