diff --git a/AGENTS.md b/AGENTS.md
index e07a77b..0eec6df 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -29,7 +29,10 @@ a run stops as safety-critical (see SAFETY.md).
1. Never weaken, skip or delete a check to make a change pass. Fix the code or explain.
2. Never bypass the stop/vent confirmation, the ceiling clamp, or the START gate.
3. Saved-data changes must keep old files loading; add a `Migrate` case.
-4. No network code in release builds; no data leaves the phone unless the user opts in.
+4. GrowthTrack is the optional release network integration: public-client PKCE, secure tokens,
+ browser approval of an account connection enables automatic transfer of every new real
+ finished session. Disconnected and unmarked earlier history never upload; pending work
+ stays bound to its original grant. No per-session opt-in is required. Diagnostic log upload remains debug-only.
5. UI: Java-built views (no XML layouts), 48 dp minimum touch targets, colours and sizes
from `Look`, dialogs through `Ui.dialog()` + `Ui.dress()`.
6. New logic that can be pure goes in `core/` with a JUnit test.
diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
index 0b7f125..6faf50d 100644
--- a/ARCHITECTURE.md
+++ b/ARCHITECTURE.md
@@ -9,8 +9,11 @@ so that most of the logic can be understood, changed and tested without a phone.
app/ Android shell — screens, the foreground run service, Bluetooth (PumpLink),
notifications, widget, file providers. Depends on core.
app/src/debug is in debug builds only: the diagnostic console (MainActivity,
- its own Bluetooth connection and raw frames) and the INTERNET permission its
- log upload needs. The release APK carries neither.
+ its own Bluetooth connection and raw frames) and cleartext diagnostic log upload.
+ The release APK carries no diagnostic console. Optional
+ GrowthTrack has INTERNET/ACCESS_NETWORK_STATE in main. Browser approval enables
+ automatic same-account session sync, with a separate Activity/task, encrypted
+ no-backup state and persisted network-constrained retry jobs.
core/ Plain Java — no Android imports, enforced by ArchitectureTest.
Training plan, session engine, data model and persistence, share codes,
progress/analytics, and the ZD21 pump protocol (Proto) with its simulator;
@@ -25,6 +28,7 @@ is being removed — see the roadmap).
| You want to… | Look in |
|---|---|
+| Change the optional GrowthTrack connection | `core/./GrowthTrack*.java`, `app/./GrowthTrack*.java`; [developer handoff](docs/growthtrack-developer-handoff.md) |
| Change a screen | `app/src/main/java/org/openpump/*Screen.java`, `SessionActivity.java` |
| Change the training plan | `core/…/Plan.java`, `RxBuild.java`, `Mint.java`, `Deload.java` |
| Change how a run is recorded or saved | `core/…/AsRun.java`, `RunEdit.java`, `Session.java` |
diff --git a/README.md b/README.md
index d1fce38..2e001d0 100644
--- a/README.md
+++ b/README.md
@@ -12,7 +12,7 @@
-
+
@@ -36,7 +36,9 @@ The goal is bigger than any one feature: the best app there is to pump, track yo
- **Works with** the Epic Hydro PE Pump over Bluetooth. It's the one pump checked on real hardware so far. Others can be added by the people who own them.
- **No pump?** Practice mode runs everything against a simulated pump, and marks those runs as simulated.
-- **Your data** stays on your phone. No account, no server, no analytics.
+- **Your data** stays on your phone until you export/share it or connect your own GrowthTrack account. Connection enables automatic sync of new real finished sessions; disconnected and preconnection history does not send. Measurements, photos and notes are excluded from this optional connection.
+
+ This feature branch adds the GrowthTrack connection and read-only routine previews. Android build/device validation is still required before release; see the [developer handoff](docs/growthtrack-developer-handoff.md) and [verification record](docs/growthtrack-verification.md).
- **You need** Android 7.0 or newer.
- **It's free** and open source, under AGPL-3.0.
diff --git a/SAFETY.md b/SAFETY.md
index 7a25e71..b33816f 100644
--- a/SAFETY.md
+++ b/SAFETY.md
@@ -53,7 +53,11 @@ own risk — the full terms, including the warranty and liability disclaimer, ar
or leaving a screen never orphans a pump under pressure.
6. **Practice mode is never mistaken for a pump.** Simulated runs are labelled everywhere
and filed as simulated.
-7. **Nothing is sent on the user's behalf.** No network traffic in release builds.
+7. **Connection is optional and authorizes automatic sync.** GrowthTrack linking uses
+ the system browser; every new real finished session transfers to that grant. Disconnected
+ and preconnection history never sends. No measurements, photos or notes are uploaded.
+ Account-bound encrypted pending work retries automatically. Data transfer owns no pump connection and
+ cannot start hardware. The diagnostic log console remains debug-only.
These are enforced by code review, by `WiringCheck` (static checks over the source), by
the self-test, and — as pump drivers arrive — by a conformance kit every driver must pass.
diff --git a/app/src/debug/AndroidManifest.xml b/app/src/debug/AndroidManifest.xml
index c4a1f5a..62530b7 100644
--- a/app/src/debug/AndroidManifest.xml
+++ b/app/src/debug/AndroidManifest.xml
@@ -7,8 +7,9 @@
builds developers make themselves. SessionActivity reaches it by class name, and only
when BuildConfig.DEBUG says it is here.
- INTERNET and cleartext traffic are the console's log upload to a developer's own
- computer. Release builds never hold the INTERNET permission. -->
+ Cleartext traffic is for the console's log upload to a developer's own computer.
+ INTERNET is also declared in main for optional GrowthTrack account connection and automatic session sync.
+ Release builds forbid cleartext and carry no diagnostic console. -->
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index 0dbe550..db16f21 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -1,6 +1,10 @@
+
+
+
+
@@ -161,7 +165,8 @@
android:icon="@mipmap/ic_launcher"
android:roundIcon="@mipmap/ic_launcher_round"
android:theme="@android:style/Theme.DeviceDefault.NoActionBar"
- android:allowBackup="false">
+ android:allowBackup="false"
+ android:usesCleartextTraffic="false">
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/app/src/main/java/org/openpump/GrowthTrackActivity.java b/app/src/main/java/org/openpump/GrowthTrackActivity.java
new file mode 100644
index 0000000..c47acce
--- /dev/null
+++ b/app/src/main/java/org/openpump/GrowthTrackActivity.java
@@ -0,0 +1,335 @@
+package org.openpump;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.app.KeyguardManager;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.os.Bundle;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.Button;
+import android.widget.CheckBox;
+import android.widget.LinearLayout;
+import android.widget.ScrollView;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+/** Optional account connection and automatic-sync status. This activity never owns a pump link. */
+public final class GrowthTrackActivity extends Activity {
+ private static final int UNLOCK = 721;
+ private GrowthTrackManager manager;
+ private Model model;
+ private LinearLayout body;
+ private GrowthTrackClient.Snapshot snapshot;
+ private final Map receipts = new LinkedHashMap();
+ private String onlyId, page = "home", message = "";
+ private boolean busy, unlocked, askingUnlock;
+ private JSONArray library;
+ private JSONObject routine;
+
+ /** Main-thread observation only: refusing this handoff never commands or stops hardware. */
+ static boolean refuseHandOffUnderHold(Activity from) {
+ SessionActivity owner = SessionActivity.liveForDataHandoff();
+ if ((owner != null && owner.stillUnsafe()) || RunService.isRunning()) {
+ if (owner != null) owner.toast("Vent the pump before opening GrowthTrack or its browser");
+ return true;
+ }
+ return false;
+ }
+ static void open(SessionActivity owner, Model.Sess session) {
+ if (refuseHandOffUnderHold(owner)) return;
+ Intent intent = new Intent(owner, GrowthTrackActivity.class).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+ if (session != null) intent.putExtra("session_id", session.id);
+ owner.startActivity(intent);
+ }
+ static final class OpenTap implements View.OnClickListener {
+ private final SessionActivity owner; private final Model.Sess session;
+ OpenTap(SessionActivity owner, Model.Sess session) { this.owner = owner; this.session = session; }
+ @Override public void onClick(View v) { open(owner, session); }
+ }
+ static final class InformationTap implements View.OnClickListener {
+ final SessionActivity owner;
+ InformationTap(SessionActivity owner) { this.owner = owner; }
+ @Override public void onClick(View view) {
+ if (refuseHandOffUnderHold(owner)) return;
+ owner.startActivity(new Intent(owner, GrowthTrackActivity.class)
+ .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK).putExtra("information", true));
+ }
+ }
+ @Override protected void onCreate(Bundle b) {
+ super.onCreate(b); manager = GrowthTrackManager.get(this); model = Store.load(this, false);
+ SessionActivity.applySecureFlag(getWindow(), model);
+ onlyId = b == null ? getIntent().getStringExtra("session_id") : null;
+ if (getIntent().getBooleanExtra("information", false)) page = "about";
+ message = getIntent().getStringExtra("connection_message"); if (message == null) message = "";
+ buildRoot();
+ }
+ @Override protected void onNewIntent(Intent intent) {
+ super.onNewIntent(intent); setIntent(intent); model = Store.load(this, false);
+ SessionActivity.applySecureFlag(getWindow(), model);
+ page = "home"; onlyId = intent.getStringExtra("session_id");
+ if (intent.getBooleanExtra("information", false)) page = "about";
+ message = intent.getStringExtra("connection_message"); if (message == null) message = "";
+ refresh();
+ }
+ private void buildRoot() {
+ ScrollView scroll = new ScrollView(this); scroll.setFillViewport(true); scroll.setBackgroundColor(Ui.BG);
+ body = Ui.col(this); int padding = Ui.dp(this, Look.S5); body.setPadding(padding, padding, padding, padding);
+ scroll.addView(body, new ScrollView.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT)); setContentView(scroll);
+ }
+ @Override protected void onResume() {
+ super.onResume(); model = Store.load(this, false); SessionActivity.applySecureFlag(getWindow(), model);
+ if (needsUnlock() && !unlocked) { lockScreen(); return; } refresh();
+ }
+ private boolean needsUnlock() { return model.appLockOn && (model.appLockWholeApp || model.appLockSettings || model.appLockSessions); }
+ private void lockScreen() {
+ body.removeAllViews(); Ui.head(this, body, "GrowthTrack"); Ui.note(this, body, "Unlock to manage your connection and view sync status.");
+ button("Unlock", new Tap(Action.UNLOCK)); button("Back", new Tap(Action.FINISH));
+ }
+ private void askUnlock() {
+ if (refuseHandOffUnderHold(this)) return;
+ KeyguardManager keyguard = (KeyguardManager) getSystemService(KEYGUARD_SERVICE);
+ Intent intent = keyguard == null ? null : keyguard.createConfirmDeviceCredentialIntent("Unlock", "Review your connected app and sessions");
+ if (intent == null) { Ui.note(this, body, "Set a device PIN, pattern or password before opening this locked area."); return; }
+ askingUnlock = true; startActivityForResult(intent, UNLOCK);
+ }
+ @Override protected void onActivityResult(int request, int result, Intent data) {
+ super.onActivityResult(request, result, data);
+ if (request == UNLOCK) { askingUnlock = false; unlocked = result == RESULT_OK; if (unlocked) refresh(); else lockScreen(); }
+ }
+ @Override protected void onStop() {
+ super.onStop();
+ if (RunService.isRunning()) { library = null; routine = null; } // Private previews yield; automatic sync never owns the pump.
+ if (!askingUnlock) { unlocked = false; if (needsUnlock()) body.removeAllViews(); }
+ library = null; routine = null;
+ if ("library".equals(page) || "routine".equals(page)) { page = "home"; body.removeAllViews(); }
+ }
+ private void refresh() {
+ if (needsUnlock() && !unlocked) return;
+ List ids = new ArrayList(); for (Model.Sess s : model.sessLog.all) ids.add(s.id);
+ manager.run(new ReadState(ids), new Completed(null, true, false));
+ }
+ private static final class StateView {
+ final GrowthTrackClient.Snapshot snapshot; final Map receipts;
+ StateView(GrowthTrackClient.Snapshot snapshot, Map receipts) { this.snapshot = snapshot; this.receipts = receipts; }
+ }
+ private static final class ReadState implements GrowthTrackManager.Work {
+ final List ids; ReadState(List ids) { this.ids = ids; }
+ @Override public Object run(GrowthTrackClient client) {
+ Map statuses = new LinkedHashMap();
+ for (String id : ids) try { statuses.put(id, client.receipt(GrowthTrackProtocol.stableId(id))); } catch (IllegalArgumentException ignored) { }
+ return new StateView(client.snapshot(), statuses);
+ }
+ }
+ private void work(GrowthTrackManager.Work task, String next) { busy = true; render(); manager.run(task, new Completed(next, false, false)); }
+ private final class Completed implements GrowthTrackManager.Listener {
+ final String next; final boolean readState, reset;
+ Completed(String next, boolean readState, boolean reset) { this.next = next; this.readState = readState; this.reset = reset; }
+ @Override public void done(Object result, String error) { runOnUiThread(new Delivered(result, error, next, readState, reset)); }
+ }
+ private final class Delivered implements Runnable {
+ final Object result; final String error, next; final boolean readState, reset;
+ Delivered(Object result, String error, String next, boolean readState, boolean reset) { this.result = result; this.error = error; this.next = next; this.readState = readState; this.reset = reset; }
+ @Override public void run() {
+ if (isFinishing() || isDestroyed()) return;
+ if (readState) {
+ if (result instanceof StateView) { StateView state = (StateView) result; snapshot = state.snapshot; receipts.clear(); receipts.putAll(state.receipts); }
+ if (error != null) message = error; if (!needsUnlock() || unlocked) render(); return;
+ }
+ busy = false;
+ if (error != null) message = error; else { message = reset ? "Disconnected on this device." : ""; if (next != null) page = next; }
+ if (reset) { snapshot = null; library = null; routine = null; }
+ if (result instanceof String && error == null) {
+ if (hasWindowFocus() && (!needsUnlock() || unlocked)) openBrowser((String) result);
+ else message = "Connection prepared. Return and tap Connect to open your browser.";
+ }
+ if (result instanceof JSONObject && error == null) {
+ JSONObject json = (JSONObject) result;
+ // No private response cache survives backgrounding or a locked screen.
+ if (hasWindowFocus() && (!needsUnlock() || unlocked)) {
+ if (json.optJSONArray("routines") != null) library = json.optJSONArray("routines"); else routine = json.optJSONObject("routine");
+ } else page = "home";
+ }
+ refresh();
+ }
+ }
+ private enum Operation { BEGIN, CANCEL_AUTH, ROUTINES }
+ private static final class Task implements GrowthTrackManager.Work {
+ final Operation operation; final boolean read; final String id; final List payloads;
+ Task(Operation operation) { this(operation, false, null, null); }
+ Task(Operation operation, boolean read, String id, List payloads) { this.operation = operation; this.read = read; this.id = id; this.payloads = payloads; }
+ @Override public Object run(GrowthTrackClient client) throws Exception {
+ switch (operation) {
+ case BEGIN: return client.begin(read);
+ case CANCEL_AUTH: client.cancelAuthorization(); break;
+ case ROUTINES: return client.routines(id);
+ default: throw new IllegalStateException();
+ }
+ return null;
+ }
+ }
+ private void render() {
+ if (needsUnlock() && !unlocked) { lockScreen(); return; }
+ body.removeAllViews(); Ui.header(this, body, "GrowthTrack", new Tap(Action.BACK));
+ if (!message.isEmpty()) Ui.noteInfo(this, body, "Connection update", "GrowthTrack", message);
+ if (busy) Ui.note(this, body, "Working.");
+ if ("status".equals(page)) statusScreen();
+ else if ("library".equals(page)) libraryScreen(); else if ("routine".equals(page)) routineScreen();
+ else if ("about".equals(page)) informationScreen(); else homeScreen();
+ }
+ private void homeScreen() {
+ Ui.head(this, body, "Your GrowthTrack account");
+ button("About GrowthTrack and this connection", new Tap(Action.ABOUT));
+ if (snapshot == null) Ui.note(this, body, "Reading connection state.");
+ else Ui.noteInfo(this, body, snapshot.connected ? "Connected" : snapshot.pending ? "Waiting for browser approval" : "Not connected", "Connection status", snapshot.message);
+ Ui.noteInfo(this, body, "Connected: new sessions sync automatically.", "Connecting your account",
+ "Connection enables automatic transfer of every new real finished session to the account you approve in GrowthTrack. Disconnected sessions and earlier history stay on your phone. There is no per-session selection or Send step. Unsupported recordings show an explicit sync error.");
+ CheckBox read = check("Also allow reading my GrowthTrack routines", snapshot != null && snapshot.routines);
+ button(snapshot != null && snapshot.connected ? "Reconnect / change account" : "Connect to GrowthTrack", new ConnectTap(read));
+ if (snapshot != null && snapshot.pending) button("Cancel connection request", new Tap(Action.CANCEL_AUTH));
+ if (snapshot != null && snapshot.connected) {
+ button("Session sync status", new Tap(Action.STATUS));
+ if (snapshot.queued > 0) {
+ Ui.note(this, body, snapshot.queued + " sessions are pending. OpenPump retries them automatically when the connection is available.");
+ long wait = Math.max(0, snapshot.retryAt - System.currentTimeMillis());
+ Button retry = button(snapshot.paused ? "Reconnect to restore sync" : wait > 0 ? "Retry in " + ((wait + 999) / 1000) + " seconds" : "Retry sync", new Tap(Action.RETRY));
+ retry.setEnabled(!busy && wait == 0 && !snapshot.paused);
+ if (wait > 0) body.postDelayed(new RetryDisplay(), Math.min(wait + 100, 60_000));
+ }
+ button("Preview GrowthTrack routines", new Tap(Action.LIBRARY));
+ }
+ button("Manage access in GrowthTrack", new Tap(Action.MANAGE)); button("Disconnect on this device", new Tap(Action.DISCONNECT));
+ }
+ private final class RetryDisplay implements Runnable {
+ @Override public void run() { if (!isFinishing() && !isDestroyed() && hasWindowFocus() && "home".equals(page)) refresh(); }
+ }
+ private final class ConnectTap implements View.OnClickListener {
+ final CheckBox read; ConnectTap(CheckBox read) { this.read = read; }
+ @Override public void onClick(View view) {
+ dress(Ui.dialog(GrowthTrackActivity.this).setTitle("Connect to GrowthTrack?")
+ .setMessage("Choose your own GrowthTrack account in the system browser. OpenPump can add training sessions" + (read.isChecked() ? " and read your routine library" : "") + ". Every new real finished session syncs automatically to this account. Earlier history is not uploaded. It cannot read measurements or session history. Reconnecting discards pending transfers for the previous approval.")
+ .setPositiveButton("Continue", new Decision(Action.CONNECT, read.isChecked(), null)).setNegativeButton("Cancel", null).show());
+ }
+ }
+ private enum Action { UNLOCK, FINISH, BACK, CONNECT, CANCEL_AUTH, STATUS, RETRY, LIBRARY, MANAGE, DISCONNECT, RESET, LIBRARY_BACK, ABOUT, PROJECT, HOME }
+ private final class Tap implements View.OnClickListener {
+ final Action action; Tap(Action action) { this.action = action; }
+ @Override public void onClick(View view) { act(action, false, null); }
+ }
+ private final class Decision implements DialogInterface.OnClickListener {
+ final Action action; final boolean read; final List payloads;
+ Decision(Action action, boolean read, List payloads) { this.action = action; this.read = read; this.payloads = payloads; }
+ @Override public void onClick(DialogInterface dialog, int which) { act(action, read, payloads); }
+ }
+ private void act(Action action, boolean read, List payloads) {
+ if (busy && action != Action.BACK) return;
+ switch (action) {
+ case ABOUT: page = "about"; render(); break;
+ case PROJECT: openBrowser("https://pe-growth-track.com/"); break;
+ case HOME: page = "home"; render(); break;
+ case UNLOCK: askUnlock(); break;
+ case FINISH: finish(); break;
+ case BACK: onBackPressed(); break;
+ case CONNECT: work(new Task(Operation.BEGIN, read, null, null), "home"); break;
+ case CANCEL_AUTH: work(new Task(Operation.CANCEL_AUTH), "home"); break;
+ case STATUS: page = "status"; refresh(); break;
+ case RETRY: busy = true; render(); manager.startSync(new Completed("home", false, false)); break;
+ case LIBRARY:
+ if (snapshot == null || !snapshot.routines) { message = "Reconnect with the routine permission selected to preview your library."; render(); }
+ else work(new Task(Operation.ROUTINES), "library"); break;
+ case MANAGE: openBrowser(GrowthTrackProtocol.CONNECTED_APPS); break;
+ case DISCONNECT:
+ dress(Ui.dialog(this).setTitle("Disconnect GrowthTrack?")
+ .setMessage("Remove tokens and stop automatic sync and discard pending transfers on this device. Sessions already received remain in GrowthTrack. Also remove OpenPump from GrowthTrack Connected apps to revoke its server approval.")
+ .setPositiveButton("Disconnect", new Decision(Action.RESET, false, null)).setNegativeButton("Cancel", null).show()); break;
+ case RESET: busy = true; render(); manager.reset(new Completed("home", false, true)); break;
+ case LIBRARY_BACK: routine = null; page = "library"; render(); break;
+ default: throw new IllegalStateException();
+ }
+ }
+ private void dress(AlertDialog dialog) { Ui.dress(this, dialog); SessionActivity.applySecureFlag(dialog.getWindow(), model); }
+ private void informationScreen() {
+ Ui.head(this, body, "GrowthTrack, by your choice");
+ Ui.note(this, body, "GrowthTrack is a separate PE progress tracker for recording training sessions, routines and measurements in your own account.");
+ Ui.noteInfo(this, body, "Connect now or later in Settings.", "How to connect",
+ "Visit GrowthTrack to create or sign in to your account. Back here, choose Connect and approve OpenPump in your system browser. Check the account shown there. You can decline or cancel and keep using OpenPump.");
+ Ui.noteInfo(this, body, "Connect once; every new session syncs.", "What leaves your phone",
+ "Your connection authorizes automatic transfer of every real finished session recorded while connected. Sync includes IDs, original times, routine names, fixed automatic technique labels, set durations and recorded peak/net time. Photos, measurements and notes stay out. Earlier history is not uploaded. Offline sessions retry automatically; an unrepresentable recording shows why it cannot sync.");
+ Ui.noteInfo(this, body, "Routine previews are optional.", "Routine permission",
+ "With extra permission you can read your GrowthTrack routine library. These are previews only; they do not import executable pump routines or start the pump.");
+ Ui.noteInfo(this, body, "You control disconnection.", "Remove access",
+ "Disconnect clears local tokens and pending sends. Remove OpenPump in GrowthTrack Connected apps to revoke server approval. Records already sent remain in your GrowthTrack account.");
+ button("Visit GrowthTrack", new Tap(Action.PROJECT));
+ button("Connection and session controls", new Tap(Action.HOME));
+ button("Back to OpenPump", new Tap(Action.FINISH));
+ }
+ private void statusScreen() {
+ Ui.head(this, body, "Session sync status");
+ Ui.noteInfo(this, body, "New sessions sync automatically while connected.", "Session sync", "Every new real finished session syncs while connected. No sessions are selected individually. Earlier or disconnected history is not uploaded.");
+ int shown = 0;
+ for (Model.Sess session : model.sessLog.all) {
+ if (onlyId != null && !onlyId.equals(session.id)) continue;
+ shown++;
+ String status = receipts.getOrDefault(session.id, "");
+ if (session.sim) status = "Not synced: simulated recording";
+ else if (status.startsWith("Received")) { /* Keep confirmed receipts visible after access expires. */ }
+ else if (session.growthTrackConnectionId.isEmpty()) status = "Not synced: recorded before connection or while disconnected";
+ else if (snapshot == null || !snapshot.connected || !session.growthTrackConnectionId.equals(snapshot.connectionId))
+ status = "Previous or disconnected approval: current sync stopped; previously sent records may remain in that account";
+ else if (status.isEmpty()) status = "Waiting for automatic sync";
+ Ui.noteInfo(this, body, session.routineName == null ? "OpenPump session" : session.routineName, "Session sync", status);
+ }
+ if (shown == 0) Ui.note(this, body, "There are no recorded sessions here.");
+ Ui.noteInfo(this, body, "Technique labels are fixed.", "Automatic technique rules",
+ "Positive confirmed holds up to 6 seconds are Milking; above 6 through 30 are RIP; above 30 through 120 are Interval pumping; longer holds are Static pumping. Release and rest do not determine the label. The recorded Length track takes precedence. Unsupported timing or missing original timestamps are reported, never invented.");
+ button("Refresh status", new Tap(Action.STATUS));
+ }
+ private void libraryScreen() {
+ Ui.head(this, body, "GrowthTrack routine library"); Ui.note(this, body, "Read-only previews. A recipe's intensity hint is not an OpenPump machine setting.");
+ if (library == null) Ui.note(this, body, "Refresh to read the library again.");
+ else for (int i = 0; i < library.length(); i++) {
+ JSONObject item = library.optJSONObject(i); if (item != null) button(item.optString("name", "Routine") + " / " + item.optString("access") + " / " + item.optInt("step_count") + " steps", new RoutineTap(item.optString("id")));
+ }
+ button("Refresh library", new Tap(Action.LIBRARY));
+ }
+ private final class RoutineTap implements View.OnClickListener {
+ final String id; RoutineTap(String id) { this.id = id; }
+ @Override public void onClick(View v) { work(new Task(Operation.ROUTINES, false, id, null), "routine"); }
+ }
+ private void routineScreen() {
+ if (routine == null) { Ui.note(this, body, "This preview is no longer available. Refresh the library."); return; }
+ Ui.head(this, body, routine.optString("name", "GrowthTrack routine")); Ui.note(this, body, "Revision " + routine.optString("revision") + " / " + routine.optString("access"));
+ JSONArray steps = routine.optJSONArray("steps");
+ if (steps != null) for (int i = 0; i < steps.length(); i++) {
+ JSONObject step = steps.optJSONObject(i); if (step == null) continue;
+ Ui.fieldLabel(this, body, step.optInt("position", i + 1) + ". " + step.optString("exercise_name", "Exercise"), null);
+ Ui.note(this, body, step.optInt("sets", 1) + " sets / " + (step.isNull("work_seconds_per_set") ? "untimed / repetitions" : step.optInt("work_seconds_per_set") + " seconds per set"));
+ Ui.note(this, body, "Rest: " + step.optInt("rest_seconds_between_sets", 0) + " seconds between sets" + (i < steps.length() - 1 ? " and before the next step" : "; no trailing rest"));
+ if (!step.isNull("reps")) Ui.note(this, body, "Repetitions: " + step.optInt("reps"));
+ if (!step.isNull("intensity_hint")) Ui.noteInfo(this, body, "Author's intensity guidance", "Intensity hint", step.optString("intensity_hint"));
+ if (step.optBoolean("heat") || step.optBoolean("vibration")) Ui.note(this, body, "Author suggests " + (step.optBoolean("heat") ? "heat " : "") + (step.optBoolean("vibration") ? "vibration" : ""));
+ if ("own".equals(routine.optString("access")) && !step.isNull("notes")) Ui.noteInfo(this, body, "Your step notes", "Notes", step.optString("notes"));
+ }
+ Ui.noteInfo(this, body, "This preview cannot start an OpenPump routine.", "Device settings still need your review",
+ "Blocks are already expanded in this order. This device-neutral recipe does not supply the vacuum, release and cycle settings needed for a runnable OpenPump routine. Review and enter those settings in OpenPump's editor; this preview never starts hardware or silently substitutes values.");
+ button("Back to library", new Tap(Action.LIBRARY_BACK));
+ }
+ private CheckBox check(String text, boolean checked) {
+ CheckBox box = new CheckBox(this); box.setText(text); box.setTextColor(Ui.TEXT); box.setTextSize(Look.SP_BODY); box.setMinHeight(Ui.dp(this, 48)); box.setChecked(checked); box.setEnabled(!busy);
+ body.addView(box, new LinearLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT)); return box;
+ }
+ private Button button(String text, View.OnClickListener listener) { Button b = Ui.flat(this, body, text); b.setMinimumHeight(Ui.dp(this, 48)); b.setEnabled(!busy); b.setOnClickListener(listener); return b; }
+ private void openBrowser(String url) {
+ if (refuseHandOffUnderHold(this)) return;
+ try { startActivity(new Intent(Intent.ACTION_VIEW, android.net.Uri.parse(url))); }
+ catch (android.content.ActivityNotFoundException e) { message = "No system browser is available. Enable a browser to connect."; manager.run(new Task(Operation.CANCEL_AUTH), new Completed(null, true, false)); render(); }
+ }
+ @Override public void onBackPressed() {
+ if (!"home".equals(page)) { page = "home"; render(); } else super.onBackPressed();
+ }
+}
diff --git a/app/src/main/java/org/openpump/GrowthTrackCallbackActivity.java b/app/src/main/java/org/openpump/GrowthTrackCallbackActivity.java
new file mode 100644
index 0000000..45fe19e
--- /dev/null
+++ b/app/src/main/java/org/openpump/GrowthTrackCallbackActivity.java
@@ -0,0 +1,35 @@
+package org.openpump;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.os.Bundle;
+import android.widget.LinearLayout;
+
+/** Exported callback: no history and no credential-bearing URI forwarded to another activity. */
+public final class GrowthTrackCallbackActivity extends Activity {
+ @Override protected void onCreate(Bundle saved) {
+ super.onCreate(saved); SessionActivity.applySecureFlag(getWindow(), Store.load(this, false));
+ LinearLayout body = Ui.col(this); body.setBackgroundColor(Ui.BG); body.setPadding(Ui.dp(this, 24), Ui.dp(this, 24), Ui.dp(this, 24), Ui.dp(this, 24));
+ Ui.head(this, body, "Connecting to GrowthTrack."); setContentView(body);
+ String callback = getIntent().getDataString(); getIntent().setData(null);
+ if (!Intent.ACTION_VIEW.equals(getIntent().getAction()) || callback == null) { finish(); return; }
+ GrowthTrackManager.get(this).run(new Exchange(callback), new Completed());
+ }
+ private static final class Exchange implements GrowthTrackManager.Work {
+ final String callback; Exchange(String callback) { this.callback = callback; }
+ @Override public Object run(GrowthTrackClient client) throws Exception { client.callback(callback); return null; }
+ }
+ private final class Completed implements GrowthTrackManager.Listener {
+ @Override public void done(Object result, String error) { runOnUiThread(new Delivered(error)); }
+ }
+ private final class Delivered implements Runnable {
+ final String error; Delivered(String error) { this.error = error; }
+ @Override public void run() {
+ if (isFinishing() || isDestroyed()) return;
+ if (GrowthTrackActivity.refuseHandOffUnderHold(GrowthTrackCallbackActivity.this)) return;
+ Intent open = new Intent(GrowthTrackCallbackActivity.this, GrowthTrackActivity.class).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+ open.putExtra("connection_message", error == null ? "GrowthTrack connection response received. No sessions were sent." : error);
+ startActivity(open); finish();
+ }
+ }
+}
diff --git a/app/src/main/java/org/openpump/GrowthTrackHttp.java b/app/src/main/java/org/openpump/GrowthTrackHttp.java
new file mode 100644
index 0000000..f6f7fa1
--- /dev/null
+++ b/app/src/main/java/org/openpump/GrowthTrackHttp.java
@@ -0,0 +1,58 @@
+package org.openpump;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.util.Map;
+import javax.net.ssl.HttpsURLConnection;
+
+/** Fixed-origin HTTPS only, with no redirect forwarding, cookies, caches or payload logging. */
+final class GrowthTrackHttp implements GrowthTrackClient.Transport {
+ private volatile HttpsURLConnection active;
+ private android.net.Network network;
+ synchronized void useNetwork(android.net.Network value) { network = value; }
+ private long generation, operationGeneration;
+ synchronized long ticket() { return generation; }
+ synchronized void enter(long ticket) throws IOException {
+ if (ticket != generation) throw new IOException("GrowthTrack operation was cancelled before it started");
+ operationGeneration = ticket;
+ }
+ synchronized void cancel() { generation++; HttpsURLConnection connection = active; if (connection != null) connection.disconnect(); }
+ @Override public GrowthTrackClient.Response request(String method, String path, Map headers, String body) throws IOException {
+ if (!(path.equals("/oauth-token") || path.equals("/partner-ingest") || path.matches("/partner-routines(?:\\?id=[0-9a-fA-F-]{36})?")))
+ throw new IOException("Unsupported GrowthTrack endpoint");
+ if (!("GET".equals(method) || "POST".equals(method))) throw new IOException("Unsupported GrowthTrack operation");
+ HttpsURLConnection connection;
+ synchronized (this) {
+ // A queued Send may enter approve() after a Back/Cancel. Its old operation
+ // ticket still cannot open HTTP, even if the client's approval resets a flag.
+ if (operationGeneration != generation) throw new IOException("GrowthTrack operation was cancelled");
+ URL endpoint = new URL(GrowthTrackProtocol.API + path);
+ connection = (HttpsURLConnection) (network == null ? endpoint.openConnection() : network.openConnection(endpoint)); active = connection;
+ }
+ try {
+ connection.setInstanceFollowRedirects(false); connection.setUseCaches(false); connection.setConnectTimeout(15_000); connection.setReadTimeout(20_000);
+ connection.setRequestMethod(method);
+ for (Map.Entry h : headers.entrySet()) connection.setRequestProperty(h.getKey(), h.getValue());
+ if (body != null) {
+ byte[] bytes = body.getBytes(StandardCharsets.UTF_8);
+ if (bytes.length > GrowthTrackProtocol.MAX_BYTES) throw new IOException("GrowthTrack request exceeds its byte limit");
+ connection.setDoOutput(true); connection.setFixedLengthStreamingMode(bytes.length);
+ try (java.io.OutputStream out = connection.getOutputStream()) { out.write(bytes); }
+ }
+ int status = connection.getResponseCode();
+ if (status >= 300 && status < 400) throw new IOException("GrowthTrack unexpectedly redirected the request");
+ InputStream stream = status >= 400 ? connection.getErrorStream() : connection.getInputStream();
+ String response = "";
+ if (stream != null) try (InputStream in = stream; ByteArrayOutputStream out = new ByteArrayOutputStream()) {
+ byte[] buffer = new byte[8192]; int n;
+ while ((n = in.read(buffer)) != -1) { if (out.size() + n > 2_000_000) throw new IOException("GrowthTrack response exceeds its byte limit"); out.write(buffer, 0, n); }
+ response = new String(out.toByteArray(), StandardCharsets.UTF_8);
+ }
+ return new GrowthTrackClient.Response(status, response, connection.getHeaderField("Retry-After"));
+ } catch (IOException e) { throw new IOException("GrowthTrack network request failed"); }
+ finally { connection.disconnect(); if (active == connection) active = null; }
+ }
+}
diff --git a/app/src/main/java/org/openpump/GrowthTrackManager.java b/app/src/main/java/org/openpump/GrowthTrackManager.java
new file mode 100644
index 0000000..e946045
--- /dev/null
+++ b/app/src/main/java/org/openpump/GrowthTrackManager.java
@@ -0,0 +1,122 @@
+package org.openpump;
+
+import android.app.job.JobInfo;
+import android.app.job.JobScheduler;
+import android.content.ComponentName;
+import android.content.Context;
+import android.os.Handler;
+import android.os.Looper;
+import java.io.IOException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+/** One serial worker per process: rotating refresh credentials can never race. */
+final class GrowthTrackManager {
+ interface Work { Object run(GrowthTrackClient client) throws Exception; }
+ interface Listener { void done(Object result, String error); }
+ static final class SyncRequest { volatile boolean stopped; }
+ private volatile SyncRequest activeSync;
+ private final Handler main = new Handler(Looper.getMainLooper());
+ private static final int SYNC_JOB = 72041;
+ private static GrowthTrackManager instance;
+ private final ExecutorService worker = Executors.newSingleThreadExecutor();
+ private final Context context;
+ private final GrowthTrackStore store;
+ private final GrowthTrackHttp http = new GrowthTrackHttp();
+ private volatile GrowthTrackClient client;
+ private volatile boolean blocked;
+ private volatile String connectedGrant = "";
+ static synchronized GrowthTrackManager get(Context c) { if (instance == null) instance = new GrowthTrackManager(c.getApplicationContext()); return instance; }
+ private GrowthTrackManager(Context c) { context = c; store = new GrowthTrackStore(c); }
+ private GrowthTrackClient client() throws IOException {
+ if (client == null) client = new GrowthTrackClient(store, http, new GrowthTrackClient.Clock() { @Override public long now() { return System.currentTimeMillis(); } });
+ return client;
+ }
+ /** Main-thread observation only; this non-secret identity is frozen in the filed record. */
+ String connectionId() { return blocked ? "" : connectedGrant; }
+ private void cacheConnection(GrowthTrackClient ready) {
+ GrowthTrackClient.Snapshot state = ready.snapshot();
+ connectedGrant = !blocked && state.connected ? state.connectionId : "";
+ }
+ void run(final Work work, final Listener listener) { dispatch(work, listener, null); }
+ private void dispatch(final Work work, final Listener listener, final SyncRequest request) {
+ final long ticket = http.ticket();
+ worker.execute(new Runnable() { @Override public void run() {
+ Object result = null; String error = null; GrowthTrackClient ready = null;
+ try {
+ if (request != null && request.stopped) throw new IOException("Background sync was stopped");
+ activeSync = request;
+ if (blocked) throw new IOException("Connection cleanup is in progress");
+ http.enter(ticket); ready = client(); http.enter(ticket); cacheConnection(ready);
+ if (request != null && request.stopped) throw new IOException("Background sync was stopped");
+ http.useNetwork(null); result = work.run(ready);
+ }
+ catch (GrowthTrackClient.Problem e) { error = e.getMessage(); }
+ catch (IOException e) { error = e.getMessage(); }
+ catch (Exception e) { error = "Could not complete the GrowthTrack operation. No credential details are logged."; }
+ http.useNetwork(null); activeSync = null;
+ if (ready != null) cacheConnection(ready);
+ // Finish a running JobService before scheduling its next one-shot job.
+ if (listener != null) listener.done(result, error);
+ if (request != null && !request.stopped && ready != null && !blocked) {
+ try { http.enter(ticket); schedule(ready); } catch (IOException ignored) { }
+ }
+ } });
+ }
+ /** Only records marked at completion for this exact grant can recover into the encrypted queue. */
+ SyncRequest startSync(final Listener listener) { return startSync(listener, null); }
+ SyncRequest startSync(final Listener listener, final android.net.Network network) {
+ final SyncRequest request = new SyncRequest();
+ dispatch(new Work() { @Override public Object run(GrowthTrackClient ready) throws Exception {
+ GrowthTrackClient.Snapshot state = ready.snapshot();
+ if (!state.connected) return null;
+ http.useNetwork(network); ready.prepareAutomaticSync();
+ Model recorded = Store.load(context, false);
+ for (Model.Sess session : recorded.sessLog.all) {
+ if (state.connectionId.equals(session.growthTrackConnectionId))
+ ready.recordCompleted(session, Store.loadAsRun(context, session.ts), recorded, session.growthTrackConnectionId);
+ }
+ ready.syncPending(); return null;
+ } }, listener, request);
+ return request;
+ }
+ private JobScheduler jobs() { return (JobScheduler) context.getSystemService(Context.JOB_SCHEDULER_SERVICE); }
+ private void schedule(final GrowthTrackClient ready) {
+ final long due = ready.automaticRetryAt(); final long ticket = http.ticket();
+ // jobFinished posts its completion on the main looper. Schedule after that
+ // message so replacing this job ID cannot stop the job that just finished.
+ main.post(new Runnable() { @Override public void run() {
+ if (blocked) return;
+ try { http.enter(ticket); } catch (IOException ignored) { return; }
+ JobScheduler scheduler = jobs();
+ if (due < 0) { if (scheduler != null) scheduler.cancel(SYNC_JOB); return; }
+ int result = JobScheduler.RESULT_FAILURE;
+ try {
+ if (scheduler != null) result = scheduler.schedule(new JobInfo.Builder(SYNC_JOB, new ComponentName(context, GrowthTrackSyncService.class))
+ .setRequiredNetworkType(JobInfo.NETWORK_TYPE_ANY)
+ .setMinimumLatency(Math.max(1000L, due - System.currentTimeMillis()))
+ .setBackoffCriteria(30_000L, JobInfo.BACKOFF_POLICY_EXPONENTIAL)
+ .setPersisted(true).build());
+ } catch (RuntimeException ignored) { /* A scheduler refusal remains visible in sync status. */ }
+ if (result != JobScheduler.RESULT_SUCCESS) worker.execute(new Runnable() { @Override public void run() {
+ if (!blocked && client == ready) try { ready.backgroundUnavailable(); } catch (IOException ignored) { }
+ } });
+ } });
+ }
+ void cancelSync(SyncRequest request) {
+ if (request == null) return; request.stopped = true;
+ // A stopped queued job must not cancel an unrelated OAuth/routine operation.
+ if (activeSync == request) cancel();
+ }
+ void cancel() { GrowthTrackClient c = client; if (c != null) c.cancelRequests(); http.cancel(); }
+ void reset(final Listener listener) {
+ blocked = true; connectedGrant = ""; cancel(); JobScheduler scheduler = jobs(); if (scheduler != null) scheduler.cancel(SYNC_JOB);
+ worker.execute(new Runnable() { @Override public void run() {
+ String error = null;
+ try { store.erase(); client = null; blocked = false; }
+ catch (IOException e) { error = e.getMessage(); } // Keep requests blocked until reset succeeds.
+ if (listener != null) listener.done(null, error);
+ } });
+ }
+ static synchronized void eraseWithAppData(Context c) { get(c).reset(null); }
+}
diff --git a/app/src/main/java/org/openpump/GrowthTrackStore.java b/app/src/main/java/org/openpump/GrowthTrackStore.java
new file mode 100644
index 0000000..7abd48f
--- /dev/null
+++ b/app/src/main/java/org/openpump/GrowthTrackStore.java
@@ -0,0 +1,72 @@
+package org.openpump;
+
+import android.content.Context;
+import android.security.keystore.KeyGenParameterSpec;
+import android.security.keystore.KeyProperties;
+import android.util.AtomicFile;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.security.KeyStore;
+import javax.crypto.Cipher;
+import javax.crypto.KeyGenerator;
+import javax.crypto.SecretKey;
+import javax.crypto.spec.GCMParameterSpec;
+import org.json.JSONObject;
+
+/** Keystore-backed AES-GCM; tokens and approved records never enter preferences or backups. */
+final class GrowthTrackStore implements GrowthTrackClient.Store {
+ private static final String ALIAS = "org.openpump.growthtrack.v1";
+ private static final int MAX_STORED_BYTES = 16_000_000;
+ private final AtomicFile file;
+ GrowthTrackStore(Context context) { file = new AtomicFile(new File(context.getNoBackupFilesDir(), "growthtrack-v1.enc")); }
+ @Override public JSONObject read() throws IOException {
+ if (!file.getBaseFile().exists() && !new File(file.getBaseFile().getPath() + ".bak").exists()) return new JSONObject();
+ try (FileInputStream in = file.openRead()) {
+ ByteArrayOutputStream out = new ByteArrayOutputStream(); byte[] buffer = new byte[8192]; int n;
+ while ((n = in.read(buffer)) != -1) { if (out.size() + n > MAX_STORED_BYTES) throw new IOException(); out.write(buffer, 0, n); }
+ byte[] blob = out.toByteArray();
+ if (blob.length < 32 || blob[0] != 'G' || blob[1] != 'T' || blob[2] != 1) throw new IOException();
+ byte[] iv = java.util.Arrays.copyOfRange(blob, 3, 15);
+ Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding"); cipher.init(Cipher.DECRYPT_MODE, key(false), new GCMParameterSpec(128, iv));
+ cipher.updateAAD(new byte[]{'G', 'T', 1});
+ byte[] clear = cipher.doFinal(blob, 15, blob.length - 15);
+ try { return new JSONObject(new String(clear, StandardCharsets.UTF_8)); }
+ finally { java.util.Arrays.fill(clear, (byte) 0); }
+ } catch (Exception e) { throw new IOException("Secure GrowthTrack storage is unavailable. Disconnect/reset the connection to link again."); }
+ }
+ @Override public void write(JSONObject state) throws IOException {
+ FileOutputStream out = null; byte[] clear = state.toString().getBytes(StandardCharsets.UTF_8);
+ try {
+ if (clear.length > MAX_STORED_BYTES - 32) throw new IOException();
+ Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding"); cipher.init(Cipher.ENCRYPT_MODE, key(true));
+ cipher.updateAAD(new byte[]{'G', 'T', 1}); byte[] iv = cipher.getIV();
+ if (iv.length != 12) throw new IOException();
+ byte[] encrypted = cipher.doFinal(clear);
+ out = file.startWrite(); out.write(new byte[]{'G', 'T', 1}); out.write(iv); out.write(encrypted); file.finishWrite(out); out = null;
+ } catch (Exception e) { if (out != null) file.failWrite(out); throw new IOException("Could not securely save the GrowthTrack connection. No plain-text fallback is used."); }
+ finally { java.util.Arrays.fill(clear, (byte) 0); }
+ }
+ private static SecretKey key(boolean create) throws Exception {
+ KeyStore store = KeyStore.getInstance("AndroidKeyStore"); store.load(null);
+ if (store.containsAlias(ALIAS)) return (SecretKey) store.getKey(ALIAS, null);
+ if (!create) throw new IOException();
+ KeyGenerator generator = KeyGenerator.getInstance(KeyProperties.KEY_ALGORITHM_AES, "AndroidKeyStore");
+ generator.init(new KeyGenParameterSpec.Builder(ALIAS, KeyProperties.PURPOSE_ENCRYPT | KeyProperties.PURPOSE_DECRYPT)
+ .setBlockModes(KeyProperties.BLOCK_MODE_GCM).setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
+ .setKeySize(256).setRandomizedEncryptionRequired(true).build());
+ return generator.generateKey();
+ }
+ void erase() throws IOException {
+ file.delete();
+ boolean remains = file.getBaseFile().exists() || new File(file.getBaseFile().getPath() + ".bak").exists()
+ || new File(file.getBaseFile().getPath() + ".new").exists();
+ // Destroy the decryption key even if the filesystem could not remove an old blob.
+ try { KeyStore store = KeyStore.getInstance("AndroidKeyStore"); store.load(null); if (store.containsAlias(ALIAS)) store.deleteEntry(ALIAS); }
+ catch (Exception e) { throw new IOException("Could not remove the GrowthTrack encryption key"); }
+ if (remains) throw new IOException("Could not remove GrowthTrack connection storage. Retry reset before linking again.");
+ }
+}
diff --git a/app/src/main/java/org/openpump/GrowthTrackSyncService.java b/app/src/main/java/org/openpump/GrowthTrackSyncService.java
new file mode 100644
index 0000000..aaa72a6
--- /dev/null
+++ b/app/src/main/java/org/openpump/GrowthTrackSyncService.java
@@ -0,0 +1,35 @@
+package org.openpump;
+
+import android.app.job.JobParameters;
+import android.app.job.JobService;
+import android.os.Handler;
+import android.os.Looper;
+
+/** Android network-constrained retry. No UI, new OAuth grant, or pump access. */
+public final class GrowthTrackSyncService extends JobService {
+ private JobParameters active;
+ private GrowthTrackManager.SyncRequest request;
+ private final Handler main = new Handler(Looper.getMainLooper());
+ @Override public boolean onStartJob(JobParameters params) {
+ active = params;
+ request = GrowthTrackManager.get(this).startSync(new Finished(params), android.os.Build.VERSION.SDK_INT >= 28 ? params.getNetwork() : null);
+ return true;
+ }
+ private final class Finished implements GrowthTrackManager.Listener {
+ final JobParameters params; Finished(JobParameters params) { this.params = params; }
+ @Override public void done(Object result, String error) {
+ // The worker needs jobFinished to precede replacement scheduling. Android's
+ // JobService API accepts this callback from the worker; no view is touched.
+ jobFinished(params, false);
+ main.post(new Clear(params));
+ }
+ }
+ private final class Clear implements Runnable {
+ final JobParameters params; Clear(JobParameters params) { this.params = params; }
+ @Override public void run() { if (active == params) active = null; }
+ }
+ @Override public boolean onStopJob(JobParameters params) {
+ if (active == params) { active = null; GrowthTrackManager.get(this).cancelSync(request); request = null; }
+ return true;
+ }
+}
diff --git a/app/src/main/java/org/openpump/SessionActivity.java b/app/src/main/java/org/openpump/SessionActivity.java
index 5af510f..b638121 100644
--- a/app/src/main/java/org/openpump/SessionActivity.java
+++ b/app/src/main/java/org/openpump/SessionActivity.java
@@ -540,6 +540,7 @@ private Model.Set manualSourceSet() {
Model.Fmt.unit = model.unit; // keep the formatter in step with what was saved
Model.Fmt.sizeUnit = model.sizeUnit; // ...and the SIZE formatter, the same way
Model.Fmt.loadUnit = model.loadUnit; // ...and the LOAD formatter (2026-09-30)
+ GrowthTrackManager.get(this).startSync(null);
openLog();
storeUnreadable = Store.storeWasUnreadable();
// KEEP THE PHOTOS OUT OF THE PHONE'S GALLERY. The directory below is
@@ -868,6 +869,12 @@ private Model.Set manualSourceSet() {
* The running screen, for the guard at the top of onCreate. Main thread only; set as a
* screen is created and released in its onDestroy only if it is still this one. */
private static SessionActivity liveScreen;
+
+ /** Main-thread, read-only guard for optional connected-app handoffs. */
+ static SessionActivity liveForDataHandoff() {
+ SessionActivity s = liveScreen;
+ return s != null && !s.isFinishing() && !s.isDestroyed() ? s : null;
+ }
/** This instance was created over a running screen and finished at once: its onDestroy
* must touch nothing (no last stop, no clearLive, no service stop). */
private boolean duplicateScreen;
@@ -2711,7 +2718,7 @@ void applySecureWindow() {
* its switch is on. Incognito (0.10): the switch is "Hide from recent apps" in Settings ›
* Privacy - the same field, the same flag, and ONLY this switch sets it (WiringCheck
* invariant 193). */
- void applySecureFlag(android.view.Window w) {
+ static void applySecureFlag(android.view.Window w, Model model) {
if (w == null) return;
if (model != null && model.secureWindow)
w.setFlags(WindowManager.LayoutParams.FLAG_SECURE, WindowManager.LayoutParams.FLAG_SECURE);
@@ -2719,6 +2726,8 @@ void applySecureFlag(android.view.Window w) {
w.clearFlags(WindowManager.LayoutParams.FLAG_SECURE);
}
+ void applySecureFlag(android.view.Window w) { applySecureFlag(w, model); }
+
/* ================================================================ INCOGNITO (0.10)
*
* The part of Settings › Privacy that lives on this screen. The rules are Incognito's
@@ -27953,6 +27962,12 @@ private void fileSession(boolean aborted, long now) {
// ...and with the earlier parts, the session lasts them all and starts when the first
// did - before anything below keys on rec.ts (the as-run, the traces, the day).
RunParts.foldTime(parts, rec);
+ // Data-only wall-clock facts: do not reinterpret old history's end/start key.
+ // A rejoined record lacks independently preserved wall-clock bounds for all parts.
+ if (parts == null || parts.playedMs == 0) {
+ rec.recordedStartMs = session.runStartedAtOrZero();
+ rec.recordedEndMs = now;
+ }
el = rec.durSec;
sessionElapsedSec = el;
rec.completed = !aborted;
@@ -28213,7 +28228,10 @@ private void fileSession(boolean aborted, long now) {
// it is where the summary's Done goes, and the summary is drawn after this runs.
manualSource = null;
model.adhoc.clear();
+ GrowthTrackManager sync = GrowthTrackManager.get(this);
+ rec.growthTrackConnectionId = sync.connectionId();
Store.save(this, model);
+ sync.startSync(null);
// The run is over: stop attributing samples to it and stop its clock. What it
// accumulated stays readable (the summary is redrawn after the after-measurement
@@ -35336,6 +35354,7 @@ void refreshWidgetIdle() {
/** Set at load, so the warning survives the rest of onCreate deciding what to show. */
private boolean storeUnreadable = false;
+ boolean dataStoreUnreadable() { return storeUnreadable; }
/**
* THE SCREEN THAT USED TO NOT EXIST (audit A33). A model.json that could not be read
diff --git a/app/src/main/java/org/openpump/SettingsScreen.java b/app/src/main/java/org/openpump/SettingsScreen.java
index bf4201d..72d3c52 100644
--- a/app/src/main/java/org/openpump/SettingsScreen.java
+++ b/app/src/main/java/org/openpump/SettingsScreen.java
@@ -1029,6 +1029,12 @@ void showSettings() {
* out of sight. */
// Whether this build has the diagnostic console at all: only a debug build does (see
// the Diagnostics card below).
+ LinearLayout gConnected = Ui.cardGroup(a, a.body, "Connected apps", null, Ui.DIM);
+ Ui.note(a, gConnected, "GrowthTrack is optional. Connected: new sessions sync automatically. "
+ + "Disconnected: nothing sends.");
+ Button growthTrack = Ui.flat(a, gConnected, "GrowthTrack >");
+ growthTrack.setOnClickListener(new GrowthTrackActivity.OpenTap(a, null));
+
boolean console = SessionActivity.hasConsole();
/* ===== DEVICE & DEVELOPER — deliberately last ================================== */
diff --git a/app/src/main/java/org/openpump/SetupScreen.java b/app/src/main/java/org/openpump/SetupScreen.java
index aaf2d5d..c3bda2f 100644
--- a/app/src/main/java/org/openpump/SetupScreen.java
+++ b/app/src/main/java/org/openpump/SetupScreen.java
@@ -80,6 +80,7 @@ static final class Walk {
final HashSet open = new HashSet();
/** The battery row as last drawn, so a resume redraws only when it changed. */
boolean drawnExempt;
+ boolean growthTrackVisible;
Walk() {
// The one explanation open from the start: the battery's, on Ready.
@@ -932,6 +933,11 @@ private int starterMinutes() {
private void ready() {
Walk w = w();
+ if (GrowthTrackOnboarding.shouldOffer(a.model, RunService.isRunning(), a.dataStoreUnreadable())) {
+ GrowthTrackOnboarding.presented(a.model);
+ Store.save(a, a.model);
+ w.growthTrackVisible = true;
+ }
TextView h = text(SetupText.READY_TITLE, 22f, Ui.TEXT);
h.setTypeface(Typeface.DEFAULT_BOLD);
if (android.os.Build.VERSION.SDK_INT >= 28) h.setAccessibilityHeading(true);
@@ -939,6 +945,20 @@ private void ready() {
hl.bottomMargin = dp(Look.S4);
page.addView(h, hl);
+ if (w.growthTrackVisible) {
+ LinearLayout gt = card();
+ Ui.head(a, gt, "Connect your own GrowthTrack account?");
+ Ui.note(a, gt, "GrowthTrack records PE training sessions, routines and measurements. Connection is optional; you can skip and connect later in Settings.");
+ Ui.noteInfo(a, gt, "Nothing uploads just by connecting.", "Your choice",
+ "Use your own account and approve in your browser. While connected, every new real finished session syncs automatically. Disconnected sessions and earlier history stay on your phone. Skipping, cancelling or going back leaves OpenPump ready to use.");
+ Button connect = Ui.flat(a, gt, "Connect to GrowthTrack");
+ connect.setOnClickListener(new GrowthTrackChoice(true));
+ Button info = Ui.flat(a, gt, "About GrowthTrack and account setup");
+ info.setOnClickListener(new GrowthTrackActivity.InformationTap(a));
+ Button skip = Ui.flat(a, gt, "Skip for now");
+ skip.setOnClickListener(new GrowthTrackChoice(false));
+ }
+
// THE BATTERY: the one explanation open from the start, and the one row that goes
// out to a system screen - so the answer is read again on the way back (onResume).
boolean exempt = a.isBatteryExempt();
@@ -982,6 +1002,16 @@ private void ready() {
page.addView(opts, ol);
}
+ private final class GrowthTrackChoice implements View.OnClickListener {
+ final boolean connect;
+ GrowthTrackChoice(boolean connect) { this.connect = connect; }
+ @Override public void onClick(View view) {
+ w().growthTrackVisible = false;
+ show();
+ if (connect) GrowthTrackActivity.open(a, null);
+ }
+ }
+
private void summary(LinearLayout parent) {
Model m = a.model;
String size = Model.Fmt.S_IN.equals(m.sizeUnit) ? SetupText.SIZE_IN : SetupText.SIZE_CM;
diff --git a/app/src/main/java/org/openpump/Store.java b/app/src/main/java/org/openpump/Store.java
index f18c8aa..6ca1bba 100644
--- a/app/src/main/java/org/openpump/Store.java
+++ b/app/src/main/java/org/openpump/Store.java
@@ -538,6 +538,7 @@ public static void deleteTau(Context c, long sessTs) {
* the same either way, and a half-completed erase must still leave the app usable.
*/
public static boolean deleteAll(Context c) {
+ GrowthTrackManager.eraseWithAppData(c); // stop transfers and remove tokens outside backups too
File dir = c.getFilesDir();
boolean ok = true;
ok &= gone(new File(dir, FILE));
diff --git a/app/src/main/java/org/openpump/SummaryScreen.java b/app/src/main/java/org/openpump/SummaryScreen.java
index afc9692..896b311 100644
--- a/app/src/main/java/org/openpump/SummaryScreen.java
+++ b/app/src/main/java/org/openpump/SummaryScreen.java
@@ -314,6 +314,11 @@ void renderSummary() {
a.streakBlock(st.streak, "day streak", sub, st.weekDays, st.scheduledDays);
}
+ if (s != null && !s.sim) {
+ Button growthTrack = Ui.flat(a, a.body, "GrowthTrack sync status");
+ growthTrack.setOnClickListener(new GrowthTrackActivity.OpenTap(a, s));
+ }
+
boolean man = s != null && s.manual;
// The after-session measurement now leads the summary rather than closing it - see
// measureAfterCard(). One action, one place: a second identical button down here
diff --git a/core/src/main/java/org/openpump/AsRun.java b/core/src/main/java/org/openpump/AsRun.java
index c12c1cd..dce6949 100644
--- a/core/src/main/java/org/openpump/AsRun.java
+++ b/core/src/main/java/org/openpump/AsRun.java
@@ -71,6 +71,9 @@ public static final class Row {
/** Position of the set within its stage (Preset#pos) and position of the preset
* within the set's ladder (Preset#ordinal). */
public int pos, ordinal;
+ /** Frozen stitch boundary: -1 on old recordings, 0 a complete preset, 1 a
+ * continuation chunk. Data only; never changes how a preset is driven. */
+ public int cyclePart = -1;
public int up, upReq, lo, uhWire, uhReq, lh, sp;
/** False when the pump never acknowledged the write this row records (§2) — the
* card then says "the pump didn't confirm this change". */
@@ -113,6 +116,7 @@ public JSONObject toJson() throws JSONException {
// shim has no optLong, and one reader for both JVMs is the point of the shim.
o.put("t0", String.valueOf(t0)); o.put("t1", String.valueOf(t1));
o.put("st", stageIdx); o.put("pos", pos); o.put("ord", ordinal);
+ if (cyclePart >= 0) o.put("cyclePart", cyclePart);
o.put("sid", setId == null ? "" : setId);
o.put("up", up); o.put("upr", upReq); o.put("lo", lo);
o.put("uhw", uhWire); o.put("uhr", uhReq); o.put("lh", lh); o.put("sp", sp);
@@ -128,6 +132,8 @@ public static Row fromJson(JSONObject o) {
r.t0 = parseLong(o.optString("t0", "0"), 0L);
r.t1 = parseLong(o.optString("t1", "-1"), -1L);
r.stageIdx = o.optInt("st", 0); r.pos = o.optInt("pos", 0); r.ordinal = o.optInt("ord", 0);
+ int part = o.optInt("cyclePart", -1);
+ r.cyclePart = part == 0 || part == 1 ? part : -1;
r.setId = o.optString("sid", "");
r.up = o.optInt("up", 0);
// upReq absent (a row written before it existed) → what went on the wire: no
@@ -248,9 +254,11 @@ public Row openRow() {
*/
public Row open(int kind, long t0, Model.Preset p,
int up, int upReq, int lo, int uhWire, int uhReq, int lh, int sp) {
- return open(kind, t0, p == null ? 0 : p.stageIdx, p == null ? 0 : p.pos,
+ Row row = open(kind, t0, p == null ? 0 : p.stageIdx, p == null ? 0 : p.pos,
p == null ? "" : p.setId, p == null ? 0 : p.ordinal,
up, upReq, lo, uhWire, uhReq, lh, sp);
+ if (p != null && row.hasValues()) row.cyclePart = p.cyclePart ? 1 : 0;
+ return row;
}
/** {@link #open(int, long, Model.Preset, int, int, int, int, int, int, int)} with the
diff --git a/core/src/main/java/org/openpump/GrowthTrackClient.java b/core/src/main/java/org/openpump/GrowthTrackClient.java
new file mode 100644
index 0000000..6251f9f
--- /dev/null
+++ b/core/src/main/java/org/openpump/GrowthTrackClient.java
@@ -0,0 +1,407 @@
+package org.openpump;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/** Serialized OAuth and upload state machine. Transport and encrypted storage are Android seams. */
+public final class GrowthTrackClient {
+ public interface Store { JSONObject read() throws IOException; void write(JSONObject state) throws IOException; }
+ public interface Clock { long now(); }
+ public interface Transport { Response request(String method, String path, Map headers, String body) throws IOException; }
+ public static final class Response {
+ public final int status;
+ public final String body, retryAfter;
+ public Response(int status, String body) { this(status, body, null); }
+ public Response(int status, String body, String retryAfter) { this.status = status; this.body = body; this.retryAfter = retryAfter; }
+ }
+ public static final class Problem extends IOException {
+ public Problem(String message) { super(message); }
+ }
+ public static final class Snapshot {
+ public final boolean connected, routines, pending, paused;
+ public final int queued;
+ public final long retryAt;
+ public final String message;
+ public final String connectionId;
+ Snapshot(boolean connected, boolean routines, boolean pending, int queued, long retryAt, String message, String connectionId, boolean paused) {
+ this.connected = connected; this.routines = routines; this.pending = pending;
+ this.queued = queued; this.retryAt = retryAt; this.message = message;
+ this.connectionId = connectionId; this.paused = paused;
+ }
+ }
+ private final Store store;
+ private final Transport transport;
+ private final Clock clock;
+ private JSONObject state;
+ private volatile boolean cancelled;
+ private boolean storageBroken;
+
+ public GrowthTrackClient(Store store, Transport transport, Clock clock) throws IOException {
+ this.store = store; this.transport = transport; this.clock = clock;
+ state = store.read();
+ if (state == null) state = new JSONObject();
+ if (state.optInt("version", 1) != 1) throw new Problem("This connection storage needs a newer OpenPump version");
+ if (state.optBoolean("refreshing") || state.optBoolean("exchanging")) {
+ // A rotating token may have been consumed before the process died. Never replay it.
+ clearAuthority("Connection interrupted while exchanging credentials. Connect again."); save();
+ }
+ if (state.optJSONArray("approved") == null) put("approved", new JSONArray());
+ if (state.optJSONObject("receipts") == null) put("receipts", new JSONObject());
+ if (state.optJSONObject("tokens") != null && state.optString("connection_id").isEmpty()) {
+ clearAuthority("This older connection needs fresh browser approval."); save();
+ }
+ if (state.optJSONObject("tokens") != null && !state.optBoolean("automatic_sync")) {
+ clearAuthority("Connect again to enable automatic transfer of every new session."); save();
+ }
+ if (approved().length() > 0 && !state.optString("connection_id").equals(state.optString("approved_connection_id"))) {
+ put("approved", new JSONArray()); put("message", "The account approval changed. Pending sessions for the previous account were discarded."); save();
+ }
+ }
+ public synchronized Snapshot snapshot() {
+ JSONObject t = state.optJSONObject("tokens");
+ return new Snapshot(t != null && !storageBroken, t != null && !storageBroken && hasScope(t.optString("scope"), GrowthTrackProtocol.READ),
+ state.optJSONObject("pending") != null, approved().length(), state.optLong("retry_at", 0), state.optString("message", "Not connected"), state.optString("connection_id"), state.optBoolean("sync_paused"));
+ }
+ public synchronized String receipt(String id) { return state.optJSONObject("receipts").optString(id, ""); }
+ public void cancelRequests() { cancelled = true; }
+ private void checkCancelled() throws Problem { if (storageBroken) throw new Problem("Secure storage failed. Disconnect/reset this connection before continuing."); if (cancelled) throw new Problem("Sending stopped. An in-flight request may already have arrived; stable IDs make a later retry safe."); }
+
+ /** Changing account invalidates every old local approval; only future completions belong to the new grant. */
+ public synchronized String begin(boolean routines) throws IOException {
+ if (storageBroken) throw new Problem("Secure storage failed. Disconnect/reset this connection before continuing.");
+ cancelled = false;
+ clearAuthority("Waiting for GrowthTrack approval in your browser");
+ put("receipts", new JSONObject());
+ put("pending", pendingJson(GrowthTrackProtocol.pending(routines, clock.now()))); save();
+ try { return GrowthTrackProtocol.Pending.from(state.getJSONObject("pending")).authorizeUrl(); }
+ catch (JSONException e) { throw new Problem("Could not create the connection request"); }
+ }
+ public synchronized void cancelAuthorization() throws IOException {
+ state.remove("pending"); put("message", "Connection cancelled. No sessions were sent."); save();
+ }
+ public synchronized void callback(String uri) throws IOException {
+ GrowthTrackProtocol.Pending pending;
+ GrowthTrackProtocol.Callback callback;
+ try {
+ pending = state.optJSONObject("pending") == null ? null : GrowthTrackProtocol.Pending.from(state.getJSONObject("pending"));
+ callback = GrowthTrackProtocol.callback(uri, pending, clock.now());
+ } catch (JSONException | IllegalArgumentException e) { throw new Problem(e.getMessage()); }
+ checkCancelled();
+ state.remove("pending");
+ if (callback.error != null) { put("message", "access_denied".equals(callback.error) ? "GrowthTrack approval was declined. No sessions were sent." : "GrowthTrack could not approve this connection. Connect again."); save(); return; }
+ put("exchanging", true); save();
+ Map form = new LinkedHashMap();
+ form.put("grant_type", "authorization_code"); form.put("code", callback.code);
+ form.put("code_verifier", pending.verifier); form.put("client_id", GrowthTrackProtocol.CLIENT_ID); form.put("redirect_uri", GrowthTrackProtocol.REDIRECT);
+ try {
+ Response response = tokenRequest(form); checkCancelled();
+ if (response.status != 200) throw new Problem(tokenError(response));
+ put("tokens", tokens(response.body, pending.scope)); put("exchanging", false);
+ put("connection_id", pending.state); put("automatic_sync", true); put("sync_paused", false);
+ put("message", "Connected to the GrowthTrack account you approved in the browser. Every new real finished session will sync automatically. Earlier history stays on this device."); save();
+ } catch (IOException e) { clearAuthority("Could not complete the connection. Connect again; the authorization code will not be replayed."); save(); throw e; }
+ }
+ public synchronized void disconnect() throws IOException {
+ cancelled = true; clearAuthority("Disconnected on this device. Remove OpenPump in GrowthTrack Connected apps to revoke its server approval.");
+ put("receipts", new JSONObject()); save();
+ }
+ public synchronized void cancelApproved() throws IOException {
+ put("approved", new JSONArray()); put("retry_at", 0); put("attempts", 0);
+ put("message", "Sending stopped. Sessions already received by GrowthTrack remain there."); save();
+ }
+
+ /** Completion consent is the browser grant captured when the record was filed.
+ * Persisted record markers recover the tiny filing/queue crash window, without
+ * admitting disconnected history or records belonging to another account. */
+ public synchronized boolean recordCompleted(Model.Sess session, AsRun run, Model model, String completionConnectionId) throws IOException {
+ if (!snapshot().connected || completionConnectionId == null || completionConnectionId.isEmpty()
+ || !completionConnectionId.equals(state.optString("connection_id"))) return false;
+ checkCancelled();
+ String id;
+ try { id = GrowthTrackProtocol.stableId(session == null ? "" : session.id); }
+ catch (IllegalArgumentException e) { put("message", "Not synced: a finished record has no stable identifier."); save(); return false; }
+ if (!receipt(id).isEmpty() || ids(approved()).contains(id)) return false;
+ JSONObject payload;
+ try {
+ payload = GrowthTrackSession.draft(session, run, model).payload(); validateSession(payload);
+ if (envelope(new JSONArray().put(payload)).getBytes(StandardCharsets.UTF_8).length > GrowthTrackProtocol.MAX_BYTES)
+ throw new IllegalArgumentException("The recording exceeds GrowthTrack's request size limit");
+ } catch (IllegalArgumentException | JSONException e) {
+ receiptPut(id, "Not synced: " + safeReason(e.getMessage() == null ? "Invalid recording" : e.getMessage()));
+ put("message", "A finished recording cannot be sent. See session sync status for the reason."); save(); return false;
+ }
+ approved().put(payload); put("approved_connection_id", completionConnectionId);
+ put("message", approved().length() + " sessions waiting for automatic sync"); save(); return true;
+ }
+ /** Read-only scheduling decision: a paused permission error never loops in background. */
+ public synchronized long automaticRetryAt() {
+ Snapshot s = snapshot(); return s.connected && s.queued > 0 && !s.paused ? Math.max(clock.now(), s.retryAt) : -1;
+ }
+ public synchronized void backgroundUnavailable() throws IOException {
+ put("message", "Background sync could not be scheduled. Pending sessions are secure; reopen OpenPump or tap Retry to resume."); save();
+ }
+ /** Called on the serial native worker after a fresh transport generation is entered. */
+ public synchronized void prepareAutomaticSync() throws IOException {
+ if (storageBroken) throw new Problem("Secure storage failed. Disconnect/reset before continuing.");
+ cancelled = false;
+ }
+ /** Starts no OAuth and scans no unmarked history. Same-grant durable pending work only. */
+ public synchronized void syncPending() throws IOException {
+ if (automaticRetryAt() < 0 || clock.now() < state.optLong("retry_at", 0)) return;
+ cancelled = false; sendApproved();
+ }
+
+ /** A detached, allowlisted snapshot of exactly the records the user just reviewed. */
+ public synchronized void approve(List sessions) throws IOException {
+ approve(sessions, state.optString("connection_id"));
+ }
+ /** The review must still refer to the same browser grant, including across relinking. */
+ public synchronized void approve(List sessions, String reviewedConnectionId) throws IOException {
+ checkLinked(GrowthTrackProtocol.WRITE); cancelled = false;
+ if (reviewedConnectionId == null || reviewedConnectionId.isEmpty() || !reviewedConnectionId.equals(state.optString("connection_id")))
+ throw new Problem("The GrowthTrack account approval changed. Review these sessions again before sending.");
+ if (sessions == null || sessions.isEmpty()) throw new Problem("Select at least one session");
+ if (approved().length() != 0) throw new Problem("Retry or cancel the existing approved send first");
+ JSONArray queue = new JSONArray(); Set ids = new HashSet();
+ try {
+ for (JSONObject s : sessions) {
+ validateSession(s);
+ String id = s.getString("external_session_id");
+ if (!ids.add(id)) throw new Problem("The selection contains a duplicate session");
+ if (envelope(new JSONArray().put(s)).getBytes(StandardCharsets.UTF_8).length > GrowthTrackProtocol.MAX_BYTES)
+ throw new Problem("A selected session exceeds GrowthTrack's request size limit");
+ queue.put(new JSONObject(s.toString()));
+ }
+ } catch (JSONException | IllegalArgumentException e) { throw new Problem("The selected session payload is invalid"); }
+ put("approved", queue); put("attempts", 0); put("retry_at", 0); put("batch_limit", GrowthTrackProtocol.BATCH_SIZE);
+ put("approved_connection_id", reviewedConnectionId);
+ put("message", queue.length() + " reviewed sessions approved for sending"); save();
+ }
+ /** Retry uses the same durable, account-bound queue; startup and scheduled jobs call syncPending(). */
+ public synchronized void resumeApproved() throws IOException { put("sync_paused", false); cancelled = false; sendApproved(); }
+ public synchronized void sendApproved() throws IOException {
+ checkCancelled(); checkLinked(GrowthTrackProtocol.WRITE);
+ if (approved().length() > 0 && !state.optString("connection_id").equals(state.optString("approved_connection_id")))
+ throw new Problem("The approved send belongs to an earlier connection. Cancel it and review your sessions again.");
+ if (clock.now() < state.optLong("retry_at", 0)) throw new Problem("Please wait for the retry delay before trying again");
+ while (approved().length() > 0) {
+ checkCancelled();
+ JSONArray batch = batch(); String body = envelope(batch);
+ Response response;
+ try { response = authorized("POST", "/partner-ingest", body, GrowthTrackProtocol.WRITE); }
+ catch (Problem e) { throw e; }
+ catch (IOException e) { retry(null); throw new Problem("Offline or network error. Your sessions are saved for automatic retry."); }
+ checkCancelled();
+ if (response.status == 413 && batch.length() > 1) {
+ put("batch_limit", Math.max(1, batch.length() / 2)); save(); continue;
+ }
+ if (response.status == 408 || response.status == 429 || response.status >= 500) {
+ retry(response.retryAfter); throw new Problem("GrowthTrack is unavailable or busy. Your sessions are saved for automatic retry.");
+ }
+ if (response.status != 200) {
+ if (response.status == 400 || response.status == 413 || response.status == 422) {
+ for (int i = 0; i < batch.length(); i++) receiptPut(batch.optJSONObject(i).optString("external_session_id"), "Needs review: GrowthTrack rejected the request (" + response.status + ")");
+ removeIds(ids(batch)); put("message", "GrowthTrack rejected the request. Review the selected sessions before sending again."); save();
+ }
+ if (response.status != 400 && response.status != 413 && response.status != 422) {
+ put("sync_paused", true); put("message", "Sync paused: GrowthTrack rejected the request (" + response.status + "). Check the connection."); save();
+ }
+ throw new Problem("GrowthTrack rejected the request (" + response.status + "). See sync status.");
+ }
+ try { applyResults(batch, new JSONObject(response.body)); }
+ catch (JSONException | IllegalArgumentException e) { retry(null); throw new Problem("GrowthTrack returned an incomplete result. The approved batch is kept; retrying is safe."); }
+ if (state.optLong("retry_at", 0) > clock.now()) return;
+ }
+ }
+
+ public synchronized JSONObject routines(String id) throws IOException {
+ cancelled = false;
+ if (id != null && !id.matches("[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}"))
+ throw new Problem("Invalid GrowthTrack routine ID");
+ Response r = authorized("GET", "/partner-routines" + (id == null ? "" : "?id=" + id), null, GrowthTrackProtocol.READ);
+ checkCancelled();
+ if (r.status == 404) throw new Problem("This routine is no longer available. Refresh the library.");
+ if (r.status != 200) throw new Problem("Could not read the GrowthTrack library (" + r.status + "). Try again later.");
+ try {
+ JSONObject o = new JSONObject(r.body);
+ if (!"gt-routine".equals(o.getString("format")) || o.getInt("schema_version") != 1)
+ throw new Problem("This GrowthTrack routine format is not supported");
+ if (id == null) { if (o.getJSONArray("routines").length() > 1000) throw new JSONException("Too many routines"); }
+ else { JSONObject routine = o.getJSONObject("routine"); if (!id.equals(routine.getString("external_id")) || routine.getJSONArray("steps").length() > 1000) throw new JSONException("Invalid routine"); }
+ return o;
+ } catch (JSONException e) { throw new Problem("GrowthTrack returned an invalid routine response"); }
+ }
+
+ private Response authorized(String method, String path, String body, String scope) throws IOException {
+ checkLinked(scope);
+ JSONObject t = state.optJSONObject("tokens");
+ boolean refreshed = false;
+ if (clock.now() + 30_000 >= t.optLong("expires_at")) { refresh(); refreshed = true; }
+ Response r = authenticatedRequest(method, path, body);
+ if (r.status == 401 && !refreshed) { refresh(); r = authenticatedRequest(method, path, body); }
+ if (r.status == 401 || r.status == 410) {
+ clearAuthority("GrowthTrack access expired or was removed. Automatic sync stopped; connect again."); save();
+ throw new Problem("GrowthTrack access expired or was removed. Connect again.");
+ }
+ if (r.status == 403) { put("sync_paused", true); put("message", "Sync paused: GrowthTrack has not granted " + scope + ". Reconnect to restore access."); save(); throw new Problem(state.optString("message")); }
+ return r;
+ }
+ private Response authenticatedRequest(String method, String path, String body) throws IOException {
+ checkCancelled(); JSONObject t = state.optJSONObject("tokens");
+ Map headers = new LinkedHashMap();
+ headers.put("Authorization", "Bearer " + t.optString("access_token"));
+ headers.put("Accept", "application/json"); headers.put("Cache-Control", "no-store");
+ if (body != null) headers.put("Content-Type", "application/json; charset=utf-8");
+ return transport.request(method, path, headers, body);
+ }
+ private void refresh() throws IOException {
+ checkCancelled(); JSONObject old = state.optJSONObject("tokens");
+ if (old == null) throw new Problem("Connect to GrowthTrack first");
+ put("refreshing", true); save();
+ Map form = new LinkedHashMap();
+ form.put("grant_type", "refresh_token"); form.put("refresh_token", old.optString("refresh_token")); form.put("client_id", GrowthTrackProtocol.CLIENT_ID);
+ try {
+ Response r = tokenRequest(form); checkCancelled();
+ if (r.status != 200) throw new Problem(tokenError(r));
+ JSONObject replacement = tokens(r.body, old.optString("scope"));
+ if (old.optString("refresh_token").equals(replacement.optString("refresh_token"))) throw new Problem("GrowthTrack did not rotate the refresh credential");
+ put("tokens", replacement); put("refreshing", false); save();
+ } catch (IOException e) {
+ clearAuthority("Could not safely renew GrowthTrack access. Connect again; the old refresh credential will not be replayed."); save();
+ throw new Problem("Could not safely renew GrowthTrack access. Connect again.");
+ }
+ }
+ private Response tokenRequest(Map form) throws IOException {
+ Map headers = new LinkedHashMap();
+ headers.put("Content-Type", "application/x-www-form-urlencoded"); headers.put("Accept", "application/json"); headers.put("Cache-Control", "no-store");
+ return transport.request("POST", "/oauth-token", headers, GrowthTrackProtocol.form(form));
+ }
+ private JSONObject tokens(String body, String requestedScope) throws Problem {
+ try {
+ JSONObject o = new JSONObject(body); String access = o.getString("access_token"), refresh = o.getString("refresh_token");
+ int expiry = o.getInt("expires_in"); String scope = o.getString("scope");
+ if (!access.matches("gta_[A-Za-z0-9_-]{20,256}") || !refresh.matches("gtr_[A-Za-z0-9_-]{20,256}")
+ || !"Bearer".equalsIgnoreCase(o.getString("token_type")) || expiry < 1 || expiry > 900
+ || !hasScope(scope, GrowthTrackProtocol.WRITE)) throw new JSONException("Invalid credentials");
+ for (String s : scope.trim().split("\\s+")) if (!hasScope(requestedScope, s)) throw new JSONException("Unexpected permission");
+ if (hasScope(requestedScope, GrowthTrackProtocol.READ) && !hasScope(scope, GrowthTrackProtocol.READ))
+ throw new JSONException("Missing permission");
+ return new JSONObject().put("access_token", access).put("refresh_token", refresh).put("scope", scope)
+ .put("expires_at", clock.now() + expiry * 1000L);
+ } catch (JSONException e) { throw new Problem("GrowthTrack returned invalid credentials. Connect again."); }
+ }
+ private String tokenError(Response r) {
+ String code = ""; try { code = new JSONObject(r.body).optString("error"); } catch (JSONException ignored) { }
+ if ("invalid_client".equals(code)) return "GrowthTrack has not enabled this OpenPump client. Contact the integration maintainer.";
+ if ("invalid_grant".equals(code)) return "GrowthTrack authorization expired or was removed. Connect again.";
+ return "GrowthTrack could not complete authorization (" + r.status + "). Connect again.";
+ }
+ private void applyResults(JSONArray batch, JSONObject response) throws JSONException, IOException {
+ int accepted = count(response, "accepted"), duplicates = count(response, "duplicates");
+ JSONArray rejected = response.getJSONArray("rejected"); Set submitted = ids(batch), seen = new HashSet();
+ Map reasons = new LinkedHashMap();
+ for (int i = 0; i < rejected.length(); i++) {
+ JSONObject item = rejected.getJSONObject(i); String id = item.getString("external_session_id");
+ if (!submitted.contains(id) || !seen.add(id)) throw new JSONException("Invalid result IDs");
+ String reason = item.getString("reason");
+ reasons.put(id, reason.equals("Insert failed") || reason.contains("retry later") ? "retry" : "Needs review: " + safeReason(reason));
+ }
+ if ((long) accepted + duplicates + rejected.length() != batch.length()) throw new JSONException("Incomplete result counts");
+ Set finished = new HashSet(); boolean retry = false;
+ for (String id : submitted) {
+ String reason = reasons.get(id);
+ if ("retry".equals(reason)) { retry = true; continue; }
+ receiptPut(id, reason == null ? "Received by GrowthTrack (sent or already present)" : reason); finished.add(id);
+ }
+ removeIds(finished);
+ put("message", accepted + " accepted, " + duplicates + " already present, " + rejected.length() + " rejected.");
+ if (!retry) put("attempts", 0);
+ put("retry_at", 0); save();
+ if (retry) retry(null);
+ }
+ private static int count(JSONObject o, String field) throws JSONException {
+ Object value = o.get(field); if (!(value instanceof Number)) throw new JSONException("Invalid count");
+ double n = ((Number) value).doubleValue(); if (!Double.isFinite(n) || n < 0 || n > Integer.MAX_VALUE || Math.floor(n) != n) throw new JSONException("Invalid count");
+ return (int) n;
+ }
+ private JSONArray batch() throws IOException {
+ JSONArray out = new JSONArray(); int limit = Math.max(1, state.optInt("batch_limit", GrowthTrackProtocol.BATCH_SIZE));
+ for (int i = 0; i < approved().length() && i < limit; i++) {
+ out.put(approved().optJSONObject(i));
+ if (envelope(out).getBytes(StandardCharsets.UTF_8).length > GrowthTrackProtocol.MAX_BYTES) {
+ JSONArray smaller = new JSONArray(); for (int j = 0; j < out.length() - 1; j++) smaller.put(out.optJSONObject(j));
+ if (smaller.length() == 0) throw new Problem("An approved session exceeds the request size limit. Cancel and review it.");
+ return smaller;
+ }
+ }
+ return out;
+ }
+ private String envelope(JSONArray list) throws Problem { try { return new JSONObject().put("schema_version", 1).put("sessions", list).toString(); } catch (JSONException e) { throw new Problem("Could not prepare the upload"); } }
+ private static Set ids(JSONArray rows) { Set out = new HashSet(); for (int i = 0; i < rows.length(); i++) out.add(rows.optJSONObject(i).optString("external_session_id")); return out; }
+ private JSONArray approved() { return state.optJSONArray("approved"); }
+ private void removeIds(Set ids) throws Problem { JSONArray remaining = new JSONArray(); for (int i = 0; i < approved().length(); i++) if (!ids.contains(approved().optJSONObject(i).optString("external_session_id"))) remaining.put(approved().optJSONObject(i)); put("approved", remaining); }
+ private void receiptPut(String id, String text) throws Problem { try { state.optJSONObject("receipts").put(id, text); } catch (JSONException e) { throw new Problem("Could not save the upload result"); } }
+ private void retry(String retryAfter) throws IOException {
+ int attempts = Math.min(10, state.optInt("attempts", 0) + 1); long delay = Math.min(3_600_000L, 5000L << (attempts - 1));
+ if (retryAfter != null) try { delay = Math.max(delay, Math.min(86_400L, Math.max(0, Long.parseLong(retryAfter))) * 1000L); } catch (NumberFormatException ignored) { }
+ put("attempts", attempts); put("retry_at", clock.now() + delay); put("message", "Sessions are securely queued. Automatic retry is waiting for the connection or retry delay."); save();
+ }
+ private void checkLinked(String scope) throws Problem { if (storageBroken) throw new Problem("Secure storage failed. Disconnect/reset this connection before continuing."); JSONObject t = state.optJSONObject("tokens"); if (t == null) throw new Problem("Connect to GrowthTrack first"); if (!hasScope(t.optString("scope"), scope)) throw new Problem("Connect again to allow " + scope); }
+ private static boolean hasScope(String scopes, String scope) { for (String s : scopes.trim().split("\\s+")) if (scope.equals(s)) return true; return false; }
+ private void clearAuthority(String message) throws Problem { state.remove("tokens"); state.remove("pending"); state.remove("connection_id"); state.remove("approved_connection_id"); put("refreshing", false); put("exchanging", false); put("automatic_sync", false); put("sync_paused", false); put("approved", new JSONArray()); put("retry_at", 0); put("message", message); }
+ private JSONObject pendingJson(GrowthTrackProtocol.Pending p) throws Problem { try { return p.json(); } catch (JSONException e) { throw new Problem("Could not save authorization"); } }
+ private void put(String key, Object value) throws Problem { try { state.put(key, value); } catch (JSONException e) { throw new Problem("Could not save connection state"); } }
+ private void save() throws IOException { put("version", 1); try { store.write(new JSONObjectCopy(state).value); } catch (IOException e) { storageBroken = true; cancelled = true; throw e; } }
+ private static final class JSONObjectCopy { final JSONObject value; JSONObjectCopy(JSONObject original) throws Problem { try { value = new JSONObject(original.toString()); } catch (JSONException e) { throw new Problem("Could not save connection state"); } } }
+ private static String safeReason(String reason) { return reason.replaceAll("(?:gta|gtr|gtc|gtp)_[A-Za-z0-9_-]+", "[redacted]").substring(0, Math.min(200, reason.replaceAll("(?:gta|gtr|gtc|gtp)_[A-Za-z0-9_-]+", "[redacted]").length())); }
+ private static void validateSession(JSONObject s) throws JSONException {
+ Set allowed = new HashSet(java.util.Arrays.asList("external_session_id", "started_at", "completed_at", "routine_name", "total_duration_seconds", "time_under_tension_seconds", "pressure_peak_inhg", "method", "sets"));
+ for (java.util.Iterator it = s.keys(); it.hasNext();) if (!allowed.contains(it.next())) throw new JSONException("Unapproved session field");
+ if (s.getString("external_session_id").length() > 128 || s.getString("external_session_id").isEmpty()
+ || s.getString("routine_name").isEmpty() || s.getString("routine_name").length() > 200) throw new JSONException("Invalid session identity");
+ long started = timestamp(s.getString("started_at")), completed = timestamp(s.getString("completed_at"));
+ if (completed <= started) throw new JSONException("Invalid session timestamps");
+ int seconds = count(s, "total_duration_seconds"); if (seconds < 1 || seconds > 86400) throw new JSONException("Invalid duration");
+ if (s.has("time_under_tension_seconds")) { int tension = count(s, "time_under_tension_seconds"); if (tension < 1 || tension > seconds) throw new JSONException("Invalid time under tension"); }
+ if (s.has("pressure_peak_inhg")) {
+ Object value = s.get("pressure_peak_inhg");
+ if (!(value instanceof Number)) throw new JSONException("Invalid pressure");
+ double peak = ((Number) value).doubleValue();
+ if (!Double.isFinite(peak) || peak < 0 || peak > 29.92) throw new JSONException("Invalid pressure");
+ }
+ JSONArray sets = s.optJSONArray("sets");
+ if (sets == null || sets.length() == 0) { if (!GrowthTrackSession.method(s.getString("method"))) throw new JSONException("Invalid method"); }
+ else {
+ if (sets.length() > 500) throw new JSONException("Too many sets");
+ long totalSetSeconds = 0; Set indexes = new HashSet();
+ for (int i = 0; i < sets.length(); i++) {
+ JSONObject set = sets.getJSONObject(i);
+ for (java.util.Iterator it = set.keys(); it.hasNext();) if (!java.util.Arrays.asList("method", "set_index", "duration_seconds").contains(it.next())) throw new JSONException("Unapproved set field");
+ int index = count(set, "set_index");
+ if (index < 1 || !indexes.add(index) || !GrowthTrackSession.method(set.getString("method"))) throw new JSONException("Invalid set");
+ if (!set.isNull("duration_seconds")) {
+ int duration = count(set, "duration_seconds"); if (duration < 1 || duration > seconds) throw new JSONException("Invalid set duration");
+ totalSetSeconds += duration;
+ }
+ }
+ if (totalSetSeconds > seconds) throw new JSONException("Set durations exceed the session duration");
+ }
+ }
+ private static long timestamp(String text) throws JSONException {
+ if (!text.matches("\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}Z")) throw new JSONException("Invalid timestamp");
+ java.text.SimpleDateFormat format = new java.text.SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", java.util.Locale.ROOT);
+ format.setLenient(false); format.setTimeZone(java.util.TimeZone.getTimeZone("UTC"));
+ java.text.ParsePosition pos = new java.text.ParsePosition(0); java.util.Date date = format.parse(text, pos);
+ if (date == null || pos.getIndex() != text.length()) throw new JSONException("Invalid timestamp");
+ return date.getTime();
+ }
+}
diff --git a/core/src/main/java/org/openpump/GrowthTrackOnboarding.java b/core/src/main/java/org/openpump/GrowthTrackOnboarding.java
new file mode 100644
index 0000000..c89e56d
--- /dev/null
+++ b/core/src/main/java/org/openpump/GrowthTrackOnboarding.java
@@ -0,0 +1,13 @@
+package org.openpump;
+
+/** A one-time invitation only. It grants no authority and never queues or starts a run. */
+public final class GrowthTrackOnboarding {
+ private GrowthTrackOnboarding() { }
+ public static boolean shouldOffer(Model m, boolean runLive, boolean unreadable) {
+ if (m.growthTrackOfferSeen || runLive || unreadable) return false;
+ for (Model.Sess s : m.sessLog.all) if (!s.sim) return false;
+ return true;
+ }
+ /** Mark when displayed: Back, dismissal or process death must not become repeated nags. */
+ public static void presented(Model m) { m.growthTrackOfferSeen = true; }
+}
diff --git a/core/src/main/java/org/openpump/GrowthTrackProtocol.java b/core/src/main/java/org/openpump/GrowthTrackProtocol.java
new file mode 100644
index 0000000..153cc6a
--- /dev/null
+++ b/core/src/main/java/org/openpump/GrowthTrackProtocol.java
@@ -0,0 +1,127 @@
+package org.openpump;
+
+import java.net.URI;
+import java.net.URLDecoder;
+import java.net.URLEncoder;
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
+import java.security.SecureRandom;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/** The public native-client contract. No partner key or GrowthTrack user JWT belongs here. */
+public final class GrowthTrackProtocol {
+ private GrowthTrackProtocol() { }
+ public static final String API = "https://rxtqbktyeetmbigbpbdd.supabase.co/functions/v1";
+ public static final String CLIENT_ID = "gtc_bfa5809efbd314f246dd5d0f";
+ public static final String REDIRECT = "gt-openpump://oauth/callback";
+ public static final String CONNECTED_APPS = "https://pe-growth-track.com/connected-apps";
+ public static final String WRITE = "sessions:write", READ = "routines:read";
+ public static final int MAX_BYTES = 1_000_000;
+ // Below both the older pilot's 100 and the current handler's 500-session limit.
+ public static final int BATCH_SIZE = 100;
+ public static final long AUTH_LIFETIME_MS = 15 * 60_000L;
+
+ public static final class Pending {
+ public final String state, verifier, scope;
+ public final long createdAt;
+ Pending(String state, String verifier, String scope, long createdAt) {
+ this.state = state; this.verifier = verifier; this.scope = scope; this.createdAt = createdAt;
+ }
+ public JSONObject json() throws JSONException {
+ return new JSONObject().put("state", state).put("verifier", verifier)
+ .put("scope", scope).put("created_at", createdAt);
+ }
+ public static Pending from(JSONObject o) throws JSONException {
+ String state = o.getString("state"), verifier = o.getString("verifier");
+ if (!state.matches("[a-f0-9]{64}") || !verifier.matches("[A-Za-z0-9._~-]{43,128}"))
+ throw new JSONException("Invalid saved authorization");
+ String scope = o.getString("scope");
+ if (!WRITE.equals(scope) && !(WRITE + " " + READ).equals(scope))
+ throw new JSONException("Invalid saved scope");
+ return new Pending(state, verifier, scope, o.getLong("created_at"));
+ }
+ public String authorizeUrl() {
+ Map p = new LinkedHashMap();
+ p.put("response_type", "code"); p.put("client_id", CLIENT_ID); p.put("redirect_uri", REDIRECT);
+ p.put("scope", scope); p.put("state", state); p.put("code_challenge", challenge(verifier));
+ p.put("code_challenge_method", "S256");
+ return API + "/oauth-authorize?" + form(p);
+ }
+ }
+
+ public static Pending pending(boolean routines, long now) {
+ SecureRandom random = new SecureRandom();
+ byte[] a = new byte[32], b = new byte[32]; random.nextBytes(a); random.nextBytes(b);
+ return new Pending(hex(a), hex(b), WRITE + (routines ? " " + READ : ""), now);
+ }
+ public static String challenge(String verifier) {
+ if (verifier == null || !verifier.matches("[A-Za-z0-9._~-]{43,128}"))
+ throw new IllegalArgumentException("Invalid PKCE verifier");
+ return base64Url(digest(verifier));
+ }
+ public static String stableId(String id) {
+ if (id == null || id.trim().isEmpty()) throw new IllegalArgumentException("This record has no stable session ID");
+ return id.length() <= 125 ? "op_" + id : "op_" + hex(digest(id));
+ }
+
+ public static final class Callback {
+ public final String code, error;
+ Callback(String code, String error) { this.code = code; this.error = error; }
+ }
+ /** Validate the exact callback and state before consuming anything or making a request. */
+ public static Callback callback(String value, Pending pending, long now) {
+ if (pending == null) throw new IllegalArgumentException("No connection request is waiting");
+ if (now < pending.createdAt || now - pending.createdAt > AUTH_LIFETIME_MS)
+ throw new IllegalArgumentException("Connection request expired. Connect again");
+ if (value == null || value.length() > 8192) throw new IllegalArgumentException("Invalid connection callback");
+ try {
+ URI u = new URI(value);
+ if (!"gt-openpump".equals(u.getScheme()) || !"oauth".equals(u.getHost())
+ || !"/callback".equals(u.getRawPath()) || u.getPort() != -1
+ || u.getUserInfo() != null || u.getFragment() != null)
+ throw new IllegalArgumentException("Unexpected connection callback");
+ Map p = new LinkedHashMap();
+ if (u.getRawQuery() == null) throw new IllegalArgumentException("Missing connection response");
+ for (String pair : u.getRawQuery().split("&", -1)) {
+ String[] parts = pair.split("=", 2);
+ String key = decode(parts[0]), val = parts.length == 2 ? decode(parts[1]) : "";
+ if (!("state".equals(key) || "code".equals(key) || "error".equals(key) || "error_description".equals(key))
+ || p.put(key, val) != null) throw new IllegalArgumentException("Invalid connection response parameters");
+ }
+ String state = p.get("state");
+ if (state == null || !MessageDigest.isEqual(pending.state.getBytes(StandardCharsets.UTF_8),
+ state.getBytes(StandardCharsets.UTF_8))) throw new IllegalArgumentException("Connection response did not match this request");
+ String code = p.get("code"), error = p.get("error");
+ if ((code == null) == (error == null)) throw new IllegalArgumentException("Invalid connection response");
+ if (code != null && !code.matches("gtc_[A-Za-z0-9_-]{20,256}"))
+ throw new IllegalArgumentException("Invalid authorization code");
+ if (error != null && !error.matches("[a-z_]{1,64}")) throw new IllegalArgumentException("Invalid authorization response");
+ return new Callback(code, error);
+ } catch (IllegalArgumentException e) { throw e; }
+ catch (Exception e) { throw new IllegalArgumentException("Invalid connection callback"); }
+ }
+
+ public static String form(Map values) {
+ StringBuilder out = new StringBuilder();
+ for (Map.Entry e : values.entrySet()) {
+ if (out.length() != 0) out.append('&');
+ out.append(encode(e.getKey())).append('=').append(encode(e.getValue()));
+ }
+ return out.toString();
+ }
+ private static String encode(String s) { try { return URLEncoder.encode(s, "UTF-8"); } catch (Exception e) { throw new AssertionError(e); } }
+ private static String decode(String s) { try { return URLDecoder.decode(s, "UTF-8"); } catch (Exception e) { throw new IllegalArgumentException("Invalid callback encoding"); } }
+ private static byte[] digest(String s) { try { return MessageDigest.getInstance("SHA-256").digest(s.getBytes(StandardCharsets.UTF_8)); } catch (Exception e) { throw new AssertionError(e); } }
+ private static String hex(byte[] bytes) { StringBuilder s = new StringBuilder(); for (byte b : bytes) s.append(String.format(java.util.Locale.ROOT, "%02x", b & 255)); return s.toString(); }
+ // java.util.Base64 is API 26; the application also supports Android 24 and 25.
+ private static String base64Url(byte[] data) {
+ String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+ StringBuilder out = new StringBuilder(); int bits = 0, buffer = 0;
+ for (byte b : data) { buffer = (buffer << 8) | (b & 255); bits += 8; while (bits >= 6) { bits -= 6; out.append(alphabet.charAt((buffer >>> bits) & 63)); } }
+ if (bits > 0) out.append(alphabet.charAt((buffer << (6 - bits)) & 63));
+ return out.toString();
+ }
+}
diff --git a/core/src/main/java/org/openpump/GrowthTrackSession.java b/core/src/main/java/org/openpump/GrowthTrackSession.java
new file mode 100644
index 0000000..9dc350f
--- /dev/null
+++ b/core/src/main/java/org/openpump/GrowthTrackSession.java
@@ -0,0 +1,172 @@
+package org.openpump;
+
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.TimeZone;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/** An allowlist mapper, deliberately independent of Model's broad persistence/export JSON. */
+public final class GrowthTrackSession {
+ private GrowthTrackSession() { }
+ public static final String[] METHODS = {
+ "static_pumping", "interval_pumping", "rip", "sleeved_pumping", "length_pumping",
+ "milking", "high_pressure_milking", "pac", "airlock_clamping", "clamping", "hard_clamping",
+ "soft_clamping", "hypoxic_clamping", "manual_clamping", "clamped_ulis", "ulis",
+ "hanging", "static_hanging", "interval_hanging", "bundle_hanging", "fulcrum_hanging", "rapid_interval_hanging",
+ "extending", "static_extending", "interval_extending", "bundle_extending", "rapid_interval_vacuum_extending",
+ "jelqing", "manuals", "fowfers", "bundled_stretching", "mandingo_stretch", "fulcrum_bends",
+ "semi_erect_bends", "vibra_tugging", "kegels", "reverse_kegels", "angion_1", "angion_2", "angion_3", "angion_4",
+ "sabre", "warm_up", "massage", "edging", "ads", "bfr", "fire_goat_rolls", "tunica_shears"
+ };
+ public static boolean method(String slug) { for (String m : METHODS) if (m.equals(slug)) return true; return false; }
+
+ /** Positive UPPER hold duration, excluding release/rest. Classify before any wire rounding. */
+ public static String methodForHoldMillis(double holdMs) {
+ if (!Double.isFinite(holdMs) || holdMs <= 0) throw new IllegalArgumentException("A positive recorded hold duration is required");
+ if (holdMs <= 6000) return "milking";
+ if (holdMs <= 30000) return "rip";
+ if (holdMs <= 120000) return "interval_pumping";
+ return "static_pumping";
+ }
+ public static String methodLabel(String method) {
+ if ("milking".equals(method)) return "Milking";
+ if ("rip".equals(method)) return "RIP";
+ if ("interval_pumping".equals(method)) return "Interval pumping";
+ if ("static_pumping".equals(method)) return "Static pumping";
+ if ("length_pumping".equals(method)) return "Length pumping";
+ return method.replace('_', ' ');
+ }
+
+ public static final class Part {
+ public final String label, method;
+ public final int seconds;
+ public final long recordedMillis, holdMillis;
+ Part(String label, long recordedMillis, long holdMillis, String method) {
+ this.label = label; this.recordedMillis = recordedMillis; this.seconds = (int) (recordedMillis / 1000L);
+ this.holdMillis = holdMillis; this.method = method;
+ }
+ }
+ public static final class Draft {
+ public final String id, name, startedAt, completedAt;
+ public final int seconds;
+ public final Double observedPeakInhg;
+ public final Integer tensionSeconds;
+ public final List parts = new ArrayList();
+ public final List warnings = new ArrayList();
+ private String wholeMethod;
+ public String methodForWholeSession() { return wholeMethod; }
+ Draft(Model.Sess s) {
+ if (s == null || s.sim) throw new IllegalArgumentException("Simulated sessions cannot be sent to GrowthTrack");
+ id = GrowthTrackProtocol.stableId(s.id);
+ if (s.recordedStartMs <= 0 || s.recordedEndMs <= s.recordedStartMs || s.durSec < 1 || s.durSec > 86400
+ || s.durSec * 1000L > s.recordedEndMs - s.recordedStartMs + 1000L)
+ throw new IllegalArgumentException("Original wall-clock session boundaries are unavailable or inconsistent; older or rejoined history cannot be sent");
+ name = s.routineName == null || s.routineName.trim().isEmpty() ? "OpenPump session" : s.routineName.trim();
+ if (name.length() > 200) throw new IllegalArgumentException("Routine name is longer than GrowthTrack's 200-character limit");
+ seconds = (int) s.durSec;
+ // Only explicitly recorded wall-clock facts, never the ambiguous legacy day/key stamp.
+ startedAt = iso(s.recordedStartMs); completedAt = iso(s.recordedEndMs);
+ double peak = s.peakKpa == null ? Double.NaN : s.peakKpa / 3.38639;
+ observedPeakInhg = Double.isFinite(peak) && peak >= 0 && peak <= 29.92 ? peak : null;
+ if (s.peakKpa != null && observedPeakInhg == null) warnings.add("The implausible observed peak is omitted.");
+ // Gross is sealed elapsed time INCLUDING releases. Net is the saved measured,
+ // phase-filtered training time; never substitute gross or commanded duty cycle.
+ double tup = s.netTupSec == null ? Double.NaN : s.netTupSec;
+ tensionSeconds = Double.isFinite(tup) && tup >= 1 && tup <= seconds ? (int) Math.floor(tup) : null;
+ if (s.netTupSec != null && tensionSeconds == null) warnings.add("The unavailable or inconsistent measured net time under pressure is omitted.");
+ if (!s.completed) warnings.add("This was stopped early. Only its recorded elapsed work is sent.");
+ }
+ public JSONObject payload() throws JSONException {
+ if (parts.isEmpty() && wholeMethod == null) throw new IllegalArgumentException("No classifiable recorded work exists for this session");
+ JSONObject o = new JSONObject().put("external_session_id", id).put("started_at", startedAt)
+ .put("completed_at", completedAt).put("routine_name", name).put("total_duration_seconds", seconds);
+ if (observedPeakInhg != null) o.put("pressure_peak_inhg", observedPeakInhg);
+ if (tensionSeconds != null) o.put("time_under_tension_seconds", tensionSeconds);
+ if (wholeMethod != null) { o.put("method", wholeMethod); return o; }
+ JSONArray sets = new JSONArray();
+ for (int i = 0; i < parts.size(); i++) {
+ Part part = parts.get(i);
+ JSONObject set = new JSONObject().put("set_index", i + 1).put("method", part.method);
+ // GT v1 only accepts whole positive seconds. Null preserves a subsecond
+ // segment's technique without fabricating a second of delivered work.
+ set.put("duration_seconds", part.seconds > 0 ? part.seconds : JSONObject.NULL);
+ sets.put(set);
+ }
+ o.put("sets", sets);
+ return o;
+ }
+ }
+
+ public static Draft draft(Model.Sess s, AsRun run) {
+ return draft(s, run, null);
+ }
+ public static Draft draft(Model.Sess s, AsRun run, Model model) {
+ Draft draft = new Draft(s);
+ Model.AsRunSnapshot snap = run != null && run.snap != null ? run.snap : s.asRunSnapshot;
+ boolean length = snap != null && snap.trainerTrack == Plan.TRACK_LENGTH;
+ // Legacy snapshots have no frozen marker. Only use a structured marker on a
+ // routine whose full saved structure/values still match, never a free-text name.
+ if (snap != null && snap.trainerTrack < 0 && model != null) {
+ Model.Routine routine = model.routine(s.routineId);
+ length = routine != null && routine.trainerTrack == Plan.TRACK_LENGTH && snap.matches(routine, model);
+ }
+ if (run == null || run.rows.isEmpty()) {
+ if (length) {
+ draft.wholeMethod = "length_pumping";
+ draft.warnings.add("The recorded Length track labels this sitting. No detailed set breakdown exists; only saved session elapsed/net figures are sent, with no invented work set.");
+ return draft;
+ }
+ throw new IllegalArgumentException("Detailed hold recording is unavailable; an automatic technique cannot be determined");
+ }
+ LinkedHashMap durations = new LinkedHashMap();
+ LinkedHashMap names = new LinkedHashMap();
+ LinkedHashMap holds = new LinkedHashMap();
+ LinkedHashMap methods = new LinkedHashMap();
+ long previousEnd = 0;
+ for (AsRun.Row row : run.rows) {
+ if (row.kind == AsRun.SKIPPED) continue;
+ if (row.t0 < 0 || row.t1 < row.t0 || row.t0 < previousEnd || row.t1 > s.durSec * 1000L + 1000L)
+ throw new IllegalArgumentException("The detailed recording has inconsistent timing");
+ previousEnd = row.t1;
+ if (!row.hasValues() || row.span() == 0) continue;
+ if (!row.confirmed) { draft.warnings.add("An unconfirmed pump change is excluded from the set breakdown."); continue; }
+ if (row.up <= 0) { draft.warnings.add("A zero-pressure part is excluded from the work breakdown."); continue; }
+ }
+ for (GrowthTrackTiming.Span span : GrowthTrackTiming.read(run, snap, length)) {
+ AsRun.Row row = span.row;
+ long holdMs = span.holdMs;
+ String method = length ? "length_pumping" : methodForHoldMillis(holdMs);
+ String key = row.stageIdx + ":" + row.pos + ":" + row.setId + ":" + method + ":" + holdMs;
+ Long before = durations.get(key);
+ durations.put(key, (before == null ? 0L : before) + span.workMs);
+ String label = "Recorded set " + (row.pos + 1);
+ if (snap != null && row.stageIdx >= 0 && row.stageIdx < snap.stages.size()) {
+ Model.AsRunSnapshot.StageSnap stage = snap.stages.get(row.stageIdx);
+ Model.AsRunSnapshot.SetSnap set = stage.setAt(row.pos);
+ label = stage.name + (set != null && set.name != null && !set.name.isEmpty() ? " / " + set.name : "");
+ }
+ names.put(key, label);
+ holds.put(key, holdMs); methods.put(key, method);
+ }
+ int total = 0;
+ for (String key : durations.keySet()) {
+ int seconds = (int) (durations.get(key) / 1000L);
+ draft.parts.add(new Part(names.get(key), durations.get(key), holds.get(key), methods.get(key))); total += seconds;
+ }
+ if (draft.parts.size() > 500 || total > draft.seconds) throw new IllegalArgumentException("The recorded set breakdown exceeds GrowthTrack's limits");
+ if (draft.parts.isEmpty()) throw new IllegalArgumentException("No confirmed positive-pressure work exists to send");
+ draft.warnings.add(length ? "The structured Length track overrides hold-duration labels for every part." : "Techniques use confirmed command intervals, clipped to delivered recording time and joined across verified stitch boundaries: up to 6 s Milking; up to 30 s RIP; up to 120 s Interval pumping; longer Static pumping. Release/rest do not affect this label.");
+ draft.warnings.add("Set durations retain recorded work spans, including their release halves. Separate rest and interrupted periods are excluded. Measured net time under pressure excludes release/rest; gross sealed time is not substituted.");
+ draft.warnings.add("Command phases are reconstructed from confirmed holds/releases and elapsed spans, not sampled pressure plateaus. Ambiguous paused, lost-link or unverified stitched recordings are unavailable for automatic export. No measured plateau or pressure average is invented. GrowthTrack's whole-second durations round down; subsecond set duration is left unknown.");
+ return draft;
+ }
+ private static String iso(long millis) {
+ SimpleDateFormat f = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", Locale.ROOT);
+ f.setTimeZone(TimeZone.getTimeZone("UTC")); return f.format(new java.util.Date(millis));
+ }
+}
diff --git a/core/src/main/java/org/openpump/GrowthTrackTiming.java b/core/src/main/java/org/openpump/GrowthTrackTiming.java
new file mode 100644
index 0000000..115df35
--- /dev/null
+++ b/core/src/main/java/org/openpump/GrowthTrackTiming.java
@@ -0,0 +1,73 @@
+package org.openpump;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/** Reads confirmed command intervals; it does not infer measured pressure plateaus. */
+final class GrowthTrackTiming {
+ static final class Span {
+ final AsRun.Row row; final long workMs, holdMs;
+ Span(AsRun.Row row, long workMs, long holdMs) { this.row = row; this.workMs = workMs; this.holdMs = holdMs; }
+ }
+ static List read(AsRun run, Model.AsRunSnapshot snap, boolean length) {
+ List out = new ArrayList();
+ List planned = Model.planFromSnapshot(snap);
+ long carryHold = 0, carryWork = 0;
+ AsRun.Row previous = null, carryRow = null;
+ for (AsRun.Row row : run.rows) {
+ if (row.kind == AsRun.SKIPPED) continue;
+ if (!length && row.span() > 0 && (row.kind == AsRun.HOLD || row.kind == AsRun.LOST))
+ throw unknown("a pause or lost link does not retain the pressure-phase timeline");
+ if (!row.hasValues() || row.span() == 0 || !row.confirmed || row.up <= 0) {
+ if (carryHold > 0) throw unknown("a stitch continuation is missing or unconfirmed");
+ continue;
+ }
+ if (length) { out.add(new Span(row, row.span(), 0)); continue; }
+ if (row.uhWire <= 0 || row.lh < 0) throw unknown("a positive upper hold is unavailable");
+ int part = part(row, planned);
+ if (part < 0 && row.uhWire == Proto.WIRE_HOLD_MAX && row.lh == 1 && row.lo == row.up - 1)
+ throw unknown("this older wire-sized hold has no verified stitch boundary");
+ if (carryHold > 0 && (previous == null || row.t0 != previous.t1 || row.up != previous.up
+ || row.stageIdx != previous.stageIdx || row.pos != previous.pos || !row.setId.equals(previous.setId)
+ || row.ordinal != previous.ordinal + 1 || row.kind != AsRun.PLAN))
+ throw unknown("a stitched hold was interrupted or changed");
+ if (part == 1) {
+ if (row.kind != AsRun.PLAN || row.uhWire != Proto.WIRE_HOLD_MAX || row.lh != 1
+ || row.lo != row.up - 1 || row.span() > row.uhWire * 1000L)
+ throw unknown("the delivered stitch no longer matches its recorded boundary");
+ if (carryRow == null) carryRow = row;
+ carryHold += row.span(); carryWork += row.span(); previous = row;
+ continue;
+ }
+ long upper = row.uhWire * 1000L, release = row.lh * 1000L;
+ if (release == 0) {
+ // With no release the positive command is continuous across device repeats.
+ out.add(new Span(carryRow == null ? row : carryRow, carryWork + row.span(), carryHold + row.span()));
+ } else {
+ long remaining = row.span();
+ while (remaining > 0) {
+ long held = Math.min(remaining, upper);
+ long work = Math.min(remaining, upper + release);
+ out.add(new Span(carryRow == null ? row : carryRow, carryWork + work, carryHold + held));
+ carryHold = 0; carryWork = 0; carryRow = null;
+ remaining -= work;
+ }
+ }
+ carryHold = 0; carryWork = 0; carryRow = null; previous = row;
+ }
+ // A stopped final chunk retains only its recorded, clipped hold duration.
+ if (carryHold > 0) out.add(new Span(carryRow, carryWork, carryHold));
+ return out;
+ }
+ private static int part(AsRun.Row row, List plan) {
+ if (row.cyclePart >= 0) return row.cyclePart;
+ if (row.kind != AsRun.PLAN) return -1;
+ for (Model.Preset p : plan) if (p.stageIdx == row.stageIdx && p.pos == row.pos && p.ordinal == row.ordinal
+ && p.setId.equals(row.setId) && p.uh == row.uhWire && p.uh == row.uhReq && p.lh == row.lh)
+ return p.cyclePart ? 1 : 0;
+ return -1;
+ }
+ private static IllegalArgumentException unknown(String reason) {
+ return new IllegalArgumentException("Automatic technique unavailable: " + reason + ". This recording cannot be sent.");
+ }
+}
diff --git a/core/src/main/java/org/openpump/Model.java b/core/src/main/java/org/openpump/Model.java
index 970d8c5..c83cef8 100644
--- a/core/src/main/java/org/openpump/Model.java
+++ b/core/src/main/java/org/openpump/Model.java
@@ -4688,6 +4688,10 @@ private static int b64Val(char c) {
*/
public static final class AsRunSnapshot {
public String routineId = "";
+ /** Frozen structured track for connected-app classification. -1 means an old
+ * snapshot did not record it; 0 is a known unmarked routine. Never inferred
+ * from the routine/stage names or a later edited routine. */
+ public int trainerTrack = -1;
public final List stages = new ArrayList();
/** One stage as it stood at run start: its name, the set ids it held, in order, and
@@ -4814,6 +4818,7 @@ public static AsRunSnapshot of(Routine r, Model m) {
if (r == null) return null;
AsRunSnapshot s = new AsRunSnapshot();
s.routineId = r.id == null ? "" : r.id;
+ s.trainerTrack = r.trainerTrack;
for (int i = 0; i < r.stages.size(); i++) {
Stage src = r.stages.get(i);
StageSnap st = new StageSnap();
@@ -4874,6 +4879,7 @@ public boolean matches(Routine r, Model m) {
public JSONObject toJson() throws JSONException {
JSONObject o = new JSONObject();
o.put("rid", routineId);
+ if (trainerTrack >= 0) o.put("trainerTrack", trainerTrack);
JSONArray a = new JSONArray();
for (int i = 0; i < stages.size(); i++) {
StageSnap st = stages.get(i);
@@ -4898,6 +4904,8 @@ public static AsRunSnapshot fromJson(JSONObject o) {
if (o == null) return null;
AsRunSnapshot s = new AsRunSnapshot();
s.routineId = o.optString("rid", "");
+ s.trainerTrack = o.optInt("trainerTrack", -1);
+ if (s.trainerTrack < -1 || s.trainerTrack > 4) s.trainerTrack = -1;
JSONArray a = o.optJSONArray("stages");
if (a != null) for (int i = 0; i < a.length(); i++) {
JSONObject so = a.optJSONObject(i);
@@ -4942,7 +4950,12 @@ public static AsRunSnapshot fromJson(JSONObject o) {
public static final class Sess {
public String id;
public String routineId, routineName;
- public long ts; // epoch millis at filing
+ public long ts; // legacy day/key stamp; old releases filed end, current releases start
+ /** Explicit wall-clock boundaries for optional partner export. Zero means unknown;
+ * never infer the meaning of an old ts or reconstruct gaps between rejoined parts. */
+ public long recordedStartMs, recordedEndMs;
+ /** Non-secret browser-grant identity captured at filing; empty records never enter sync. */
+ public String growthTrackConnectionId = "";
public long durSec; // the SAME elapsed the summary displayed
public boolean completed; // false = stopped early (an attempt)
/** True when this was a MANUAL run (Task 18) — an ephemeral cycle, not a routine.
@@ -5419,6 +5432,9 @@ public JSONObject toJson() throws JSONException {
// keeps the phone and the self-test on the same code path.
o.put("ts", String.valueOf(ts));
o.put("dur", String.valueOf(durSec));
+ if (recordedStartMs > 0) o.put("recordedStartMs", String.valueOf(recordedStartMs));
+ if (recordedEndMs > 0) o.put("recordedEndMs", String.valueOf(recordedEndMs));
+ if (!growthTrackConnectionId.isEmpty()) o.put("growthTrackConnectionId", growthTrackConnectionId);
o.put("done", completed);
o.put("man", manual);
o.put("tag", tag == null ? "" : tag);
@@ -5535,6 +5551,9 @@ public static Sess fromJson(JSONObject o) {
s.countedTrack = o.optInt("countedTrack", TRAINER_TRACK_NONE);
s.routineName = o.optString("rname", "");
s.ts = parseLong(o.optString("ts", "0"));
+ s.recordedStartMs = parseLong(o.optString("recordedStartMs", "0"));
+ s.recordedEndMs = parseLong(o.optString("recordedEndMs", "0"));
+ s.growthTrackConnectionId = o.optString("growthTrackConnectionId", "");
s.durSec = parseLong(o.optString("dur", "0"));
s.completed = o.optBoolean("done");
// Absent (false) on every session filed before Task 18 — a routine run, which is
@@ -7986,6 +8005,8 @@ public static int clampRunStripWhere(int w) {
* restarting it; see {@link FirstRun}.
*/
public int firstRun = FirstRun.DONE;
+ /** Old phones have already set up; only seed creates an unshown optional invitation. */
+ public boolean growthTrackOfferSeen = true;
/** "Whole app" — gates the COLD OPEN only (the very first content this Activity shows
* after a fresh launch), never re-checked for the rest of that process's lifetime.
* See AppLock#isLocked's own doc for why this scope's re-lock rule differs from the
@@ -11645,6 +11666,7 @@ public static double actualRatePerYear(long fromTs, double fromCm,
/** What a brand-new install starts with. Nothing here is required to be kept. */
public static Model seed() {
Model m = new Model();
+ m.growthTrackOfferSeen = false;
m.firstRun = FirstRun.NOT_STARTED; // the one place a setup is ever owed
// One example per distinct behaviour the pump can run, so a fresh install shows what
// each mode is rather than an empty library. All well inside the default 40 kPa
@@ -11747,6 +11769,7 @@ public String toJson() {
o.put("blur", privacyBlur);
o.put("lockOn", appLockOn);
o.put("firstRun", firstRun);
+ o.put("growthTrackOfferSeen", growthTrackOfferSeen);
o.put("lockWhole", appLockWholeApp);
o.put("lockPhotos", appLockPhotos);
o.put("lockMeas", appLockMeasurements);
@@ -12136,6 +12159,7 @@ public static Model fromJson(String s) {
m.appLockOn = o.optBoolean("lockOn", false);
// MIGRATION: absent in every file written before the first-run setup existed, and
// those phones are all set up already - so absent means DONE, never "not started".
+ m.growthTrackOfferSeen = o.optBoolean("growthTrackOfferSeen", true);
m.firstRun = Math.max(FirstRun.NOT_STARTED,
Math.min(FirstRun.DONE, o.optInt("firstRun", FirstRun.DONE)));
m.appLockWholeApp = o.optBoolean("lockWhole", false);
diff --git a/core/src/test/java/Migrate.java b/core/src/test/java/Migrate.java
index e845ca9..275c3e7 100644
--- a/core/src/test/java/Migrate.java
+++ b/core/src/test/java/Migrate.java
@@ -4,6 +4,42 @@
public class Migrate {
// `throws Exception` only for the org.json constructor below, which is checked.
public static void main(String[] a) throws Exception {
+ // GrowthTrack: old snapshots have no recorded designation, while new snapshots
+ // freeze the structured track and keep it through later routine edits/deletion.
+ Model.AsRunSnapshot gtOld = Model.AsRunSnapshot.fromJson(
+ new org.json.JSONObject("{\"rid\":\"legacy\",\"stages\":[]}"));
+ if (gtOld.trainerTrack != -1 || gtOld.toJson().has("trainerTrack"))
+ throw new AssertionError("Old track metadata must remain unknown");
+ Model.Routine gtRoutine = new Model.Routine(); gtRoutine.id = "gt-fixture";
+ gtRoutine.trainerTrack = org.openpump.Plan.TRACK_LENGTH;
+ Model.AsRunSnapshot gtFrozen = Model.AsRunSnapshot.of(gtRoutine, new Model());
+ gtRoutine.trainerTrack = Model.TRAINER_TRACK_NONE;
+ if (Model.AsRunSnapshot.fromJson(gtFrozen.toJson()).trainerTrack != org.openpump.Plan.TRACK_LENGTH
+ || Model.AsRunSnapshot.fromJson(Model.AsRunSnapshot.of(gtRoutine, new Model()).toJson()).trainerTrack != 0)
+ throw new AssertionError("Frozen Length and known unmarked metadata must round-trip");
+ System.out.println("GrowthTrack snapshot: old unknown / frozen Length / known unmarked preserved");
+
+ org.openpump.AsRun.Row gtOldRow = org.openpump.AsRun.Row.fromJson(new org.json.JSONObject());
+ if (gtOldRow.cyclePart != -1 || gtOldRow.toJson().has("cyclePart")) throw new AssertionError("Old stitch boundary must remain unknown");
+ gtOldRow.cyclePart = 1;
+ if (org.openpump.AsRun.Row.fromJson(gtOldRow.toJson()).cyclePart != 1) throw new AssertionError("Frozen stitch boundary must round-trip");
+ Model gtFresh = Model.seed();
+ if (gtFresh.growthTrackOfferSeen || !Model.fromJson("{\"sets\":[],\"routines\":[]}").growthTrackOfferSeen) throw new AssertionError("Optional invitation migration must never nag upgrades");
+ org.openpump.GrowthTrackOnboarding.presented(gtFresh);
+ if (!Model.fromJson(gtFresh.toJson()).growthTrackOfferSeen) throw new AssertionError("Invitation dismissal must round-trip");
+ System.out.println("GrowthTrack timing/onboarding: unknown old boundaries, frozen new boundaries, one-time offer preserved");
+
+ Model.Sess gtLegacyTime = Model.Sess.fromJson(new org.json.JSONObject("{\"ts\":\"1700000000000\",\"dur\":\"120\"}"));
+ if (gtLegacyTime.recordedStartMs != 0 || gtLegacyTime.recordedEndMs != 0) throw new AssertionError("Old wall-clock boundaries must not be invented");
+ gtLegacyTime.recordedStartMs = 1700000000000L; gtLegacyTime.recordedEndMs = 1700000120000L;
+ Model.Sess gtTimeRoundTrip = Model.Sess.fromJson(gtLegacyTime.toJson());
+ if (gtTimeRoundTrip.recordedStartMs != gtLegacyTime.recordedStartMs || gtTimeRoundTrip.recordedEndMs != gtLegacyTime.recordedEndMs) throw new AssertionError("Explicit wall-clock boundaries must round-trip");
+
+ if (!gtLegacyTime.growthTrackConnectionId.isEmpty()) throw new AssertionError("Legacy history must not opt into sync");
+ gtLegacyTime.growthTrackConnectionId = "fictional-browser-grant";
+ if (!Model.Sess.fromJson(gtLegacyTime.toJson()).growthTrackConnectionId.equals(gtLegacyTime.growthTrackConnectionId))
+ throw new AssertionError("Completion grant marker must round-trip for crash recovery");
+
// EXACTLY what build 30 (pre-stage) wrote to model.json
String old = "{\"ceil\":40,\"unit\":\"inHg\",\"selected\":\"r1\","
+ "\"sets\":[{\"id\":\"s1\",\"name\":\"Gentle Warm\",\"ramp\":false,\"up\":14,"
diff --git a/core/src/test/java/org/openpump/GrowthTrackAutoSyncTest.java b/core/src/test/java/org/openpump/GrowthTrackAutoSyncTest.java
new file mode 100644
index 0000000..40206e4
--- /dev/null
+++ b/core/src/test/java/org/openpump/GrowthTrackAutoSyncTest.java
@@ -0,0 +1,116 @@
+package org.openpump;
+
+import static org.junit.jupiter.api.Assertions.*;
+import java.io.IOException;
+import org.json.JSONArray;
+import org.json.JSONObject;
+import org.junit.jupiter.api.Test;
+
+/** Fictional completion events, encrypted-store seam and mocked HTTP only. */
+class GrowthTrackAutoSyncTest {
+ private final GrowthTrackIntegrationTest.Clock clock = new GrowthTrackIntegrationTest.Clock();
+ private static AsRun run() {
+ AsRun run = new AsRun(); run.rows.add(GrowthTrackIntegrationTest.row(AsRun.PLAN, 0, 120_000, 0)); return run;
+ }
+ private static boolean complete(GrowthTrackIntegrationTest.Fixture f, String id) throws Exception {
+ return f.client.recordCompleted(GrowthTrackIntegrationTest.session(id), run(), new Model(), f.client.snapshot().connectionId);
+ }
+ @Test void connectedCompletionQueuesThenSyncsWithoutReviewOrSelection() throws Exception {
+ GrowthTrackIntegrationTest.Fixture f = new GrowthTrackIntegrationTest.Fixture(false);
+ f.http.acceptAll = true;
+ assertTrue(complete(f, "one")); assertEquals(1, f.client.snapshot().queued);
+ f.client.syncPending(); assertEquals(0, f.client.snapshot().queued);
+ assertEquals(1, f.http.requests.size()); assertTrue(f.client.receipt("op_one").startsWith("Received"));
+ }
+ @Test void everyDistinctCompletionAppendsEvenWithOtherSessionsPending() throws Exception {
+ GrowthTrackIntegrationTest.Fixture f = new GrowthTrackIntegrationTest.Fixture(false);
+ assertTrue(complete(f, "one")); assertTrue(complete(f, "two")); assertEquals(2, f.client.snapshot().queued);
+ f.http.acceptAll = true; f.client.syncPending();
+ assertEquals(2, new JSONObject(f.http.requests.get(0).body).getJSONArray("sessions").length());
+ }
+ @Test void duplicateCompletionBeforeAndAfterReceiptNeverCreatesAnotherTransfer() throws Exception {
+ GrowthTrackIntegrationTest.Fixture f = new GrowthTrackIntegrationTest.Fixture(false); f.http.acceptAll = true;
+ assertTrue(complete(f, "one")); assertFalse(complete(f, "one")); assertEquals(1, f.client.snapshot().queued);
+ f.client.syncPending(); assertFalse(complete(f, "one")); f.client.syncPending(); assertEquals(1, f.http.requests.size());
+ }
+ @Test void disconnectedCompletionAndPreconnectionHistoryNeverQueue() throws Exception {
+ GrowthTrackIntegrationTest.Storage store = new GrowthTrackIntegrationTest.Storage();
+ GrowthTrackIntegrationTest.Http http = new GrowthTrackIntegrationTest.Http();
+ GrowthTrackClient client = new GrowthTrackClient(store, http, clock);
+ assertFalse(client.recordCompleted(GrowthTrackIntegrationTest.session("before"), run(), new Model(), ""));
+ assertEquals(-1, client.automaticRetryAt()); client.syncPending(); assertTrue(http.requests.isEmpty());
+ GrowthTrackIntegrationTest.Fixture f = new GrowthTrackIntegrationTest.Fixture(false);
+ assertFalse(f.client.recordCompleted(GrowthTrackIntegrationTest.session("before"), run(), new Model(), ""));
+ assertEquals(0, f.client.snapshot().queued);
+ }
+ @Test void offlineQueueRestartsAndRetriesAfterDurableBackoff() throws Exception {
+ GrowthTrackIntegrationTest.Fixture f = new GrowthTrackIntegrationTest.Fixture(false); complete(f, "one");
+ f.http.responses.add(new IOException("fictional offline")); assertThrows(IOException.class, f.client::syncPending);
+ long retryAt = f.client.automaticRetryAt(); assertTrue(retryAt > f.clock.now());
+ GrowthTrackClient restarted = new GrowthTrackClient(f.storage, f.http, f.clock);
+ assertEquals(retryAt, restarted.automaticRetryAt()); restarted.syncPending(); assertEquals(1, f.http.requests.size());
+ f.clock.time = retryAt; f.http.acceptAll = true; restarted.syncPending();
+ assertEquals(0, restarted.snapshot().queued); assertEquals(2, f.http.requests.size());
+ assertEquals("op_one", new JSONObject(f.http.requests.get(1).body).getJSONArray("sessions").getJSONObject(0).getString("external_session_id"));
+ }
+ @Test void filingMarkerRecoversCompletionLostBeforeEncryptedQueueSave() throws Exception {
+ GrowthTrackIntegrationTest.Fixture f = new GrowthTrackIntegrationTest.Fixture(false);
+ Model.Sess saved = GrowthTrackIntegrationTest.session("crash"); saved.growthTrackConnectionId = f.client.snapshot().connectionId;
+ saved = Model.Sess.fromJson(saved.toJson());
+ GrowthTrackClient restarted = new GrowthTrackClient(f.storage, f.http, f.clock);
+ assertTrue(restarted.recordCompleted(saved, run(), new Model(), saved.growthTrackConnectionId));
+ f.http.acceptAll = true; restarted.syncPending(); assertTrue(restarted.receipt("op_crash").startsWith("Received"));
+ }
+ @Test void relinkDiscardsQueueAndNeverClaimsOldOrDisconnectedCompletions() throws Exception {
+ GrowthTrackIntegrationTest.Fixture f = new GrowthTrackIntegrationTest.Fixture(false); String old = f.client.snapshot().connectionId;
+ complete(f, "old"); f.client.begin(false); assertEquals(0, f.client.snapshot().queued);
+ f.http.responses.add(GrowthTrackIntegrationTest.token(GrowthTrackIntegrationTest.R2, false));
+ String state = f.storage.saved.getJSONObject("pending").getString("state");
+ f.client.callback(GrowthTrackProtocol.REDIRECT + "?code=" + GrowthTrackIntegrationTest.CODE + "&state=" + state);
+ assertNotEquals(old, f.client.snapshot().connectionId);
+ assertFalse(f.client.recordCompleted(GrowthTrackIntegrationTest.session("old"), run(), new Model(), old));
+ assertFalse(f.client.recordCompleted(GrowthTrackIntegrationTest.session("disconnected"), run(), new Model(), ""));
+ assertEquals(0, f.client.snapshot().queued); assertTrue(complete(f, "new"));
+ }
+ @Test void disconnectDuringTransferStopsRemainingBatchesAndRecovery() throws Exception {
+ GrowthTrackIntegrationTest.Fixture f = new GrowthTrackIntegrationTest.Fixture(false);
+ for (int i = 0; i < 101; i++) complete(f, "record" + i);
+ String old = f.client.snapshot().connectionId; f.http.acceptAll = true;
+ f.http.beforeReturn = () -> { try { f.client.disconnect(); } catch (IOException e) { throw new AssertionError(e); } };
+ assertThrows(IOException.class, f.client::syncPending); assertEquals(1, f.http.requests.size());
+ assertFalse(f.client.snapshot().connected); assertEquals(0, f.client.snapshot().queued);
+ assertFalse(f.client.recordCompleted(GrowthTrackIntegrationTest.session("late"), run(), new Model(), old));
+ }
+ @Test void simulatedInvalidAndUnsupportedRecordsHaveDurableFailureStatuses() throws Exception {
+ GrowthTrackIntegrationTest.Fixture f = new GrowthTrackIntegrationTest.Fixture(false); String grant = f.client.snapshot().connectionId;
+ Model.Sess sim = GrowthTrackIntegrationTest.session("sim"); sim.sim = true;
+ assertFalse(f.client.recordCompleted(sim, run(), new Model(), grant));
+ Model.Sess invalid = GrowthTrackIntegrationTest.session("invalid"); invalid.recordedEndMs = 0;
+ assertFalse(f.client.recordCompleted(invalid, run(), new Model(), grant));
+ assertFalse(f.client.recordCompleted(GrowthTrackIntegrationTest.session("unsupported"), null, new Model(), grant));
+ assertEquals(0, f.client.snapshot().queued); assertTrue(f.http.requests.isEmpty());
+ GrowthTrackClient restarted = new GrowthTrackClient(f.storage, f.http, f.clock);
+ for (String id : new String[]{"sim", "invalid", "unsupported"}) assertTrue(restarted.receipt("op_" + id).startsWith("Not synced:"));
+ }
+ @Test void partialFailureRetainsOnlyTransientRecordAndRetriesAutomatically() throws Exception {
+ GrowthTrackIntegrationTest.Fixture f = new GrowthTrackIntegrationTest.Fixture(false);
+ complete(f, "sent"); complete(f, "later"); complete(f, "bad");
+ JSONArray rejected = new JSONArray().put(new JSONObject().put("external_session_id", "op_later").put("reason", "Insert failed"))
+ .put(new JSONObject().put("external_session_id", "op_bad").put("reason", "Invalid fixture field"));
+ f.http.responses.add(GrowthTrackIntegrationTest.ok(1, 0, rejected)); f.client.syncPending();
+ assertEquals(1, f.client.snapshot().queued); assertTrue(f.client.receipt("op_bad").startsWith("Needs review"));
+ assertFalse(complete(f, "bad")); f.clock.time = f.client.automaticRetryAt(); f.http.acceptAll = true; f.client.syncPending();
+ assertEquals("op_later", new JSONObject(f.http.requests.get(1).body).getJSONArray("sessions").getJSONObject(0).getString("external_session_id"));
+ }
+ @Test void permissionFailurePausesRatherThanSpinningBackgroundRequests() throws Exception {
+ GrowthTrackIntegrationTest.Fixture f = new GrowthTrackIntegrationTest.Fixture(false); complete(f, "one");
+ f.http.responses.add(new GrowthTrackClient.Response(403, "{}")); assertThrows(IOException.class, f.client::syncPending);
+ assertTrue(f.client.snapshot().paused); assertEquals(-1, f.client.automaticRetryAt());
+ f.client.syncPending(); assertEquals(1, f.http.requests.size()); assertEquals(1, f.client.snapshot().queued);
+ }
+ @Test void manualConsentFromOlderBuildMustReconnectBeforeAutoSync() throws Exception {
+ GrowthTrackIntegrationTest.Fixture f = new GrowthTrackIntegrationTest.Fixture(false); f.storage.saved.remove("automatic_sync");
+ GrowthTrackClient restarted = new GrowthTrackClient(f.storage, f.http, f.clock);
+ assertFalse(restarted.snapshot().connected); assertEquals(-1, restarted.automaticRetryAt());
+ }
+}
diff --git a/core/src/test/java/org/openpump/GrowthTrackIntegrationTest.java b/core/src/test/java/org/openpump/GrowthTrackIntegrationTest.java
new file mode 100644
index 0000000..a48793e
--- /dev/null
+++ b/core/src/test/java/org/openpump/GrowthTrackIntegrationTest.java
@@ -0,0 +1,430 @@
+package org.openpump;
+
+import static org.junit.jupiter.api.Assertions.*;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Deque;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import org.json.JSONArray;
+import org.json.JSONObject;
+import org.junit.jupiter.api.Test;
+
+/** Only fictional records and mocked HTTP/storage. These tests cannot reach GrowthTrack. */
+class GrowthTrackIntegrationTest {
+ static final String A = "gta_" + "a".repeat(43), R = "gtr_" + "r".repeat(43), R2 = "gtr_" + "s".repeat(43);
+ static final String CODE = "gtc_" + "c".repeat(43);
+ static class Clock implements GrowthTrackClient.Clock { long time = 1_700_000_000_000L; public long now() { return time; } }
+ static class Storage implements GrowthTrackClient.Store {
+ JSONObject saved = new JSONObject(); boolean fail;
+ public JSONObject read() throws IOException { try { return new JSONObject(saved.toString()); } catch (Exception e) { throw new IOException(); } }
+ public void write(JSONObject state) throws IOException { if (fail) throw new IOException("fixture storage failure"); try { saved = new JSONObject(state.toString()); } catch (Exception e) { throw new IOException(); } }
+ }
+ static class Request {
+ final String method, path, body; final Map headers;
+ Request(String method, String path, Map headers, String body) { this.method = method; this.path = path; this.headers = headers; this.body = body; }
+ }
+ static class Http implements GrowthTrackClient.Transport {
+ final Deque
- 
+ 
