diff --git a/README.md b/README.md index ba2c0a3..ae9f7c7 100644 --- a/README.md +++ b/README.md @@ -26,7 +26,8 @@ APIs directly: display - mobile soft-key row for tmux-oriented input, including tmux prefix, detach, new window, previous/next window, Ctrl keys, arrows, page keys, and paste -- automatic update checks against the selected release manifest +- automatic update checks with Gitea first and GitHub fallback, plus manual + source-specific checks - one-download-per-version APK cache, SHA-256 verification, and installer handoff - native Update and About pages for version/build type, protocol, permission, @@ -161,9 +162,19 @@ manifest is: https://github.com/neatstudio/tmux-browser-android/releases/latest/download/latest.json ``` -The app checks only the selected update source. It does not probe GitHub and -Gitea during the same update check. Choose the source in the app's `Update` -page, or use a custom manifest/API URL. +The app has four update checks on the `Update` page: + +- `Auto check` tries Gitea first, then tries GitHub only if Gitea cannot be + reached. +- `Gitea` checks only the public Gitea release API. +- `GitHub` checks only the public GitHub manifest. +- `Selected` checks the source chosen with `Source`, including a custom + manifest/API URL. + +Each source retries transient network failures before that source is considered +failed. The `APK` and `Release page` buttons still resolve from the selected +source, so they can be forced to Gitea on phones that cannot reliably reach +GitHub. Gitea tag-specific assets are also public, for example: @@ -174,8 +185,9 @@ https://gitea.neatcn.com/tmux/tmux-browser-android/releases/download/v0.1.7/tmux In the app: -- Open the `Update` page to check `latest.json`, download the APK, verify - SHA-256, and open Android's installer. +- Open the `Update` page and tap `Auto check` to check `latest.json`, download + the APK, verify SHA-256, and open Android's installer. Use `Gitea`, `GitHub`, + or `Selected` to force a single update source. - If the same version APK was already downloaded and its SHA-256 still matches, the app reuses that file instead of downloading it again. - If Android sends you to the unknown-app install permission screen, return to diff --git a/app/src/main/java/com/neatstudio/tmuxandroid/MainActivity.java b/app/src/main/java/com/neatstudio/tmuxandroid/MainActivity.java index 53e7b0d..559a461 100644 --- a/app/src/main/java/com/neatstudio/tmuxandroid/MainActivity.java +++ b/app/src/main/java/com/neatstudio/tmuxandroid/MainActivity.java @@ -370,7 +370,10 @@ public final class MainActivity extends Activity { )); content.addView(sectionTitle("Update")); content.addView(actionPanel( - actionButton("Check now", view -> updateManager.check(true)), + actionButton("Auto check", view -> updateManager.check(true)), + actionButton("Gitea", view -> updateManager.checkGitea(true)), + actionButton("GitHub", view -> updateManager.checkGithub(true)), + actionButton("Selected", view -> updateManager.checkSelected(true)), actionButton("Source", view -> showUpdateSourcePicker()), actionButton("APK", view -> updateManager.openApkDownload()) )); @@ -428,7 +431,7 @@ public final class MainActivity extends Activity { "Update policy", "Selected source: " + updateSourceHost() + "\n" + prefs.getString("update_url", BuildConfig.DEFAULT_UPDATE_URL) + "\n" - + "The app checks only this source. APK downloads are cached by version and reused after Android install permission is granted." + + "Auto check tries Gitea first, then GitHub if Gitea cannot be reached. Manual Gitea/GitHub/Selected checks are also available. APK downloads are cached by version and reused after Android install permission is granted." )); content.addView(actionPanel( actionButton("Release page", view -> updateManager.openReleasePage()), @@ -1433,7 +1436,7 @@ public final class MainActivity extends Activity { text.append("Tap Release on the About page. The app resolves the page from the selected update source.\n"); text.append('\n'); text.append("In-app update:\n"); - text.append("Tap Check now on the Update page. The app checks only the selected source, downloads one APK per version, verifies SHA-256, then opens Android's installer.\n"); + text.append("Tap Auto check on the Update page to try Gitea first and GitHub only if Gitea cannot be reached. Use Gitea, GitHub, or Selected to force one source. Each source retries transient network failures before failing. The app downloads one APK per version, verifies SHA-256, then opens Android's installer.\n"); text.append("Selected manifest: ") .append(updateSourceHost()) .append('\n') diff --git a/app/src/main/java/com/neatstudio/tmuxandroid/UpdateManager.java b/app/src/main/java/com/neatstudio/tmuxandroid/UpdateManager.java index 79c77b2..6c2dd16 100644 --- a/app/src/main/java/com/neatstudio/tmuxandroid/UpdateManager.java +++ b/app/src/main/java/com/neatstudio/tmuxandroid/UpdateManager.java @@ -26,6 +26,8 @@ import java.util.concurrent.Executors; final class UpdateManager { private static final String PREF_PENDING_INSTALL_APK = "pending_install_apk"; + private static final int NETWORK_ATTEMPTS = 3; + private static final long RETRY_DELAY_MS = 1200L; interface Callback { void onChecking(boolean checking); @@ -51,25 +53,77 @@ final class UpdateManager { } void check(boolean userInitiated) { + checkWithFallback(userInitiated); + } + + void checkSelected(boolean userInitiated) { + startUpdateCheck( + userInitiated, + "selected source", + new String[]{getUpdateManifestUrl()} + ); + } + + void checkGitea(boolean userInitiated) { + startUpdateCheck( + userInitiated, + "Gitea", + new String[]{BuildConfig.DEFAULT_GITEA_UPDATE_URL} + ); + } + + void checkGithub(boolean userInitiated) { + startUpdateCheck( + userInitiated, + "GitHub", + new String[]{BuildConfig.DEFAULT_GITHUB_UPDATE_URL} + ); + } + + void checkWithFallback(boolean userInitiated) { + startUpdateCheck( + userInitiated, + "Gitea, then GitHub", + new String[]{BuildConfig.DEFAULT_GITEA_UPDATE_URL, BuildConfig.DEFAULT_GITHUB_UPDATE_URL} + ); + } + + private void startUpdateCheck(boolean userInitiated, String label, String[] manifestUrls) { if (checkInProgress) { postMessage("Update check already running"); return; } - String manifestUrl = getUpdateManifestUrl(); checkInProgress = true; callback.onChecking(true); - postMessage("Checking update from " + hostLabel(manifestUrl) + "..."); + postMessage("Checking update: " + label + "..."); executor.execute(() -> { + Exception lastError = null; try { - ReleaseInfo info = fetchReleaseInfo(manifestUrl); - if (info.versionCode <= BuildConfig.VERSION_CODE) { - postMessage("Already up to date: " + BuildConfig.VERSION_NAME); - return; + for (int index = 0; index < manifestUrls.length; index++) { + String manifestUrl = manifestUrls[index]; + try { + postMessage("Checking " + hostLabel(manifestUrl) + "..."); + ReleaseInfo info = fetchReleaseInfo(manifestUrl); + if (info.versionCode <= BuildConfig.VERSION_CODE) { + postMessage("Already up to date: " + BuildConfig.VERSION_NAME + " from " + hostLabel(manifestUrl)); + return; + } + postMessage("Update found: " + info.versionName + " from " + hostLabel(manifestUrl)); + activity.runOnUiThread(() -> showUpdateDialog(info)); + return; + } catch (Exception error) { + lastError = error; + if (index + 1 < manifestUrls.length) { + postMessage(hostLabel(manifestUrl) + " failed; trying " + hostLabel(manifestUrls[index + 1]) + "..."); + } + } } - postMessage("Update found: " + info.versionName); - activity.runOnUiThread(() -> showUpdateDialog(info)); - } catch (Exception error) { - postMessage(userInitiated ? "Update check failed: " + error.getMessage() : null); + if (lastError != null) { + throw lastError; + } + throw new IllegalStateException("No update sources configured"); + } catch (Exception finalError) { + postMessage(userInitiated ? "Update check failed: " + finalError.getMessage() : null); } finally { checkInProgress = false; activity.runOnUiThread(() -> callback.onChecking(false)); @@ -177,6 +231,22 @@ final class UpdateManager { } private String readText(String url) throws Exception { + Exception lastError = null; + for (int attempt = 1; attempt <= NETWORK_ATTEMPTS; attempt++) { + try { + return readTextOnce(url); + } catch (Exception error) { + lastError = error; + if (attempt < NETWORK_ATTEMPTS) { + postMessage("Retrying " + hostLabel(url) + " (" + (attempt + 1) + "/" + NETWORK_ATTEMPTS + ")..."); + waitBeforeRetry(); + } + } + } + throw lastError == null ? new IllegalStateException("Request failed") : lastError; + } + + private String readTextOnce(String url) throws Exception { HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection(); connection.setConnectTimeout(12000); connection.setReadTimeout(12000); @@ -238,7 +308,36 @@ final class UpdateManager { } postMessage("Downloading " + info.versionName + "..."); - HttpURLConnection connection = (HttpURLConnection) new URL(info.apkUrl).openConnection(); + File partial = new File(dir, "tmux-android-" + info.versionCode + ".apk.tmp"); + if (partial.exists()) { + partial.delete(); + } + if (apk.exists()) { + apk.delete(); + } + + Exception lastError = null; + for (int attempt = 1; attempt <= NETWORK_ATTEMPTS; attempt++) { + try { + downloadApkOnce(info.apkUrl, partial); + if (!partial.renameTo(apk)) { + throw new IllegalStateException("Cannot finalize APK download"); + } + return apk; + } catch (Exception error) { + lastError = error; + partial.delete(); + if (attempt < NETWORK_ATTEMPTS) { + postMessage("Retrying APK download (" + (attempt + 1) + "/" + NETWORK_ATTEMPTS + ")..."); + waitBeforeRetry(); + } + } + } + throw lastError == null ? new IllegalStateException("APK download failed") : lastError; + } + + private void downloadApkOnce(String apkUrl, File apk) throws Exception { + HttpURLConnection connection = (HttpURLConnection) new URL(apkUrl).openConnection(); connection.setConnectTimeout(12000); connection.setReadTimeout(60000); try (InputStream input = new BufferedInputStream(connection.getInputStream()); @@ -251,7 +350,6 @@ final class UpdateManager { } finally { connection.disconnect(); } - return apk; } private boolean isCachedApkValid(File apk, ReleaseInfo info) throws Exception { @@ -366,4 +464,8 @@ final class UpdateManager { } activity.runOnUiThread(() -> callback.onMessage(message)); } + + private void waitBeforeRetry() throws InterruptedException { + Thread.sleep(RETRY_DELAY_MS); + } } diff --git a/docs/android-client-notes.md b/docs/android-client-notes.md index 3b11d99..16c568a 100644 --- a/docs/android-client-notes.md +++ b/docs/android-client-notes.md @@ -101,11 +101,11 @@ The Android app cannot silently replace itself. It may download a newer APK and open Android's package installer, but the user must approve the install. On Android 8+, the user may also need to allow this app to install unknown apps. -The app checks exactly one update source per run: the selected manifest/API URL. -Gitea is the default public source because phones may not reach GitHub reliably. -GitHub is available as an optional public source, but the app does not fall back -across both providers during a normal check. This keeps update behavior -predictable on mobile networks and avoids duplicate provider checks. +The app provides explicit update checks for Auto, Gitea, GitHub, and Selected. +Auto checks Gitea first because phones may not reach GitHub reliably, then tries +GitHub only if Gitea cannot be reached. The manual Gitea, GitHub, and Selected +buttons force one source. Transient network failures are retried against the +current source before a source is considered failed. Downloaded APKs are cached by `versionCode`. If a cached APK exists and its SHA-256 matches the manifest, the app reuses it instead of downloading the same