@saltcorn/mobile-app 1.5.0-beta.12 → 1.5.0-beta.14

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 { showAlerts } 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);
+    showAlerts([
+      {
+        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.12",
+  "version": "1.5.0-beta.14",
   "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";
+  showAlerts,
+  tryInitBackgroundSync,
+  tryInitPush,
+  tryStopBackgroundSync,
+  tryUnregisterPush,
+} from "./common";
 
 /**
  * internal helper for the normal login/signup and public login
@@ -45,78 +47,96 @@ 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) {
+  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();
-    } 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();
-  } else {
-    await unregisterPushNotifications();
-  }
-  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);
   } else {
@@ -179,13 +199,22 @@ 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) {
+    console.error("unable to logout:", error);
     showAlerts([
       {
         type: "error",

package/src/helpers/common.js

@@ -4,6 +4,7 @@ import { apiCall } from "./api";
 import { Camera, CameraResultType } from "@capacitor/camera";
 import { ScreenOrientation } from "@capacitor/screen-orientation";
 import { SendIntent } from "send-intent";
+import { addPushSyncHandler } from "./offline_mode";
 
 const orientationChangeListeners = new Set();
 
@@ -189,3 +190,78 @@ export async function checkSendIntentReceived() {
     return null;
   }
 }
+
+/**
+ * init the push system, if available
+ */
+export async function tryInitPush(config) {
+  try {
+    const { initPushNotifications, addPusNotifyHandler } = await import(
+      "../helpers/notifications.js"
+    );
+    try {
+      await initPushNotifications();
+      if (saltcorn.data.utils.isPushEnabled(config.user)) addPusNotifyHandler();
+      if (config.pushSync) addPushSyncHandler();
+    } catch (error) {
+      console.error("Error initializing push notifications:", error);
+    }
+  } catch (error) {
+    console.log("Push notifications module not available:", error);
+  }
+}
+
+/**
+ * init background sync, if available
+ */
+export async function tryInitBackgroundSync(config) {
+  try {
+    const { startPeriodicBackgroundSync } = await import(
+      "../helpers/background_sync.js"
+    );
+    try {
+      if (config.syncInterval && config.syncInterval > 0)
+        await startPeriodicBackgroundSync(config.syncInterval);
+    } catch (error) {
+      console.error("Error initializing background sync:", error);
+    }
+  } catch (error) {
+    console.log("Background sync module not available:", error);
+  }
+}
+
+/**
+ * end the push system, if available
+ */
+export async function tryUnregisterPush() {
+  try {
+    const { unregisterPushNotifications } = await import(
+      "../helpers/notifications.js"
+    );
+    try {
+      await unregisterPushNotifications();
+    } catch (error) {
+      console.error("Error unregistering push notifications:", error);
+    }
+  } catch (error) {
+    console.log("Push notifications module not available:", error);
+  }
+}
+
+/**
+ * stop background sync, if available
+ */
+export async function tryStopBackgroundSync() {
+  try {
+    const { stopPeriodicBackgroundSync } = await import(
+      "../helpers/background_sync.js"
+    );
+    try {
+      await stopPeriodicBackgroundSync();
+    } catch (error) {
+      console.error("Error stopping periodic background sync:", error);
+    }
+  } catch (error) {
+    console.error("Push notifications module not available:", error);
+  }
+}

package/src/helpers/offline_mode.js

@@ -445,57 +445,72 @@ const setSpinnerText = () => {
   }
 };
 
-export async function sync() {
-  setSpinnerText();
-  const state = saltcorn.data.state.getState();
-  const { user } = state.mobileConfig;
-  const { offlineUser, hasOfflineData, uploadStarted, uploadStartTime } =
-    (await getLastOfflineSession()) || {};
-  if (offlineUser && hasOfflineData && offlineUser !== user.email) {
-    throw new Error(
-      `The sync is not available, '${offlineUser}' has not yet uploaded offline data.`
-    );
-  } else {
-    let syncDir = null;
-    let cleanSync = await checkCleanSync(
-      uploadStarted,
-      uploadStartTime,
-      user.email
-    );
-    const syncTimestamp = await getSyncTimestamp();
-    await setUploadStarted(true, syncTimestamp);
-    let lock = null;
-    try {
-      if (window.navigator?.wakeLock?.request)
-        lock = await window.navigator.wakeLock.request();
-    } catch (error) {
-      console.log("wakeLock not available");
-      console.log(error);
-    }
-    let transactionOpen = false;
-    try {
-      await saltcorn.data.db.query("PRAGMA foreign_keys = OFF;");
-      await saltcorn.data.db.query("BEGIN");
-      transactionOpen = true;
-      if (cleanSync) await clearLocalData(true);
-      const { synchedTables, syncInfos } = await prepare();
-      await syncRemoteDeletes(syncInfos, syncTimestamp);
-      syncDir = await syncOfflineData(synchedTables, syncTimestamp);
-      await syncRemoteData(syncInfos, syncTimestamp);
-      await endOfflineMode(true);
-      await setUploadStarted(false);
-      await saltcorn.data.db.query("COMMIT");
-      transactionOpen = false;
-      await saltcorn.data.db.query("PRAGMA foreign_keys = ON;");
-    } catch (error) {
-      if (transactionOpen) await saltcorn.data.db.query("ROLLBACK");
-      await saltcorn.data.db.query("PRAGMA foreign_keys = ON;");
-      console.log(error);
-      throw error;
-    } finally {
-      if (syncDir) await cleanSyncDir(syncDir);
-      if (lock) await lock.release();
+let syncInProgress = false;
+
+export async function isSyncInProgress() {
+  return syncInProgress;
+}
+
+export async function sync(background = false) {
+  if (syncInProgress)
+    throw new Error("A synchronization is already in progress.");
+
+  try {
+    if (!background) setSpinnerText();
+    const state = saltcorn.data.state.getState();
+    const { user } = state.mobileConfig;
+    const { offlineUser, hasOfflineData, uploadStarted, uploadStartTime } =
+      (await getLastOfflineSession()) || {};
+    if (offlineUser && hasOfflineData && offlineUser !== user.email) {
+      throw new Error(
+        `The sync is not available, '${offlineUser}' has not yet uploaded offline data.`
+      );
+    } else {
+      let syncDir = null;
+      let cleanSync = await checkCleanSync(
+        uploadStarted,
+        uploadStartTime,
+        user.email
+      );
+      const syncTimestamp = await getSyncTimestamp();
+      await setUploadStarted(true, syncTimestamp);
+      let lock = null;
+      if (!background) {
+        try {
+          if (window.navigator?.wakeLock?.request)
+            lock = await window.navigator.wakeLock.request();
+        } catch (error) {
+          console.log("wakeLock not available");
+          console.log(error);
+        }
+      }
+      let transactionOpen = false;
+      try {
+        await saltcorn.data.db.query("PRAGMA foreign_keys = OFF;");
+        await saltcorn.data.db.query("BEGIN");
+        transactionOpen = true;
+        if (cleanSync) await clearLocalData(true);
+        const { synchedTables, syncInfos } = await prepare();
+        await syncRemoteDeletes(syncInfos, syncTimestamp);
+        syncDir = await syncOfflineData(synchedTables, syncTimestamp);
+        await syncRemoteData(syncInfos, syncTimestamp);
+        if (!background) await endOfflineMode(true);
+        await setUploadStarted(false);
+        await saltcorn.data.db.query("COMMIT");
+        transactionOpen = false;
+        await saltcorn.data.db.query("PRAGMA foreign_keys = ON;");
+      } catch (error) {
+        if (transactionOpen) await saltcorn.data.db.query("ROLLBACK");
+        await saltcorn.data.db.query("PRAGMA foreign_keys = ON;");
+        console.log(error);
+        throw error;
+      } finally {
+        if (syncDir) await cleanSyncDir(syncDir);
+        if (lock) await lock.release();
+      }
     }
+  } finally {
+    syncInProgress = false;
   }
 }
 
@@ -602,7 +617,7 @@ export async function hasOfflineRows() {
     const table = saltcorn.data.models.Table.findOne({ name: tblName });
     const pkName = table.pk_name;
     const { rows } = await saltcorn.data.db.query(
-      `select count(info_tbl.ref) 
+      `select count(info_tbl.ref) as total
            from "${saltcorn.data.db.sqlsanitize(
              tblName
            )}_sync_info" as info_tbl 
@@ -610,7 +625,7 @@ export async function hasOfflineRows() {
            on info_tbl.ref = data_tbl."${saltcorn.data.db.sqlsanitize(pkName)}"
            where info_tbl.modified_local = true`
     );
-    if (rows?.length > 0 && parseInt(rows[0].count) > 0) return true;
+    if (rows?.length > 0 && parseInt(rows[0].total) > 0) return true;
   }
   return false;
 }
@@ -643,3 +658,15 @@ export async function deleteOfflineData(noFeedback) {
     if (!noFeedback) removeLoadSpinner();
   }
 }
+
+export function addPushSyncHandler() {
+  const state = saltcorn.data.state.getState();
+  state.mobile_push_handler["push_sync"] = async (notification) => {
+    console.log("Push sync received:", notification);
+    try {
+      await sync(true);
+    } catch (error) {
+      console.log("Error during push sync:", error);
+    }
+  };
+}

package/src/index.js

@@ -2,13 +2,32 @@ import { init } from "./init";
 import * as api from "./helpers/api";
 import * as auth from "./helpers/auth";
 import * as common from "./helpers/common";
-import * as notifications from "./helpers/notifications";
 import * as fileSystem from "./helpers/file_system";
 import * as navigation from "./helpers/navigation";
 import * as offlineMode from "./helpers/offline_mode";
 import * as dbSchema from "./helpers/db_schema";
 import { router } from "./routing/index";
 
+// included when push notifications or push sync is enabled
+let notifications = undefined;
+try {
+  notifications = require("./helpers/notifications");
+  console.log("Notifications module available");  
+} catch (err) {
+  console.log("Notifications module not available");
+}
+
+// included when periodic background sync is enabled
+let backgroundSync = undefined;
+try {
+  backgroundSync = require("./helpers/background_sync");
+  console.log("Background sync module available");  
+}
+catch (err) {
+  console.log("Background sync module not available");
+}
+
+// include code placed in a mobile-app directory inside plugins
 const plugins = {};
 const context = require.context("./plugins-code", true, /index\.js$/);
 context.keys().forEach((key) => {
@@ -22,10 +41,11 @@ export const mobileApp = {
   api,
   auth,
   common,
-  notifications,
   fileSystem,
   navigation: { ...navigation, router },
   offlineMode,
   dbSchema,
+  ...(notifications ? { notifications } : {}),
+  ...(backgroundSync ? { backgroundSync } : {}),
   plugins,
 };

package/src/init.js

@@ -22,7 +22,11 @@ import {
   gotoEntryView,
   addRoute,
 } from "./helpers/navigation.js";
-import { checkSendIntentReceived } from "./helpers/common.js";
+import {
+  checkSendIntentReceived,
+  tryInitBackgroundSync,
+  tryInitPush,
+} from "./helpers/common.js";
 import { readJSONCordova, readTextCordova } from "./helpers/file_system.js";
 
 import i18next from "i18next";
@@ -443,6 +447,7 @@ export async function init(mobileConfig) {
     const jwt = state.mobileConfig.jwt;
     const alerts = [];
     if ((networkDisabled && jwt) || (await checkJWT(jwt))) {
+      // already logged in, continue
       const mobileConfig = state.mobileConfig;
       const decodedJwt = jwtDecode(mobileConfig.jwt);
       mobileConfig.user = decodedJwt.user;
@@ -486,6 +491,9 @@ export async function init(mobileConfig) {
         }
       }
 
+      await tryInitPush(mobileConfig);
+      await tryInitBackgroundSync(mobileConfig);
+
       if (Capacitor.getPlatform() === "ios") {
         const shareData = await checkSendIntentReceived();
         if (shareData && notEmpty(shareData)) return await postShare(shareData);
@@ -518,6 +526,7 @@ export async function init(mobileConfig) {
       }
       if (page.content) await replaceIframe(page.content, page.isFile);
     } else if (isPublicJwt(jwt)) {
+      // already logged in as public
       const config = state.mobileConfig;
       config.user = { role_id: 100, email: "public", language: "en" };
       config.isPublicUser = true;
@@ -539,13 +548,17 @@ export async function init(mobileConfig) {
       )) &&
       state.mobileConfig.autoPublicLogin
     ) {
+      // try autoPublicLogin
       if (networkDisabled)
         throw new Error(
           "No internet connection or previous login is available. " +
             "Please go online and reload, the public login is not yet supported."
         );
       await publicLogin(getEntryPoint(100, state, state.mobileConfig));
-    } else await showLogin(alerts);
+     } else {
+      // open login page
+      await showLogin(alerts);
+    }
   } catch (error) {
     if (typeof saltcorn === "undefined" || typeof router === "undefined") {
       const msg = `An error occured: ${

package/src/routing/index.js

@@ -6,7 +6,7 @@ import {
   updateTableRow,
   insertTableRow,
 } from "./routes/api";
-import { getLoginView, logoutAction, getSignupView } from "./routes/auth";
+import { getLoginView, getSignupView } from "./routes/auth";
 import { deleteRows } from "./routes/delete";
 import { postToggleField } from "./routes/edit";
 import { getErrorView } from "./routes/error";
@@ -54,16 +54,12 @@ const routes = [
     path: "get/auth/login",
     action: getLoginView,
   },
-  {
-    path: "get/auth/logout",
-    action: logoutAction,
-  },
   {
     path: "get/auth/signup",
     action: getSignupView,
   },
+
   // delete
-  
   {
     path: "post/delete/:tableName/:id", // legacy
     action: deleteRows,
@@ -72,7 +68,7 @@ const routes = [
     path: "delete/api/:tableName/:id",
     action: deleteRows,
   },
-  
+
   // edit
   {
     path: "post/edit/toggle/:name/:id/:field_name",

package/src/routing/routes/auth.js

@@ -1,11 +1,12 @@
 /*global saltcorn */
 import { MobileRequest } from "../mocks/request";
 import { MobileResponse } from "../mocks/response";
-import { apiCall } from "../../helpers/api";
-import { removeJwt } from "../../helpers/auth";
 import { sbAdmin2Layout, getHeaders } from "../utils";
-import { clearHistory } from "../../helpers/navigation";
 
+/**
+ * internal helper to prepare the login or signup form
+ * @returns
+ */
 const prepareAuthForm = () => {
   return new saltcorn.data.models.Form({
     class: "login",
@@ -29,7 +30,13 @@ const prepareAuthForm = () => {
   });
 };
 
-// TODO delete this and integrate getAuthLinks() from '/server/auth/routes.js'
+/**
+ * internal helper to get auth links
+ * TODO delete this and integrate getAuthLinks() from '/server/auth/routes.js'
+ * @param {*} current
+ * @param {*} entryPoint
+ * @returns
+ */
 const getAuthLinks = (current, entryPoint) => {
   const links = { methods: [] };
   const state = saltcorn.data.state.getState();
@@ -51,6 +58,13 @@ const getAuthLinks = (current, entryPoint) => {
   return links;
 };
 
+/**
+ * internal helper to render login view
+ * @param {*} entryPoint
+ * @param {*} versionTag
+ * @param {*} alerts
+ * @returns
+ */
 const renderLoginView = async (entryPoint, versionTag, alerts = []) => {
   const state = saltcorn.data.state.getState();
   const form = prepareAuthForm(entryPoint);
@@ -101,6 +115,12 @@ const renderLoginView = async (entryPoint, versionTag, alerts = []) => {
   });
 };
 
+/**
+ * internal helper to render signup view
+ * @param {*} entryPoint
+ * @param {*} versionTag
+ * @returns
+ */
 const renderSignupView = (entryPoint, versionTag) => {
   const form = prepareAuthForm(entryPoint);
   form.onSubmit = `javascript:signupFormSubmit(this, '${entryPoint}')`;
@@ -146,23 +166,3 @@ export const getSignupView = async () => {
     replaceIframe: true,
   };
 };
-
-/**
- *
- * @returns
- */
-export const logoutAction = async () => {
-  const config = saltcorn.data.state.getState().mobileConfig;
-  const response = await apiCall({ method: "GET", path: "/auth/logout" });
-  if (response.data.success) {
-    await removeJwt();
-    clearHistory();
-    config.jwt = undefined;
-    return {
-      content: await renderLoginView(config.entry_point, config.version_tag),
-    };
-  } else {
-    console.log("unable to logout");
-    return {};
-  }
-};

package/build_scripts/modify_android_manifest.js

@@ -1,53 +0,0 @@
-const { parseStringPromise, Builder } = require("xml2js");
-const { join } = require("path");
-const { readFileSync, writeFileSync } = require("fs");
-
-const readMobileConfig = () => {
-  console.log("Reading mobile config");
-  const content = readFileSync(
-    "/saltcorn-mobile-app/saltcorn-mobile-cfg.json",
-    "utf8"
-  );
-  console.log(content);
-  return JSON.parse(content);
-};
-
-(async () => {
-  try {
-    const { permissions, features } = readMobileConfig();
-    const androidManifest = join(
-      "android",
-      "app",
-      "src",
-      "main",
-      "AndroidManifest.xml"
-    );
-    const content = readFileSync(androidManifest);
-    const parsed = await parseStringPromise(content);
-
-    parsed.manifest["uses-permission"] = permissions.map((p) => ({
-      $: { "android:name": p },
-    }));
-    parsed.manifest["uses-feature"] = features.map((f) => ({
-      $: { "android:name": f },
-    }));
-
-    parsed.manifest.application[0].$ = {
-      ...parsed.manifest.application[0].$,
-      "android:allowBackup": "false",
-      "android:fullBackupContent": "false",
-      "android:dataExtractionRules": "@xml/data_extraction_rules",
-      "android:networkSecurityConfig": "@xml/network_security_config",
-      "android:usesCleartextTraffic": "true",
-    };
-    const xmlBuilder = new Builder();
-    const newCfg = xmlBuilder.buildObject(parsed);
-    writeFileSync(androidManifest, newCfg);
-  } catch (error) {
-    console.log(
-      `Unable to modify the AndroidManifest.xml: ${
-        error.message ? error.message : "Unknown error"
-      }`
-    );
-  }
-})();

package/build_scripts/modify_gradle_cfg.js

@@ -1,21 +0,0 @@
-const { join } = require("path");
-const { readFileSync, writeFileSync } = require("fs");
-
-console.log("Writing gradle config");
-console.log("args", process.argv);
-const args = process.argv.slice(2);
-const appVersion = args[0].split("=")[1];
-
-const gradleFile = join(__dirname, "..", "android", "app", "build.gradle");
-const gradleContent = readFileSync(gradleFile, "utf8");
-
-// generate versionCode from appVersion
-const parts = appVersion.split(".");
-const versionCode =
-  parseInt(parts[0]) * 1000000 + parseInt(parts[1]) * 1000 + parseInt(parts[2]);
-let newGradleContent = gradleContent
-  .replace(/versionName "1.0"/, `versionName "${appVersion}"`)
-  .replace(/versionCode 1/, `versionCode ${versionCode}`);
-
-console.log("newGradleContent", newGradleContent);
-writeFileSync(gradleFile, newGradleContent, "utf8");

package/src/helpers/notifications.js

@@ -1,92 +0,0 @@
-import { Capacitor } from "@capacitor/core";
-import { apiCall } from "./api";
-import { showAlerts } from "./common";
-
-/**
- * @capacitor/push-notifications isn't always included in the build
- */
-async function loadNotificationsPlugin() {
-  try {
-    const { PushNotifications } = await import("@capacitor/push-notifications");
-    return PushNotifications;
-  } catch (error) {
-    console.warn("Error loading PushNotifications plugin:", error);
-    return null;
-  }
-}
-
-/**
- * @capacitor/device isn't always included in the build
- */
-async function loadDevicePlugin() {
-  try {
-    const { Device } = await import("@capacitor/device");
-    return Device;
-  } catch (error) {
-    console.warn("Error loading Device plugin:", error);
-    return null;
-  }
-}
-
-async function uploadFcmToken(token, deviceId) {
-  try {
-    const response = await apiCall({
-      method: "POST",
-      path: "/notifications/fcm-token",
-      body: { token, deviceId },
-    });
-    const data = response.data;
-    if (data.success.success === "ok")
-      console.log("Token uploaded successfully:", data);
-    else console.error("Unable to upload token:", data);
-  } catch (error) {
-    console.error("Error uploading token:", error);
-  }
-}
-
-export async function initPushNotifications() {
-  const PushNotifications = await loadNotificationsPlugin();
-  if (Capacitor.getPlatform() !== "web" && PushNotifications) {
-    const { Device } = await loadDevicePlugin();
-    const permStatus = await PushNotifications.requestPermissions();
-    if (permStatus.receive === "granted") {
-      await PushNotifications.register();
-      PushNotifications.addListener("registration", async (token) => {
-        const { identifier } = await Device.getId();
-        await uploadFcmToken(token.value, identifier);
-      });
-
-      PushNotifications.addListener("registrationError", (err) => {
-        console.error("Push registration error:", err);
-      });
-
-      PushNotifications.addListener(
-        "pushNotificationReceived",
-        (notification) => {
-          console.log("Push received in foreground:", notification);
-          showAlerts([
-            {
-              type: "info",
-              msg: notification.body,
-              title: notification.title,
-            },
-          ]);
-        }
-      );
-    } else {
-      console.warn("Push notification permission not granted");
-    }
-  }
-}
-
-export async function unregisterPushNotifications() {
-  const PushNotifications = await loadNotificationsPlugin();
-  if (Capacitor.getPlatform() !== "web" && PushNotifications) {
-    try {
-      await PushNotifications.unregister();
-      console.log("Push notifications unregistered successfully");
-    } catch (error) {
-      console.error("Error unregistering push notifications:", error);
-    }
-  }
-}