From c23518dae0136e65ff61359db7f9122478a0cac7 Mon Sep 17 00:00:00 2001 From: Maurice Date: Sat, 14 Nov 2026 11:34:28 +0100 Subject: [PATCH] fix(native): start without the server on Android and keep the offline start on iOS A tester with a server on his home network could not open the Android app away from it: after closing the app and turning Wi-Fi off it stayed on the address screen ("No server answered at this address"). - Android keeps the server's UI itself (TrekOfflineShell): the start page and every file of the build, listed by native/offlineShell.ts from the server's manifest and downloaded natively. A web view runs no service worker on a plain-http server, the usual address of a server at home, so the old "Android has the service worker" assumption did not hold. - Without a network, or once the server failed to load twice, the web view serves the copy under the server's origin with Capacitor's bridge; the UI runs on its own offline data and the API answers again once the server is back. The address screen opens the copy too (openOfflineCopy). - The check an update asks for no longer locks the app out offline: on both platforms a server out of reach is put back on its copy and checked on the next launch that reaches it. iOS no longer throws its copy away when the update check runs. --- client/android/app/proguard-rules.pro | 7 + .../java/com/liketrek/trek/MainActivity.java | 13 +- .../com/liketrek/trek/TrekOfflineShell.java | 265 ++++++++++++++++++ .../com/liketrek/trek/TrekServerStore.java | 32 +++ .../com/liketrek/trek/TrekShellPlugin.java | 86 +++++- .../com/liketrek/trek/TrekWebViewClient.java | 19 +- .../App/App/TrekBridgeViewController.swift | 18 +- client/ios/App/App/TrekShellPlugin.swift | 12 + client/native-shell/main.ts | 12 + client/src/native/nativeApp.test.ts | 20 +- client/src/native/nativeApp.ts | 23 +- client/src/native/offlineShell.test.ts | 26 ++ client/src/native/offlineShell.ts | 31 +- client/src/native/trekShell.ts | 11 +- 14 files changed, 537 insertions(+), 38 deletions(-) create mode 100644 client/android/app/src/main/java/com/liketrek/trek/TrekOfflineShell.java diff --git a/client/android/app/proguard-rules.pro b/client/android/app/proguard-rules.pro index 79e4063a5..4d682b551 100644 --- a/client/android/app/proguard-rules.pro +++ b/client/android/app/proguard-rules.pro @@ -36,3 +36,10 @@ @android.webkit.JavascriptInterface ; } -keep public class * extends com.getcapacitor.Plugin + +# The stored copy of the server's UI gets Capacitor's bridge the way the +# server's own page does (TrekOfflineShell.withBridge reads it by reflection). +-keepclassmembers class com.getcapacitor.Bridge { + private com.getcapacitor.JSInjector getJSInjector(); +} +-keep class com.getcapacitor.JSInjector { public *; } diff --git a/client/android/app/src/main/java/com/liketrek/trek/MainActivity.java b/client/android/app/src/main/java/com/liketrek/trek/MainActivity.java index ba98aaf9c..ff9238f4c 100644 --- a/client/android/app/src/main/java/com/liketrek/trek/MainActivity.java +++ b/client/android/app/src/main/java/com/liketrek/trek/MainActivity.java @@ -34,7 +34,18 @@ public class MainActivity extends BridgeActivity { // runs and on its own origin. BridgeActivity reads `config` while it // builds the bridge inside super.onCreate(). boolean restarting = TrekServerStore.consumeRestart(this); - TrekServerStore.recheckAfterUpdate(this); + // Without a network the server cannot answer: with a copy of its UI the + // app starts on that at once (TrekOfflineShell), as it does when the + // address screen found the server out of reach. The check an update asks + // for waits for a launch that can reach the server. + boolean offlineStart = TrekServerStore.consumeOfflineStart(this) + || (!TrekOfflineShell.hasNetwork(this) && TrekOfflineShell.hasCopy(this, TrekServerStore.getUrlOrPrevious(this))); + if (offlineStart && TrekOfflineShell.hasCopy(this, TrekServerStore.getUrlOrPrevious(this))) { + TrekServerStore.restoreForOffline(this); + TrekOfflineShell.activate(); + } else { + TrekServerStore.recheckAfterUpdate(this); + } String server = TrekServerStore.getUrl(this); boolean onServer = server != null && !TrekServerStore.consumeShellOnce(this); config = TrekServerStore.configFor(this, onServer ? server : null, restarting); diff --git a/client/android/app/src/main/java/com/liketrek/trek/TrekOfflineShell.java b/client/android/app/src/main/java/com/liketrek/trek/TrekOfflineShell.java new file mode 100644 index 000000000..722528b40 --- /dev/null +++ b/client/android/app/src/main/java/com/liketrek/trek/TrekOfflineShell.java @@ -0,0 +1,265 @@ +package com.liketrek.trek; + +import android.content.Context; +import android.net.ConnectivityManager; +import android.net.Network; +import android.net.NetworkCapabilities; +import android.net.Uri; +import android.util.Log; +import android.webkit.WebResourceRequest; +import android.webkit.WebResourceResponse; +import com.getcapacitor.Bridge; +import com.getcapacitor.JSInjector; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.lang.reflect.Method; +import java.nio.charset.StandardCharsets; +import java.util.HashMap; +import java.util.Locale; +import java.util.Map; +import java.util.Set; +import java.util.regex.Pattern; + +/** + * The server's UI kept on the device, so the app starts without its server: on + * a trip without reception, or away from home with a server on the home + * network. The web view runs no service worker on a plain-http server, the + * usual address of a server at home, so the app keeps the start page and every + * file of the build itself (refreshed by native/offlineShell.ts while the + * server is reachable) and serves them under the server's own origin while it + * is not. The data comes from the UI's own offline store; the API is tried as + * usual and answers again once the server is back. + */ +final class TrekOfflineShell { + + private static final String DIR = "offline-shell"; + private static final String PAGE = "index.html"; + private static final String STAMP = "server.txt"; + private static final String FILES = "files"; + /** A path of the build: no "..", no query, nothing outside the copy's folder. */ + private static final Pattern SAFE_PATH = Pattern.compile("^[A-Za-z0-9._@\\-]+(?:/[A-Za-z0-9._@\\-]+)*$"); + private static final Map TYPES = new HashMap<>(); + + static { + TYPES.put("js", "text/javascript"); + TYPES.put("mjs", "text/javascript"); + TYPES.put("css", "text/css"); + TYPES.put("json", "application/json"); + TYPES.put("webmanifest", "application/manifest+json"); + TYPES.put("svg", "image/svg+xml"); + TYPES.put("png", "image/png"); + TYPES.put("jpg", "image/jpeg"); + TYPES.put("jpeg", "image/jpeg"); + TYPES.put("webp", "image/webp"); + TYPES.put("ico", "image/x-icon"); + TYPES.put("woff", "font/woff"); + TYPES.put("woff2", "font/woff2"); + TYPES.put("ttf", "font/ttf"); + TYPES.put("wasm", "application/wasm"); + TYPES.put("html", "text/html"); + } + + /** The UI comes from the copy in this run: the server did not answer when the app started. */ + private static volatile boolean active; + private static volatile JSInjector injector; + private static volatile boolean injectorLooked; + + private TrekOfflineShell() {} + + static boolean isActive() { + return active; + } + + static void activate() { + active = true; + } + + private static File root(Context context) { + return new File(context.getFilesDir(), DIR); + } + + /** Whether there is a copy of this server's UI to start from. */ + static boolean hasCopy(Context context, String server) { + if (server == null) return false; + File page = new File(root(context), PAGE); + return page.isFile() && server.equals(readStamp(context)); + } + + /** Whether the device has a network at all; with none, the server cannot answer and the copy starts at once. */ + static boolean hasNetwork(Context context) { + try { + ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE); + if (cm == null) return true; + Network network = cm.getActiveNetwork(); + if (network == null) return false; + NetworkCapabilities caps = cm.getNetworkCapabilities(network); + return caps != null && caps.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); + } catch (RuntimeException e) { + return true; + } + } + + /** Keeps the start page; a copy of another server is thrown away first. */ + static boolean savePage(Context context, String server, byte[] html) { + if (!server.equals(readStamp(context))) clear(context); + File dir = root(context); + if (!dir.isDirectory() && !dir.mkdirs()) return false; + return write(new File(dir, STAMP), server.getBytes(StandardCharsets.UTF_8)) && write(new File(dir, PAGE), html); + } + + static boolean hasFile(Context context, String path) { + File file = fileFor(context, path); + return file != null && file.isFile(); + } + + static boolean saveFile(Context context, String path, byte[] data) { + File file = fileFor(context, path); + if (file == null) return false; + File parent = file.getParentFile(); + if (parent != null && !parent.isDirectory() && !parent.mkdirs()) return false; + return write(file, data); + } + + /** Drops the files of older builds once the current one is complete. */ + static void prune(Context context, Set keep) { + File base = new File(root(context), FILES); + pruneDir(base, base, keep); + } + + static void clear(Context context) { + active = false; + deleteTree(root(context)); + } + + /** + * The copy's answer for a request of the server's UI while it is active: + * the start page for any page of the app (it routes itself), with + * Capacitor's bridge injected as into the server's own page, and a file of + * the build by its path. Null for anything else, which goes on as usual. + */ + static WebResourceResponse serve(Context context, Bridge bridge, String server, WebResourceRequest request) { + if (!active || server == null || !"GET".equalsIgnoreCase(request.getMethod())) return null; + Uri url = request.getUrl(); + Uri origin = Uri.parse(server); + if (!sameOrigin(url, origin)) return null; + try { + if (request.isForMainFrame()) { + File page = new File(root(context), PAGE); + if (!page.isFile()) return null; + InputStream html = withBridge(bridge, new FileInputStream(page)); + return response("text/html", html); + } + String path = url.getPath(); + if (path == null) return null; + File file = fileFor(context, path); + if (file == null || !file.isFile()) return null; + return response(typeOf(path), new FileInputStream(file)); + } catch (IOException e) { + Log.w("TrekShell", "Offline copy could not answer " + url, e); + return null; + } + } + + private static WebResourceResponse response(String type, InputStream body) { + Map headers = new HashMap<>(); + headers.put("Cache-Control", "no-store"); + String charset = type.startsWith("text/") || type.endsWith("json") ? "utf-8" : null; + return new WebResourceResponse(type, charset, 200, "OK", headers, body); + } + + /** + * Capacitor injects its bridge into the server's page as it passes through; + * the copy gets the same script. Its builder is internal to Capacitor, hence + * the reflection (kept in proguard-rules.pro). Without it the UI still runs, + * as it would in a browser, just without the app's native parts. + */ + private static InputStream withBridge(Bridge bridge, InputStream html) { + if (!injectorLooked) { + injectorLooked = true; + try { + Method method = Bridge.class.getDeclaredMethod("getJSInjector"); + method.setAccessible(true); + Object built = method.invoke(bridge); + if (built instanceof JSInjector) injector = (JSInjector) built; + } catch (ReflectiveOperationException | RuntimeException e) { + Log.w("TrekShell", "No bridge for the offline copy", e); + } + } + JSInjector current = injector; + return current == null ? html : current.getInjectedStream(html); + } + + private static boolean sameOrigin(Uri a, Uri b) { + if (a.getScheme() == null || b.getScheme() == null || a.getHost() == null || b.getHost() == null) return false; + return a.getScheme().equalsIgnoreCase(b.getScheme()) + && a.getHost().equalsIgnoreCase(b.getHost()) + && port(a) == port(b); + } + + private static int port(Uri uri) { + if (uri.getPort() != -1) return uri.getPort(); + return "https".equalsIgnoreCase(uri.getScheme()) ? 443 : 80; + } + + private static File fileFor(Context context, String path) { + String clean = path.startsWith("/") ? path.substring(1) : path; + if (clean.isEmpty() || clean.contains("..") || !SAFE_PATH.matcher(clean).matches()) return null; + return new File(new File(root(context), FILES), clean); + } + + private static String typeOf(String path) { + int dot = path.lastIndexOf('.'); + String ext = dot < 0 ? "" : path.substring(dot + 1).toLowerCase(Locale.ROOT); + String type = TYPES.get(ext); + return type == null ? "application/octet-stream" : type; + } + + private static String readStamp(Context context) { + File stamp = new File(root(context), STAMP); + if (!stamp.isFile()) return null; + try (FileInputStream in = new FileInputStream(stamp)) { + byte[] data = new byte[(int) Math.min(stamp.length(), 4096)]; + int read = in.read(data); + return read <= 0 ? null : new String(data, 0, read, StandardCharsets.UTF_8); + } catch (IOException e) { + return null; + } + } + + /** Written beside the target and moved over it, so a cut-off write never leaves half a file. */ + private static boolean write(File target, byte[] data) { + File temp = new File(target.getPath() + ".part"); + try (FileOutputStream out = new FileOutputStream(temp)) { + out.write(data); + out.getFD().sync(); + } catch (IOException e) { + temp.delete(); + return false; + } + return temp.renameTo(target); + } + + private static void pruneDir(File base, File dir, Set keep) { + File[] children = dir.listFiles(); + if (children == null) return; + for (File child : children) { + if (child.isDirectory()) { + pruneDir(base, child, keep); + String[] left = child.list(); + if (left != null && left.length == 0) child.delete(); + } else { + String relative = base.toURI().relativize(child.toURI()).getPath(); + if (!keep.contains(relative)) child.delete(); + } + } + } + + private static void deleteTree(File file) { + File[] children = file.listFiles(); + if (children != null) for (File child : children) deleteTree(child); + file.delete(); + } +} diff --git a/client/android/app/src/main/java/com/liketrek/trek/TrekServerStore.java b/client/android/app/src/main/java/com/liketrek/trek/TrekServerStore.java index a61fcfaf0..84ce945c0 100644 --- a/client/android/app/src/main/java/com/liketrek/trek/TrekServerStore.java +++ b/client/android/app/src/main/java/com/liketrek/trek/TrekServerStore.java @@ -38,6 +38,7 @@ final class TrekServerStore { private static final String KEY_SIGN_IN_HOSTS = "sign_in_hosts"; private static final String KEY_SHELL_ONCE = "shell_once"; private static final String KEY_RESTART = "restart"; + private static final String KEY_OFFLINE_START = "offline_start"; private static final String KEY_WELCOME = "welcome"; private static final String CONFIG_DIR = "trek-server-config"; @@ -191,6 +192,37 @@ final class TrekServerStore { return consume(context, KEY_RESTART); } + /** The next onCreate starts on the stored copy of the server's UI (TrekOfflineShell). */ + static void markOfflineStart(Context context) { + prefs(context).edit().putBoolean(KEY_OFFLINE_START, true).commit(); + } + + static boolean consumeOfflineStart(Context context) { + return consume(context, KEY_OFFLINE_START); + } + + /** + * The remembered server, or the one an update asked to check again: the + * server the stored copy of the UI belongs to. + */ + static String getUrlOrPrevious(Context context) { + String url = getUrl(context); + return url != null ? url : getPreviousUrl(context); + } + + /** + * Starting on the stored copy while the check an update asked for could not + * run: the server goes back in place, unchecked for now, and the check runs + * again on the next launch, which reaches the server. + */ + static void restoreForOffline(Context context) { + SharedPreferences prefs = prefs(context); + if (prefs.getString(KEY_URL, null) != null) return; + String previous = prefs.getString(KEY_PREVIOUS_URL, null); + if (previous == null) return; + prefs.edit().putString(KEY_URL, previous).remove(KEY_PREVIOUS_URL).putInt(KEY_SERVER_CHECK, 0).commit(); + } + private static boolean consume(Context context, String key) { boolean set = prefs(context).getBoolean(key, false); if (set) prefs(context).edit().remove(key).commit(); diff --git a/client/android/app/src/main/java/com/liketrek/trek/TrekShellPlugin.java b/client/android/app/src/main/java/com/liketrek/trek/TrekShellPlugin.java index b4eac2759..da4df1069 100644 --- a/client/android/app/src/main/java/com/liketrek/trek/TrekShellPlugin.java +++ b/client/android/app/src/main/java/com/liketrek/trek/TrekShellPlugin.java @@ -526,19 +526,95 @@ public class TrekShellPlugin extends Plugin { authBrowserOpen = false; } - /** iOS only: Android keeps the service worker, which already starts TREK offline. */ + /** + * Keeps the server's UI on the device for a start without the server + * (TrekOfflineShell): the start page, and each file of the build that + * native/offlineShell.ts lists from the server's manifest and the copy does + * not hold yet. Once all of them are there, files of older builds go. A web + * view runs no service worker on a plain-http server, the usual address of a + * server at home, so without this the app could not start away from it. + */ @PluginMethod public void refreshOfflineCopy(PluginCall call) { - JSObject result = new JSObject(); - result.put("saved", false); - call.resolve(result); + Context context = getContext(); + String server = TrekServerStore.getUrl(context); + JSArray listed = call.getArray("files"); + if (server == null || TrekOfflineShell.isActive()) { + JSObject result = new JSObject(); + result.put("saved", false); + call.resolve(result); + return; + } + new Thread(() -> { + JSObject result = new JSObject(); + byte[] page = download(server, "", "text/html"); + boolean saved = page != null && TrekOfflineShell.savePage(context, server, page); + boolean complete = saved; + if (saved && listed != null) { + Set keep = new HashSet<>(); + for (int i = 0; i < listed.length(); i++) { + String path = listed.optString(i, null); + if (path == null || path.isEmpty()) continue; + String clean = path.startsWith("/") ? path.substring(1) : path; + keep.add(clean); + if (TrekOfflineShell.hasFile(context, clean)) continue; + byte[] data = download(server, clean, null); + if (data == null || !TrekOfflineShell.saveFile(context, clean, data)) complete = false; + } + if (complete) TrekOfflineShell.prune(context, keep); + } + result.put("saved", saved); + result.put("complete", complete); + call.resolve(result); + }).start(); } + /** A file of the server's UI, or null: only a 200 counts, and the page only as HTML. */ + private static byte[] download(String server, String path, String wantType) { + java.net.HttpURLConnection connection = null; + try { + java.net.URL base = new java.net.URL(server.endsWith("/") ? server : server + "/"); + java.net.URL url = new java.net.URL(base, path); + connection = (java.net.HttpURLConnection) url.openConnection(); + connection.setConnectTimeout(15000); + connection.setReadTimeout(30000); + connection.setInstanceFollowRedirects(true); + if (wantType != null) connection.setRequestProperty("Accept", wantType); + if (connection.getResponseCode() != 200) return null; + String type = connection.getContentType(); + if (wantType != null && (type == null || !type.startsWith(wantType))) return null; + try (java.io.InputStream in = connection.getInputStream()) { + java.io.ByteArrayOutputStream out = new java.io.ByteArrayOutputStream(); + byte[] buffer = new byte[16384]; + for (int n = in.read(buffer); n > 0; n = in.read(buffer)) out.write(buffer, 0, n); + return out.toByteArray(); + } + } catch (java.io.IOException | RuntimeException e) { + return null; + } finally { + if (connection != null) connection.disconnect(); + } + } + + /** + * The address screen found the server out of reach: with a copy of its UI + * the app restarts on that instead (TrekOfflineShell), the same way it + * leaves the server for the address screen. Also for the server an update + * asked to check again, whose check then waits for the next launch. + */ @PluginMethod public void openOfflineCopy(PluginCall call) { + Context context = getContext(); JSObject result = new JSObject(); - result.put("opened", false); + if (!TrekOfflineShell.hasCopy(context, TrekServerStore.getUrlOrPrevious(context)) || getActivity() == null) { + result.put("opened", false); + call.resolve(result); + return; + } + TrekServerStore.markOfflineStart(context); + result.put("opened", true); call.resolve(result); + restart(); } // ---- Widgets, shortcuts and the travel day ---- diff --git a/client/android/app/src/main/java/com/liketrek/trek/TrekWebViewClient.java b/client/android/app/src/main/java/com/liketrek/trek/TrekWebViewClient.java index a015ec889..472b0e6a2 100644 --- a/client/android/app/src/main/java/com/liketrek/trek/TrekWebViewClient.java +++ b/client/android/app/src/main/java/com/liketrek/trek/TrekWebViewClient.java @@ -40,6 +40,7 @@ class TrekWebViewClient extends BridgeWebViewClient { private boolean retriedMainFrame; /** The page loaded again after a network error, until that load starts: its error page counts for nothing. */ private String retryUrl; + private final Bridge bridge; TrekWebViewClient( Bridge bridge, @@ -49,6 +50,7 @@ class TrekWebViewClient extends BridgeWebViewClient { Set signInHosts ) { super(bridge); + this.bridge = bridge; this.onUnreachable = onUnreachable; this.onSignInPage = onSignInPage; this.onErrorPage = onErrorPage; @@ -115,9 +117,15 @@ class TrekWebViewClient extends BridgeWebViewClient { return signInHosts.contains(key) || (url.getPort() != -1 && signInHosts.contains(key + ":" + url.getPort())); } - /** Mapbox's map resources go through the app's own store (tiles/TrekTileStore.kt). */ + /** + * Mapbox's map resources go through the app's own store (tiles/TrekTileStore.kt), + * and while the server is out of reach the UI comes from its stored copy + * (TrekOfflineShell). + */ @Override public WebResourceResponse shouldInterceptRequest(WebView view, WebResourceRequest request) { + WebResourceResponse copy = TrekOfflineShell.serve(view.getContext(), bridge, TrekServerStore.getUrl(view.getContext()), request); + if (copy != null) return copy; if (com.liketrek.trek.tiles.TrekTileStore.INSTANCE.handles(request)) { WebResourceResponse stored = com.liketrek.trek.tiles.TrekTileStore.INSTANCE.serve(request); if (stored != null) return stored; @@ -171,6 +179,15 @@ class TrekWebViewClient extends BridgeWebViewClient { }, 1500); return; } + // Out of reach for good (a trip without reception, a server at home): + // the stored copy of the UI takes over, with the app's own offline data. + String server = TrekServerStore.getUrl(view.getContext()); + if (isNetworkError(error.getErrorCode()) && !TrekOfflineShell.isActive() && TrekOfflineShell.hasCopy(view.getContext(), server)) { + TrekOfflineShell.activate(); + String url = request.getUrl().toString(); + view.post(() -> view.loadUrl(url)); + return; + } TrekServerStore.setFailure(view.getContext(), error.getDescription() + " (" + error.getErrorCode() + ")"); onUnreachable.run(); return; diff --git a/client/ios/App/App/TrekBridgeViewController.swift b/client/ios/App/App/TrekBridgeViewController.swift index 6131b70d1..7d61fcd21 100644 --- a/client/ios/App/App/TrekBridgeViewController.swift +++ b/client/ios/App/App/TrekBridgeViewController.swift @@ -455,10 +455,26 @@ enum TrekServerStore { guard defaults.integer(forKey: checkedKey) < serverCheck else { return } defaults.set(serverCheck, forKey: checkedKey) guard let server = url else { return } - url = nil + // Not through `url`, which throws the offline copy away: it still belongs + // to this server, and is what the app starts on if the check cannot run. + defaults.removeObject(forKey: key) + defaults.removeObject(forKey: signInHostsKey) defaults.set(server, forKey: previousKey) } + /// The check an update asked for cannot run (the server is out of reach), + /// but there is a copy of its UI: the server goes back in place, unchecked + /// for now, and the check runs again on the next launch. + static func restoreForOffline() -> Bool { + let defaults = UserDefaults.standard + guard url == nil, let previous = previousURL, + FileManager.default.fileExists(atPath: offlineCopyURL.path) else { return false } + defaults.set(previous, forKey: key) + defaults.removeObject(forKey: previousKey) + defaults.set(0, forKey: checkedKey) + return true + } + /// The server an update asked to check again, until a server is set. static var previousURL: String? { UserDefaults.standard.string(forKey: previousKey) diff --git a/client/ios/App/App/TrekShellPlugin.swift b/client/ios/App/App/TrekShellPlugin.swift index af823bd37..ee63e01ff 100644 --- a/client/ios/App/App/TrekShellPlugin.swift +++ b/client/ios/App/App/TrekShellPlugin.swift @@ -477,6 +477,18 @@ public class TrekShellPlugin: CAPPlugin, CAPBridgedPlugin, ASWebAuthenticationPr } @objc func openOfflineCopy(_ call: CAPPluginCall) { + // The server an update asked to check again, out of reach: back to it on + // its copy. The new bridge loads the server, fails, and this screen comes + // back with the server set, which then opens the copy below. + if TrekServerStore.url == nil { + if TrekServerStore.restoreForOffline() { + call.resolve(["opened": true]) + restartBridge() + } else { + call.resolve(["opened": false]) + } + return + } // With the trailing slash, like the bridge's serverURL: Capacitor only // keeps a navigation in the app when it starts with that exact string, // and hands anything else to Safari. diff --git a/client/native-shell/main.ts b/client/native-shell/main.ts index cc8032388..4f1324d78 100644 --- a/client/native-shell/main.ts +++ b/client/native-shell/main.ts @@ -1805,6 +1805,18 @@ async function start(): Promise { return; } if (!url && previousUrl) { + // An update asks to check the server once more. Out of reach (a trip, a + // server at home), that check cannot run: with a stored copy of the UI the + // app starts on that and checks on a later launch. Only for a server that + // did not answer, never for one that answered with a reason to stop. + const probe = await probeServer(previousUrl, get).catch(() => null); + if (!probe || (!probe.ok && probe.reason === 'unreachable')) { + const opened = await TrekShell.openOfflineCopy().then( + (r) => r.opened, + () => false + ); + if (opened) return; + } showConnect(previousUrl, { recheck: true }); } else if (!url) { showWelcome(); diff --git a/client/src/native/nativeApp.test.ts b/client/src/native/nativeApp.test.ts index 4541730b6..870c5fc0b 100644 --- a/client/src/native/nativeApp.test.ts +++ b/client/src/native/nativeApp.test.ts @@ -10,7 +10,7 @@ import { installNativeGeolocation } from './geolocation'; import { prepareKeyboardFields } from './keyboardFields'; import { scrollToTop, startNativeApp } from './nativeApp'; import { keepOfflineShellFresh } from './offlineShell'; -import { isNativeApp, isNativeIos } from './platform'; +import { isNativeAndroid, isNativeApp, isNativeIos } from './platform'; import { openPushTarget } from './push'; import { trackTouchInput } from './touchInput'; @@ -22,7 +22,7 @@ vi.mock('@capacitor/keyboard', () => ({ })); vi.mock('@capacitor/splash-screen', () => ({ SplashScreen: { hide: vi.fn() } })); vi.mock('@capacitor/status-bar', () => ({ StatusBar: { setStyle: vi.fn() }, Style: { Dark: 'DARK', Light: 'LIGHT' } })); -vi.mock('./platform', () => ({ isNativeApp: vi.fn(), isNativeIos: vi.fn() })); +vi.mock('./platform', () => ({ isNativeApp: vi.fn(), isNativeIos: vi.fn(), isNativeAndroid: vi.fn() })); vi.mock('./offlineShell', () => ({ keepOfflineShellFresh: vi.fn() })); vi.mock('../sync/networkMode', () => ({ isEffectivelyOffline: vi.fn() })); vi.mock('./capabilities', () => ({ @@ -50,6 +50,7 @@ beforeEach(() => { vi.clearAllMocks(); vi.mocked(isNativeApp).mockReturnValue(true); vi.mocked(isNativeIos).mockReturnValue(false); + vi.mocked(isNativeAndroid).mockReturnValue(false); vi.mocked(isEffectivelyOffline).mockReturnValue(false); vi.mocked(keepOfflineShellFresh).mockResolvedValue(); vi.mocked(hasNativeFeature).mockReturnValue(false); @@ -153,18 +154,19 @@ describe('startNativeApp', () => { startNativeApp(); expect(keepOfflineShellFresh).not.toHaveBeenCalled(); vi.advanceTimersByTime(15_000); - expect(keepOfflineShellFresh).toHaveBeenCalled(); + expect(vi.mocked(keepOfflineShellFresh).mock.calls[0]?.[2]).toBe(false); }); - it('skips the refresh while offline, and never on Android', () => { - vi.mocked(isNativeIos).mockReturnValue(true); - vi.mocked(isEffectivelyOffline).mockReturnValue(true); + it('refreshes it on Android too, into the store of the app', () => { + vi.mocked(isNativeAndroid).mockReturnValue(true); startNativeApp(); vi.advanceTimersByTime(15_000); - expect(keepOfflineShellFresh).not.toHaveBeenCalled(); + expect(vi.mocked(keepOfflineShellFresh).mock.calls[0]?.[2]).toBe(true); + }); - vi.mocked(isNativeIos).mockReturnValue(false); - vi.mocked(isEffectivelyOffline).mockReturnValue(false); + it('skips the refresh while offline', () => { + vi.mocked(isNativeIos).mockReturnValue(true); + vi.mocked(isEffectivelyOffline).mockReturnValue(true); startNativeApp(); vi.advanceTimersByTime(15_000); expect(keepOfflineShellFresh).not.toHaveBeenCalled(); diff --git a/client/src/native/nativeApp.ts b/client/src/native/nativeApp.ts index a1d96762a..27a831bb6 100644 --- a/client/src/native/nativeApp.ts +++ b/client/src/native/nativeApp.ts @@ -11,7 +11,7 @@ import { fadeInImages } from './imageFade'; import { keepFieldInView } from './keepFieldInView'; import { prepareKeyboardFields } from './keyboardFields'; import { keepOfflineShellFresh } from './offlineShell'; -import { isNativeApp, isNativeIos } from './platform'; +import { isNativeAndroid, isNativeApp, isNativeIos } from './platform'; import { openPushTarget, startNativePush } from './push'; import { startQuickActions } from './quickActions'; import { reportNativeFailure } from './reportFailure'; @@ -88,15 +88,20 @@ export function startNativeApp(): void { // The "‹ › Done" strip above the keyboard is a web form's, not an app's. void Keyboard.setAccessoryBarVisible({ isVisible: false }); keepFieldInView(Keyboard); - window.setTimeout(() => { - if (isEffectivelyOffline()) return; - // Not refreshed this time is no harm: the next launch tries again. An app - // older than the offline copy has no such method, which is no failure. - keepOfflineShellFresh(fetch, useSettingsStore.getState().settings.language).catch((err: unknown) => { - if (!isUnimplemented(err)) reportNativeFailure(err); - }); - }, OFFLINE_SHELL_DELAY_MS); } + + // The copy of the UI the app starts from without its server (offlineShell.ts): + // iOS in WebKit's cache, Android in the app's own store. + window.setTimeout(() => { + if (isEffectivelyOffline()) return; + // Not refreshed this time is no harm: the next launch tries again. An app + // older than the offline copy has no such method, which is no failure. + keepOfflineShellFresh(fetch, useSettingsStore.getState().settings.language, isNativeAndroid()).catch( + (err: unknown) => { + if (!isUnimplemented(err)) reportNativeFailure(err); + } + ); + }, OFFLINE_SHELL_DELAY_MS); } /** diff --git a/client/src/native/offlineShell.test.ts b/client/src/native/offlineShell.test.ts index 735c58183..8d6f85aa1 100644 --- a/client/src/native/offlineShell.test.ts +++ b/client/src/native/offlineShell.test.ts @@ -99,4 +99,30 @@ describe('keepOfflineShellFresh', () => { await keepOfflineShellFresh(fetchImpl, 'fr'); expect(fetched).toContain('/assets/fr-bbbb2222.js'); }); + + it('on Android hands the list to the native store instead of fetching it here', async () => { + vi.mocked(TrekShell.refreshOfflineCopy).mockResolvedValue({ saved: true, complete: true }); + const fetchImpl = vi.fn(async (input: RequestInfo | URL) => { + if (String(input) === '/asset-manifest.json') return new Response(JSON.stringify(manifest)); + throw new Error('the native side fetches the files'); + }) as unknown as typeof fetch; + + await keepOfflineShellFresh(fetchImpl, 'en', true); + + expect(fetchImpl).toHaveBeenCalledTimes(1); + expect(TrekShell.refreshOfflineCopy).toHaveBeenCalledTimes(1); + const { files } = vi.mocked(TrekShell.refreshOfflineCopy).mock.calls[0][0] as { files: string[] }; + expect(files).toContain('assets/index-a1b2c3d4.js'); + expect(files).toContain('assets/AtlasPage-99887766.js'); + }); + + it('on Android asks again on the next launch while the store is incomplete', async () => { + vi.mocked(TrekShell.refreshOfflineCopy).mockResolvedValue({ saved: true, complete: false }); + const fetchImpl = vi.fn(async () => new Response(JSON.stringify(manifest))) as unknown as typeof fetch; + + await keepOfflineShellFresh(fetchImpl, 'en', true); + await keepOfflineShellFresh(fetchImpl, 'en', true); + + expect(TrekShell.refreshOfflineCopy).toHaveBeenCalledTimes(2); + }); }); diff --git a/client/src/native/offlineShell.ts b/client/src/native/offlineShell.ts index 8bc1bf6bd..09a715a76 100644 --- a/client/src/native/offlineShell.ts +++ b/client/src/native/offlineShell.ts @@ -1,13 +1,16 @@ import { TrekShell } from './trekShell'; /** - * iOS only. WKWebView runs no service worker for a domain the app does not - * list at build time, so the app stands in for it: the native side keeps a - * copy of the start page (TrekShellPlugin.refreshOfflineCopy), and this pulls - * every chunk of the current build into WebKit's HTTP cache. The server marks - * them immutable, so a cold start without network can load the stored start - * page under the server's origin and find all its scripts, including the lazy - * routes nobody has opened yet. + * The app's stand-in for a service worker, so it starts without its server (a + * trip without reception, a server at home out of reach). WKWebView runs none + * for a domain the app does not list at build time, and Android's web view + * none on a plain-http server, the usual address of a server at home. So the + * native side keeps a copy of the start page (TrekShellPlugin.refreshOfflineCopy) + * and every chunk of the current build: iOS in WebKit's HTTP cache, which this + * fills (the server marks the files immutable), Android in the app's own store, + * which the native side fills from the list this hands it. A cold start without + * the server then loads the stored start page under the server's origin and + * finds all its scripts, including the lazy routes nobody has opened yet. */ const MANIFEST_URL = '/asset-manifest.json'; @@ -82,13 +85,23 @@ function rememberWarmed(build: string): void { } } -export async function keepOfflineShellFresh(fetchImpl: typeof fetch = fetch, language?: string): Promise { - await TrekShell.refreshOfflineCopy(); +export async function keepOfflineShellFresh( + fetchImpl: typeof fetch = fetch, + language?: string, + nativeStore = false +): Promise { + if (!nativeStore) await TrekShell.refreshOfflineCopy(); const response = await fetchImpl(MANIFEST_URL, { cache: 'no-store' }); if (!response.ok) return; const files = manifestFiles(await response.json(), language); // The build and the language together: a new language needs its own chunk. const build = `${[...files].sort((a, b) => a.localeCompare(b)).find((f) => /index-[^/]+\.js$/.test(f)) ?? files.length}:${language ?? 'en'}`; + if (nativeStore) { + // The native side fetches only what its store lacks, and keeps the start page fresh each time. + const { complete } = await TrekShell.refreshOfflineCopy({ files }); + if (complete) rememberWarmed(build); + return; + } if (warmedBuild() === build) return; const complete = await warmCache(files, (path) => fetchImpl(path, { priority: 'low' } as RequestInit).then((r) => r.blob()) diff --git a/client/src/native/trekShell.ts b/client/src/native/trekShell.ts index b64177115..ea5670079 100644 --- a/client/src/native/trekShell.ts +++ b/client/src/native/trekShell.ts @@ -57,9 +57,14 @@ export interface TrekShellPlugin { * only for two minutes, as long as the server keeps its code. Not in iOS builds, nor in Android builds before 5.1.4. */ takeAuthCallback(): Promise<{ url: string | null }>; - /** iOS: stores the server's start page for a cold start without network. */ - refreshOfflineCopy(): Promise<{ saved: boolean }>; - /** iOS: loads that copy under the server's origin. False when there is none. */ + /** + * Stores the server's start page for a start without the server. Android + * also downloads the build's `files` the copy does not hold yet (an Android + * build before the offline copy resolves `saved: false`); iOS keeps those in + * WebKit's HTTP cache instead and ignores them. + */ + refreshOfflineCopy(options?: { files?: string[] }): Promise<{ saved: boolean; complete?: boolean }>; + /** Starts on that copy under the server's origin. False when there is none. */ openOfflineCopy(): Promise<{ opened: boolean }>; /** What this binary offers the UI (native/capabilities.ts). Missing before shell API 2. */ getCapabilities(): Promise;