@agentprojectcontext/apx 1.81.0 → 1.89.1

package/src/interfaces/android/app/src/main/java/dev/agentprojectcontext/apx/DaemonClient.java

@@ -0,0 +1,339 @@
+package dev.agentprojectcontext.apx;
+
+import android.net.Uri;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.io.IOException;
+
+import okhttp3.Call;
+import okhttp3.Callback;
+import okhttp3.MediaType;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.RequestBody;
+import okhttp3.Response;
+import android.util.Log;
+
+final class DaemonClient {
+    private static final String TAG = "APXTravel";
+    interface PairCallback {
+        void onSuccess(String token);
+        void onError(String message);
+    }
+
+    /** One row of "what APX is watching for on this trip". */
+    /**
+     * One errand on the current trip. `options` is how many shops could still
+     * satisfy it — "buy bread" is a choice between supermarkets until the owner
+     * settles it, and a list that hid that would be claiming a decision APX has
+     * not made.
+     */
+    record TripPlace(
+        String taskId,
+        String place,
+        String task,
+        int distanceM,
+        String mapsUrl,
+        String addStopUrl,
+        int options,
+        boolean locked,
+        String answer
+    ) {}
+
+    interface TripCallback {
+        void onTrip(java.util.List<TripPlace> places);
+        void onError(String message);
+    }
+
+    private static final MediaType JSON = MediaType.get("application/json; charset=utf-8");
+    static final OkHttpClient HTTP = new OkHttpClient.Builder().retryOnConnectionFailure(true).build();
+
+    private DaemonClient() {}
+
+    static void pair(String daemonUrl, String pairingId, String label, PairCallback callback) {
+        JSONObject payload = new JSONObject();
+        try {
+            payload.put("pairing_id", pairingId);
+            payload.put("label", label);
+            payload.put("kind", "android");
+        } catch (JSONException error) {
+            callback.onError("No pude preparar pairing.");
+            return;
+        }
+
+        Request request = new Request.Builder()
+            .url(daemonUrl + "/api/pair/confirm")
+            .post(RequestBody.create(payload.toString(), JSON))
+            .build();
+        HTTP.newCall(request).enqueue(new Callback() {
+            @Override
+            public void onFailure(Call call, IOException error) {
+                callback.onError("Daemon inaccesible: " + error.getMessage());
+            }
+
+            @Override
+            public void onResponse(Call call, Response response) {
+                try (response) {
+                    String body = response.body() == null ? "" : response.body().string();
+                    JSONObject json = body.isBlank() ? new JSONObject() : new JSONObject(body);
+                    if (!response.isSuccessful()) {
+                        callback.onError(json.optString("error", "HTTP " + response.code()));
+                        return;
+                    }
+                    String token = json.optString("token", "");
+                    if (token.isBlank()) {
+                        callback.onError("Daemon no devolvió token.");
+                        return;
+                    }
+                    callback.onSuccess(token);
+                } catch (Exception error) {
+                    callback.onError("Respuesta inválida: " + error.getMessage());
+                }
+            }
+        });
+    }
+
+    /**
+     * The errands APX is watching on the active trip, for the banner's list.
+     * Read-only: asking never fires a reminder — see host/daemon/api/mobility.js.
+     */
+    static void fetchTripPlaces(String daemonUrl, String token, TripCallback callback) {
+        if (daemonUrl == null || daemonUrl.isBlank() || token == null || token.isBlank()) {
+            callback.onError("Este teléfono todavía no está vinculado.");
+            return;
+        }
+        Request request = new Request.Builder()
+            .url(daemonUrl + "/api/mobility/trip")
+            .header("Authorization", "Bearer " + token)
+            .get()
+            .build();
+        HTTP.newCall(request).enqueue(new Callback() {
+            @Override
+            public void onFailure(Call call, IOException error) {
+                callback.onError("No pude hablar con el daemon: " + error.getMessage());
+            }
+
+            @Override
+            public void onResponse(Call call, Response response) {
+                try (response) {
+                    String body = response.body() == null ? "" : response.body().string();
+                    if (!response.isSuccessful()) {
+                        callback.onError("El daemon respondió HTTP " + response.code());
+                        return;
+                    }
+                    JSONObject json = new JSONObject(body);
+                    org.json.JSONArray rows = json.optJSONArray("places");
+                    java.util.List<TripPlace> places = new java.util.ArrayList<>();
+                    for (int i = 0; rows != null && i < rows.length(); i++) {
+                        JSONObject row = rows.optJSONObject(i);
+                        if (row == null) continue;
+                        places.add(new TripPlace(
+                            row.optString("task_id", ""),
+                            row.optString("place", ""),
+                            row.optString("task", ""),
+                            row.optInt("distance_m", -1),
+                            row.optString("maps_url", ""),
+                            row.optString("add_stop_url", ""),
+                            row.optInt("options", 1),
+                            row.optBoolean("locked", false),
+                            row.isNull("answer") ? "" : row.optString("answer", "")
+                        ));
+                    }
+                    callback.onTrip(places);
+                } catch (Exception error) {
+                    callback.onError("Respuesta inválida: " + error.getMessage());
+                }
+            }
+        });
+    }
+
+    /**
+     * Answer one errand from the phone's own list — the same "voy" / "hoy no"
+     * the Telegram card asks, reaching the same record on the daemon. Silent
+     * on success: the list has already redrawn optimistically, and a toast per
+     * tap while driving is noise.
+     */
+    static void answerErrand(String daemonUrl, String token, String taskId, String answer, AnswerCallback callback) {
+        if (daemonUrl == null || daemonUrl.isBlank() || token == null || token.isBlank()) {
+            callback.onAnswerFailed("Este teléfono todavía no está vinculado.");
+            return;
+        }
+        JSONObject payload = new JSONObject();
+        try {
+            payload.put("task_id", taskId);
+            payload.put("answer", answer);
+        } catch (JSONException error) {
+            callback.onAnswerFailed("No pude preparar la respuesta.");
+            return;
+        }
+        Request request = new Request.Builder()
+            .url(daemonUrl + "/api/mobility/errands/answer")
+            .header("Authorization", "Bearer " + token)
+            .post(RequestBody.create(payload.toString(), JSON))
+            .build();
+        HTTP.newCall(request).enqueue(new Callback() {
+            @Override
+            public void onFailure(Call call, IOException error) {
+                callback.onAnswerFailed("No pude hablar con el daemon: " + error.getMessage());
+            }
+
+            @Override
+            public void onResponse(Call call, Response response) {
+                try (response) {
+                    if (response.isSuccessful()) callback.onAnswered();
+                    else callback.onAnswerFailed("El daemon respondió HTTP " + response.code());
+                }
+            }
+        });
+    }
+
+    /**
+     * Answer a proximity card by ALERT id.
+     *
+     * The sibling of answerErrand above, and they are not the same call:
+     * that one answers "this errand, on this trip" from the phone's own list,
+     * this one answers the specific card that was shown — which is what lets
+     * two alerts be open at once without a tap landing on the wrong one.
+     */
+    static void answerAlert(String daemonUrl, String token, String alertId, String action, AnswerCallback callback) {
+        if (daemonUrl == null || daemonUrl.isBlank() || token == null || token.isBlank()) {
+            callback.onAnswerFailed("Este teléfono todavía no está vinculado.");
+            return;
+        }
+        JSONObject payload = new JSONObject();
+        try {
+            payload.put("action", action);
+        } catch (JSONException error) {
+            callback.onAnswerFailed("No pude preparar la respuesta.");
+            return;
+        }
+        Request request = new Request.Builder()
+            .url(daemonUrl + "/api/mobility/alerts/" + Uri.encode(alertId) + "/answer")
+            .header("Authorization", "Bearer " + token)
+            .post(RequestBody.create(payload.toString(), JSON))
+            .build();
+        HTTP.newCall(request).enqueue(new Callback() {
+            @Override
+            public void onFailure(Call call, IOException error) {
+                callback.onAnswerFailed("No pude hablar con el daemon: " + error.getMessage());
+            }
+
+            @Override
+            public void onResponse(Call call, Response response) {
+                try (response) {
+                    if (response.isSuccessful()) callback.onAnswered();
+                    else callback.onAnswerFailed("El daemon respondió HTTP " + response.code());
+                }
+            }
+        });
+    }
+
+    interface AnswerCallback {
+        void onAnswered();
+        void onAnswerFailed(String message);
+    }
+
+    static void notifyTripStarted(String daemonUrl, String token, String tripId, String destination, DeviceLocation.Snapshot origin) {
+        notifyTripEvent(daemonUrl, token, tripId, "trip.started", destination, origin, true);
+    }
+
+    static void notifyTripContext(String daemonUrl, String token, String tripId, String destination, DeviceLocation.Snapshot origin) {
+        notifyTripEvent(daemonUrl, token, tripId, "trip.started", destination, origin, false);
+    }
+
+    static void notifyTripEnded(String daemonUrl, String token, String tripId) {
+        notifyTripEvent(daemonUrl, token, tripId, "trip.ended", "", null, false);
+    }
+
+    /**
+     * One GPS sample for a running trip. Fire-and-forget by design: the phone
+     * is on mobile data in a moving car and a sample that fails to upload is
+     * replaced by the next one 30 seconds later, so a retry queue would only
+     * deliver stale positions. The daemon answers 202 before it evaluates
+     * anything (host/daemon/api/mobility.js), so this call never waits on a
+     * place search or a Telegram send.
+     */
+    static void reportPosition(String daemonUrl, String token, String tripId, android.location.Location location) {
+        if (daemonUrl == null || daemonUrl.isBlank() || token == null || token.isBlank()) return;
+        if (tripId == null || tripId.isBlank() || location == null) return;
+        JSONObject payload = new JSONObject();
+        try {
+            payload.put("trip_id", tripId);
+            payload.put("latitude", location.getLatitude());
+            payload.put("longitude", location.getLongitude());
+            if (location.hasAccuracy()) payload.put("accuracy_m", location.getAccuracy());
+            if (location.hasSpeed()) payload.put("speed_mps", location.getSpeed());
+            if (location.hasBearing()) payload.put("heading_deg", location.getBearing());
+            payload.put("occurred_at", java.time.Instant.now().toString());
+            payload.put("source", "android");
+        } catch (JSONException error) {
+            Log.w(TAG, "Could not prepare position", error);
+            return;
+        }
+
+        Request request = new Request.Builder()
+            .url(daemonUrl + "/api/mobility/positions")
+            .header("Authorization", "Bearer " + token)
+            .post(RequestBody.create(payload.toString(), JSON))
+            .build();
+        HTTP.newCall(request).enqueue(new Callback() {
+            @Override
+            public void onFailure(Call call, IOException error) {
+                Log.w(TAG, "Could not send trip position: " + error.getMessage());
+            }
+
+            @Override
+            public void onResponse(Call call, Response response) {
+                try (response) {
+                    if (!response.isSuccessful()) Log.w(TAG, "Position rejected: HTTP " + response.code());
+                }
+            }
+        });
+    }
+
+    private static void notifyTripEvent(String daemonUrl, String token, String tripId, String type, String destination, DeviceLocation.Snapshot origin, boolean evaluate) {
+        if (daemonUrl == null || daemonUrl.isBlank() || token == null || token.isBlank()) return;
+        JSONObject payload = new JSONObject();
+        try {
+            payload.put("event_id", java.util.UUID.randomUUID().toString());
+            payload.put("trip_id", tripId == null ? "" : tripId);
+            payload.put("type", type);
+            payload.put("occurred_at", java.time.Instant.now().toString());
+            payload.put("destination", destination == null ? "" : destination);
+            payload.put("evaluate", evaluate);
+            if (origin != null) {
+                JSONObject position = new JSONObject();
+                position.put("latitude", origin.latitude());
+                position.put("longitude", origin.longitude());
+                position.put("accuracy_m", origin.accuracyMeters());
+                position.put("age_ms", origin.ageMs());
+                payload.put("origin", position);
+            }
+        } catch (JSONException error) {
+            Log.w(TAG, "Could not prepare mobility event", error);
+            return;
+        }
+
+        Request request = new Request.Builder()
+            .url(daemonUrl + "/api/mobility/events")
+            .header("Authorization", "Bearer " + token)
+            .post(RequestBody.create(payload.toString(), JSON))
+            .build();
+        HTTP.newCall(request).enqueue(new Callback() {
+            @Override
+            public void onFailure(Call call, IOException error) {
+                Log.w(TAG, "Could not send trip notification", error);
+            }
+
+            @Override
+            public void onResponse(Call call, Response response) {
+                try (response) {
+                    if (response.isSuccessful()) Log.i(TAG, "Mobility event accepted by daemon: " + type);
+                    else Log.w(TAG, "Mobility event rejected: HTTP " + response.code());
+                }
+            }
+        });
+    }
+}

package/src/interfaces/android/app/src/main/java/dev/agentprojectcontext/apx/DeviceLocation.java

@@ -0,0 +1,38 @@
+package dev.agentprojectcontext.apx;
+
+import android.Manifest;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.location.Location;
+import android.location.LocationManager;
+
+final class DeviceLocation {
+    record Snapshot(double latitude, double longitude, float accuracyMeters, long ageMs) {}
+
+    private DeviceLocation() {}
+
+    static Snapshot latest(Context context) {
+        boolean coarse = context.checkSelfPermission(Manifest.permission.ACCESS_COARSE_LOCATION) == PackageManager.PERMISSION_GRANTED;
+        boolean fine = context.checkSelfPermission(Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED;
+        if (!coarse && !fine) return null;
+
+        LocationManager manager = (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);
+        Location newest = null;
+        try {
+            for (String provider : manager.getProviders(true)) {
+                Location candidate = manager.getLastKnownLocation(provider);
+                if (candidate == null) continue;
+                if (newest == null || candidate.getTime() > newest.getTime()) newest = candidate;
+            }
+        } catch (SecurityException ignored) {
+            return null;
+        }
+        if (newest == null) return null;
+        return new Snapshot(
+            newest.getLatitude(),
+            newest.getLongitude(),
+            newest.hasAccuracy() ? newest.getAccuracy() : -1f,
+            Math.max(0L, System.currentTimeMillis() - newest.getTime())
+        );
+    }
+}

package/src/interfaces/android/app/src/main/java/dev/agentprojectcontext/apx/ErrandScreen.java

@@ -0,0 +1,127 @@
+package dev.agentprojectcontext.apx;
+
+import android.content.Intent;
+import android.net.Uri;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.car.app.CarContext;
+import androidx.car.app.CarToast;
+import androidx.car.app.Screen;
+import androidx.car.app.model.Action;
+import androidx.car.app.model.ItemList;
+import androidx.car.app.model.ListTemplate;
+import androidx.car.app.model.Row;
+import androidx.car.app.model.Template;
+
+/**
+ * One errand from the trip's list — the ones NOT in range yet.
+ *
+ * The sibling of AlertScreen, and the difference is what the driver is being
+ * asked. An alert interrupts: "you are passing it, what do you want to do?".
+ * This one was opened on purpose, from a list read at a light, so the useful
+ * verbs are different — go there now, add it to the route, or tick it off
+ * because it is already done.
+ *
+ * "Ya la hice" closes the TASK. It is the reason the list is worth having on
+ * the head unit at all: without it the owner reads what is owed, does it, and
+ * still has to remember to close it on the phone afterwards.
+ */
+final class ErrandScreen extends Screen {
+    private static final String TAG = "APXTravel";
+
+    private final DaemonClient.TripPlace errand;
+
+    ErrandScreen(@NonNull CarContext carContext, @NonNull DaemonClient.TripPlace errand) {
+        super(carContext);
+        this.errand = errand;
+    }
+
+    @Override
+    @NonNull
+    public Template onGetTemplate() {
+        ItemList.Builder items = new ItemList.Builder();
+
+        Row.Builder header = new Row.Builder().setTitle(title());
+        if (errand.place() != null && !errand.place().isBlank()) header.addText(errand.place());
+        items.addItem(header.build());
+
+        if (has(errand.mapsUrl())) {
+            items.addItem(row(R.string.mobility_navigate, () -> navigate(errand.mapsUrl())));
+        }
+        if (has(errand.addStopUrl())) {
+            items.addItem(row(R.string.mobility_add_stop, () -> navigate(errand.addStopUrl())));
+        }
+        items.addItem(row(R.string.car_errand_done, this::markDone));
+
+        return new ListTemplate.Builder()
+            .setSingleList(items.build())
+            .setTitle(title())
+            .setHeaderAction(Action.BACK)
+            .build();
+    }
+
+    private String title() {
+        String task = errand.task();
+        return task == null || task.isBlank() ? errand.place() : task;
+    }
+
+    private static boolean has(String value) {
+        return value != null && !value.isBlank();
+    }
+
+    private Row row(int labelRes, Runnable onClick) {
+        return new Row.Builder()
+            .setTitle(getCarContext().getString(labelRes))
+            .setBrowsable(false)
+            .setOnClickListener(onClick::run)
+            .build();
+    }
+
+    private void markDone() {
+        ApxPreferences preferences = new ApxPreferences(getCarContext());
+        DaemonClient.answerErrand(
+            preferences.daemonUrl(),
+            preferences.token(),
+            errand.taskId(),
+            "done",
+            new DaemonClient.AnswerCallback() {
+                @Override public void onAnswered() {
+                    Log.i(TAG, "errand " + errand.taskId() + " closed from the car");
+                }
+                @Override public void onAnswerFailed(String message) {
+                    // Logged, not surfaced: the driver already tapped and is
+                    // looking at the road. Nothing here pretends it worked.
+                    Log.w(TAG, "closing errand failed: " + message);
+                }
+            }
+        );
+        CarToast.makeText(getCarContext(),
+            getCarContext().getString(R.string.car_ack_done), CarToast.LENGTH_SHORT).show();
+        getScreenManager().pop();
+    }
+
+    /** Answer first, navigate second — the same order the notification uses. */
+    private void navigate(String url) {
+        DaemonClient.answerErrand(
+            new ApxPreferences(getCarContext()).daemonUrl(),
+            new ApxPreferences(getCarContext()).token(),
+            errand.taskId(),
+            "go",
+            new DaemonClient.AnswerCallback() {
+                @Override public void onAnswered() { }
+                @Override public void onAnswerFailed(String message) {
+                    Log.w(TAG, "errand answer failed: " + message);
+                }
+            }
+        );
+        try {
+            getCarContext().startCarApp(new Intent(CarContext.ACTION_NAVIGATE, Uri.parse(url)));
+        } catch (Exception error) {
+            Log.w(TAG, "car navigate refused: " + error.getMessage());
+            CarToast.makeText(getCarContext(),
+                getCarContext().getString(R.string.car_navigate_failed), CarToast.LENGTH_SHORT).show();
+        }
+        getScreenManager().pop();
+    }
+}