@agentprojectcontext/apx 1.81.0 → 1.89.1

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

@@ -0,0 +1,249 @@
+package dev.agentprojectcontext.apx;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.graphics.Path;
+import android.graphics.RectF;
+import android.os.Handler;
+import android.os.Looper;
+import android.view.MotionEvent;
+import android.view.View;
+
+final class MascotView extends View {
+    interface Listener {
+        void onDragStarted();
+        void onMove(float rawX, float rawY, float offsetX, float offsetY);
+        void onDragEnded(boolean cancelled);
+        void onTapped();
+    }
+
+    // This view sits on top of whatever the owner is actually doing, all day.
+    // A frame costs a full software-rendered redraw of a 210x225dp bitmap, and
+    // it used to ask for one every 32 ms forever — thirty of them a second,
+    // over the launcher, over the browser, over a video, from the moment the
+    // app went to the background until the phone was rebooted. That is the
+    // "APX está consumiendo batería" notice, and it bought nothing while
+    // nothing was moving.
+    //
+    // So motion is now a state, not the default: 32 ms frames while the blob
+    // is being dragged, hopping, or showing a message, and between those a
+    // still pose that wakes twice per blink cycle. Idle went from ~31 frames a
+    // second to ~0.4.
+    private static final long FRAME_MS = 32L;
+    private static final long HOP_MS = 520L;
+    private static final long BLINK_CYCLE_MS = 5_400L;
+    private static final long BLINK_MS = 230L;
+
+    private Bitmap body;
+    private MascotBlobCatalog.Preset preset;
+    private final Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG | Paint.FILTER_BITMAP_FLAG);
+    private final Paint textPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
+    private final Handler handler = new Handler(Looper.getMainLooper());
+    private final Listener listener;
+    private String message;
+    private Runnable hideMessage;
+    private float downRawX;
+    private float downRawY;
+    private float offsetX;
+    private float offsetY;
+    private boolean dragged;
+    private boolean dragging;
+    private long hopStarted;
+
+    MascotView(Context context, String avatar, Listener listener) {
+        super(context);
+        this.listener = listener;
+        setAvatar(avatar);
+        textPaint.setColor(Color.WHITE);
+        textPaint.setTextSize(dp(12.5f));
+        textPaint.setTypeface(android.graphics.Typeface.create("sans", android.graphics.Typeface.NORMAL));
+        setLayerType(View.LAYER_TYPE_SOFTWARE, null);
+    }
+
+    void setAvatar(String key) {
+        MascotBlobCatalog.Preset next = MascotBlobCatalog.forKey(key);
+        Bitmap nextBody = BitmapFactory.decodeResource(getResources(), next.drawable);
+        if (nextBody == null) return;
+        preset = next;
+        body = nextBody;
+        invalidate();
+    }
+
+    void showMessage(String value) {
+        message = value == null ? null : value.trim();
+        if (message == null || message.isEmpty()) return;
+        hopStarted = System.currentTimeMillis();
+        if (hideMessage != null) handler.removeCallbacks(hideMessage);
+        long duration = Math.min(9_000, Math.max(3_500, 1_500 + message.length() * 45L));
+        hideMessage = () -> {
+            message = null;
+            invalidate();
+        };
+        handler.postDelayed(hideMessage, duration);
+        invalidate();
+    }
+
+    @Override
+    protected void onDraw(Canvas canvas) {
+        super.onDraw(canvas);
+        long now = System.currentTimeMillis();
+        long hopAge = now - hopStarted;
+        boolean hopping = hopAge >= 0 && hopAge < HOP_MS;
+        // Alive while it is being handled, landing a hop, or speaking; at rest
+        // otherwise. At rest it holds the pose instead of walking and bobbing
+        // through it.
+        boolean lively = dragging || hopping || message != null;
+        float width = getWidth();
+        float bodySize = dp(122);
+        float walk = dragging || !lively ? 0 : (float) (dp(13) * Math.sin(now / 1_035.0));
+        float bob = dragging ? -dp(20) : !lively ? 0 : (float) (-dp(7) * (0.5 + 0.5 * Math.sin(now / 780.0)));
+        float hop = hopping ? (float) (-dp(16) * Math.sin(Math.PI * hopAge / 260.0) * (1.0 - hopAge / 700.0)) : 0;
+        float left = (width - bodySize) / 2f + walk;
+        float top = getHeight() - bodySize - dp(7) + bob + hop;
+
+        paint.setColor(0x50000000);
+        float shadowInset = dragging ? dp(34) : dp(24);
+        int shadowAlpha = dragging ? 0x28000000 : 0x50000000;
+        paint.setColor(shadowAlpha);
+        canvas.drawOval(new RectF(left + shadowInset, getHeight() - dp(17), left + bodySize - shadowInset, getHeight() - dp(5)), paint);
+
+        float tilt = dragging
+            ? (float) (13 + 4 * Math.sin(now / 125.0))
+            : !lively ? 0 : (float) (3 * Math.sin(now / 780.0));
+        float look = !lively ? 0 : (float) (Math.sin(now / 980.0) * 8f);
+        canvas.save();
+        canvas.rotate(tilt, left + bodySize / 2f, top + bodySize * 0.88f);
+        paint.setColor(Color.WHITE);
+        canvas.drawBitmap(body, null, new RectF(left, top, left + bodySize, top + bodySize), paint);
+        drawEyes(canvas, left, top, bodySize, now, look);
+        canvas.restore();
+        if (message != null) drawBubble(canvas, message, top - dp(8));
+        // Ask for the next frame only for as long as there is one to draw.
+        // At rest the only thing left that moves is the blink, so sleep until
+        // the eyes are due to change.
+        postInvalidateDelayed(lively ? FRAME_MS : untilNextBlinkFrame(now));
+    }
+
+    /**
+     * How long the resting blob can hold perfectly still: until its eyes are
+     * due to close, or — if they are shut right now — until they open again.
+     */
+    private static long untilNextBlinkFrame(long now) {
+        long phase = now % BLINK_CYCLE_MS;
+        long closesAt = BLINK_CYCLE_MS - BLINK_MS;
+        return Math.max(FRAME_MS, phase < closesAt ? closesAt - phase : BLINK_CYCLE_MS - phase);
+    }
+
+    private void drawEyes(Canvas canvas, float left, float top, float size, long now, float lookOffset) {
+        if (preset == null) return;
+        float scale = size / 256f;
+        float look = lookOffset * scale;
+        boolean blink = now % BLINK_CYCLE_MS > BLINK_CYCLE_MS - BLINK_MS;
+        float blinkScale = blink ? 0.10f : 1f;
+        paint.setColor(preset.eyeColor);
+        for (float[] eye : preset.eyes) {
+            drawEye(
+                canvas,
+                left + eye[0] * scale + look,
+                top + eye[1] * scale,
+                eye[2] * scale,
+                eye[3] * scale,
+                eye[4] * scale,
+                blinkScale
+            );
+        }
+    }
+
+    private void drawEye(Canvas canvas, float x, float y, float width, float height, float radius, float blinkScale) {
+        float middle = y + height / 2f;
+        float half = height * blinkScale / 2f;
+        canvas.drawRoundRect(new RectF(x, middle - half, x + width, middle + half), radius, radius, paint);
+    }
+
+    private void drawBubble(Canvas canvas, String value, float bottom) {
+        float margin = dp(8);
+        float padding = dp(11);
+        float maxWidth = getWidth() - margin * 2;
+        String[] lines = wrap(value, maxWidth - padding * 2);
+        float lineHeight = dp(17);
+        float height = padding * 2 + lines.length * lineHeight;
+        float top = Math.max(dp(2), bottom - height);
+        RectF bubble = new RectF(margin, top, getWidth() - margin, bottom);
+        paint.setColor(0xEE14181C);
+        paint.setShadowLayer(dp(12), 0, dp(6), 0x77000000);
+        canvas.drawRoundRect(bubble, dp(14), dp(14), paint);
+        paint.clearShadowLayer();
+        Path tail = new Path();
+        tail.moveTo(getWidth() / 2f - dp(8), bottom);
+        tail.lineTo(getWidth() / 2f + dp(8), bottom);
+        tail.lineTo(getWidth() / 2f, bottom + dp(9));
+        tail.close();
+        canvas.drawPath(tail, paint);
+        float y = top + padding - textPaint.ascent();
+        for (String line : lines) {
+            canvas.drawText(line, margin + padding, y, textPaint);
+            y += lineHeight;
+        }
+    }
+
+    private String[] wrap(String value, float maxWidth) {
+        java.util.ArrayList<String> lines = new java.util.ArrayList<>();
+        StringBuilder current = new StringBuilder();
+        for (String word : value.split("\\s+")) {
+            String candidate = current.length() == 0 ? word : current + " " + word;
+            if (textPaint.measureText(candidate) <= maxWidth || current.length() == 0) {
+                current.setLength(0);
+                current.append(candidate);
+            } else {
+                lines.add(current.toString());
+                current.setLength(0);
+                current.append(word);
+            }
+            if (lines.size() == 3) break;
+        }
+        if (current.length() > 0 && lines.size() < 4) lines.add(current.toString());
+        return lines.toArray(new String[0]);
+    }
+
+    @Override
+    public boolean onTouchEvent(MotionEvent event) {
+        switch (event.getActionMasked()) {
+            case MotionEvent.ACTION_DOWN:
+                downRawX = event.getRawX();
+                downRawY = event.getRawY();
+                offsetX = event.getX();
+                offsetY = event.getY();
+                dragged = false;
+                dragging = true;
+                invalidate();
+                return true;
+            case MotionEvent.ACTION_MOVE:
+                if (!dragged && Math.hypot(event.getRawX() - downRawX, event.getRawY() - downRawY) > dp(6)) {
+                    dragged = true;
+                    listener.onDragStarted();
+                }
+                listener.onMove(event.getRawX(), event.getRawY(), offsetX, offsetY);
+                return true;
+            case MotionEvent.ACTION_UP:
+            case MotionEvent.ACTION_CANCEL:
+                dragging = false;
+                invalidate();
+                if (dragged) listener.onDragEnded(event.getActionMasked() == MotionEvent.ACTION_CANCEL);
+                else {
+                    hopStarted = System.currentTimeMillis();
+                    listener.onTapped();
+                }
+                return true;
+            default:
+                return super.onTouchEvent(event);
+        }
+    }
+
+    private float dp(float value) {
+        return value * getResources().getDisplayMetrics().density;
+    }
+}

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

@@ -0,0 +1,240 @@
+package dev.agentprojectcontext.apx;
+
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+final class MessageFrameParser {
+    private MessageFrameParser() {}
+
+    /**
+     * One bubble, and the kind of news it is.
+     *
+     * `channel` is null when the daemon sent only the flat `notifications`
+     * list — an older build than this one. Null means "always ring": see
+     * NotifyChannels.known.
+     */
+    record Notice(String text, String channel) {}
+
+    /**
+     * A proximity alert, complete.
+     *
+     * Unlike a Notice this carries its whole payload rather than a "go look"
+     * line: the phone cannot re-fetch it in a tunnel, and the card has to
+     * become four buttons within a second of driving past the place.
+     *
+     * `address` and `task` may be null — the daemon omits what it does not
+     * know rather than inventing it. Nothing here contains an emoji: Android
+     * Auto hands the card to Assistant, which reads it aloud.
+     */
+    record MobilityAlert(
+        String id,
+        /** The ERRAND — what this card is about. Titles the row and the screen. */
+        String title,
+        /** The shop it points at. Detail, not heading: you have several errands. */
+        String place,
+        String address,
+        String body,
+        String distanceLabel,
+        String task,
+        double latitude,
+        double longitude,
+        String navigateUrl,
+        String addStopUrl,
+        List<Action> actions
+    ) {}
+
+    /** One labelled answer. The id is what goes back to the daemon. */
+    record Action(String id, String label) {}
+
+    /** The `mobility_alert` frame, or null for any other frame. */
+    static MobilityAlert mobilityAlert(String text) {
+        try {
+            JSONObject frame = new JSONObject(text);
+            if (!"mobility_alert".equals(frame.optString("type"))) return null;
+            JSONObject alert = frame.optJSONObject("alert");
+            if (alert == null) return null;
+            String id = alert.optString("id", "").trim();
+            String title = alert.optString("title", "").trim();
+            if (id.isEmpty() || title.isEmpty()) return null;
+
+            List<Action> actions = new ArrayList<>();
+            JSONArray raw = alert.optJSONArray("actions");
+            for (int i = 0; raw != null && i < raw.length(); i++) {
+                JSONObject action = raw.optJSONObject(i);
+                if (action == null) continue;
+                String actionId = action.optString("id", "").trim();
+                String label = action.optString("label", "").trim();
+                if (!actionId.isEmpty() && !label.isEmpty()) actions.add(new Action(actionId, label));
+            }
+            return new MobilityAlert(
+                id,
+                title,
+                blankToNull(alert.optString("place", "")),
+                blankToNull(alert.optString("address", "")),
+                alert.optString("body", title).trim(),
+                blankToNull(alert.optString("distance_label", "")),
+                blankToNull(alert.optString("task", "")),
+                alert.optDouble("latitude", Double.NaN),
+                alert.optDouble("longitude", Double.NaN),
+                blankToNull(alert.optString("navigate_url", "")),
+                blankToNull(alert.optString("add_stop_url", "")),
+                actions
+            );
+        } catch (Exception ignored) {
+            return null;
+        }
+    }
+
+    private static String blankToNull(String value) {
+        String trimmed = value == null ? "" : value.trim();
+        return trimmed.isEmpty() ? null : trimmed;
+    }
+
+    static String avatar(String text) {
+        try {
+            JSONObject frame = new JSONObject(text);
+            String type = frame.optString("type");
+            if (!"hello".equals(type) && !"settings".equals(type)) return null;
+            JSONObject settings = frame.optJSONObject("settings");
+            JSONObject superAgent = settings == null ? null : settings.optJSONObject("super_agent");
+            String icon = superAgent == null ? "" : superAgent.optString("icon", "").trim();
+            return icon.isBlank() ? null : icon;
+        } catch (Exception ignored) {
+            return null;
+        }
+    }
+
+    static List<Notice> notices(String text) {
+        List<Notice> messages = new ArrayList<>();
+        try {
+            JSONObject frame = new JSONObject(text);
+            if (!"messages".equals(frame.optString("type"))) return messages;
+            // Daemon-computed copy is the contract: an empty array means the
+            // owner's send is not news and must not fall through to a guess.
+            // `notices` carries the channel each line is about and wins when
+            // present; `notifications` is the same lines without it, kept for
+            // the reverse case — this APK against a daemon from before the tag
+            // existed.
+            if (frame.has("notices")) {
+                JSONArray ready = frame.optJSONArray("notices");
+                if (ready == null) return messages;
+                for (int i = 0; i < ready.length(); i++) {
+                    JSONObject notice = ready.optJSONObject(i);
+                    if (notice == null) continue;
+                    String line = notice.optString("text", "").trim();
+                    if (line.isEmpty()) continue;
+                    String channel = notice.optString("channel", "").trim();
+                    messages.add(new Notice(line, channel.isEmpty() ? null : channel));
+                }
+                return messages;
+            }
+            if (frame.has("notifications")) {
+                JSONArray ready = frame.optJSONArray("notifications");
+                if (ready == null) return messages;
+                for (int i = 0; i < ready.length(); i++) {
+                    String line = ready.optString(i, "").trim();
+                    if (!line.isEmpty()) messages.add(new Notice(line, null));
+                }
+                return messages;
+            }
+            JSONArray events = frame.optJSONArray("events");
+            if (events == null) return messages;
+            appendMobility(messages, events);
+            appendRoutineDeliveries(messages, events);
+            appendAgentFinals(messages, events);
+        } catch (Exception ignored) {
+            // A malformed live frame has no notification value.
+        }
+        return messages;
+    }
+
+    private static void appendMobility(List<Notice> messages, JSONArray events) {
+        for (int i = 0; i < events.length(); i++) {
+            JSONObject event = events.optJSONObject(i);
+            if (event == null) continue;
+            if (!"mobility_delivery".equals(event.optString("via"))) continue;
+            String notice = event.optString("notify", "").trim();
+            if (!notice.isBlank()) messages.add(new Notice(notice, NotifyChannels.MOBILITY));
+        }
+    }
+
+    private static void appendRoutineDeliveries(List<Notice> messages, JSONArray events) {
+        Map<String, String> byAgent = new LinkedHashMap<>();
+        for (int i = 0; i < events.length(); i++) {
+            JSONObject event = events.optJSONObject(i);
+            if (event == null) continue;
+            if (!"routine_delivery".equals(event.optString("via"))) continue;
+            if (!"web".equals(event.optString("channel"))) continue;
+            String agent = event.optString("agent_slug", "").trim();
+            if (agent.isEmpty() || "super_agent".equals(agent)) continue;
+            String notify = event.optString("notify", "").trim();
+            if (notify.isEmpty()) notify = byAgent.getOrDefault(agent, "");
+            byAgent.put(agent, notify);
+        }
+        for (Map.Entry<String, String> entry : byAgent.entrySet()) {
+            String notify = entry.getValue();
+            messages.add(new Notice(
+                notify.isEmpty()
+                    ? entry.getKey() + " te dejó un mensaje"
+                    : entry.getKey() + ": " + notify,
+                NotifyChannels.ROUTINE
+            ));
+        }
+    }
+
+    private static void appendAgentFinals(List<Notice> messages, JSONArray events) {
+        Map<String, Notice> byAgent = new LinkedHashMap<>();
+        for (int i = 0; i < events.length(); i++) {
+            JSONObject event = events.optJSONObject(i);
+            if (event == null) continue;
+            if (!isAgentFinal(event)) continue;
+            String agent = speakerName(event);
+            String channel = event.optString("channel");
+            byAgent.put(
+                channel + "|" + agent,
+                new Notice(agent + " respondió en " + channelLabel(channel), channel)
+            );
+        }
+        messages.addAll(byAgent.values());
+    }
+
+    private static boolean isAgentFinal(JSONObject event) {
+        if (!"out".equals(event.optString("direction"))) return false;
+        String type = event.optString("type", "");
+        if (!type.isEmpty() && !"agent".equals(type)) return false;
+        String channel = event.optString("channel");
+        if (!"telegram".equals(channel) && !"group".equals(channel) && !"a2a".equals(channel)) return false;
+        if (event.optBoolean("streamed", false)) return false;
+        String via = event.optString("via", "");
+        if ("routine_delivery".equals(via) || "mobility_delivery".equals(via)) return false;
+        return true;
+    }
+
+    private static String speakerName(JSONObject event) {
+        String author = event.optString("author", "").trim();
+        if (!author.isEmpty() && !"user".equals(author) && !"owner".equals(author) && !author.startsWith("@")) {
+            return author;
+        }
+        String slug = event.optString("agent_slug", "").trim();
+        return slug.isEmpty() ? "agente" : slug;
+    }
+
+    private static String channelLabel(String channel) {
+        if (channel == null || channel.isBlank()) return "APX";
+        return switch (channel) {
+            case "telegram" -> "Telegram";
+            case "group" -> "Grupo";
+            case "a2a" -> "A2A";
+            case "web", "web_sidebar", "web_code" -> "Web";
+            case "cli" -> "Terminal";
+            case "routine" -> "Rutinas";
+            case "deck" -> "Deck";
+            default -> channel.substring(0, 1).toUpperCase() + channel.substring(1);
+        };
+    }
+}

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

@@ -0,0 +1,69 @@
+package dev.agentprojectcontext.apx;
+
+import java.util.List;
+
+/**
+ * Which kinds of news this phone's bell may ring for.
+ *
+ * Five, and the list is closed: the daemon tags every bubble with one of them
+ * (see core/events/mascot-notify.js, NOTICE_CHANNELS). That is what makes the
+ * settings dialog honest — it offers exactly what can ever arrive, instead of
+ * a catalog of every channel APX speaks on, most of which never reach the pet.
+ *
+ * A delivery is tagged by what it IS, not by the ledger channel it was filed
+ * on: a routine delivery lives on `web` and a mobility notice rides Telegram,
+ * but silencing Telegram must not silence the car. So "the errands on the way
+ * home" and "Telegram" are two separate ticks, which is the whole reason the
+ * owner wanted this.
+ */
+final class NotifyChannels {
+    static final String TELEGRAM = "telegram";
+    static final String GROUP = "group";
+    static final String A2A = "a2a";
+    static final String ROUTINE = "routine";
+    static final String MOBILITY = "mobility";
+
+    /** Menu order: loudest and most contested first. */
+    static final List<String> ALL = List.of(TELEGRAM, GROUP, A2A, ROUTINE, MOBILITY);
+
+    private NotifyChannels() {}
+
+    static String label(String channel) {
+        if (channel == null) return "APX";
+        return switch (channel) {
+            case TELEGRAM -> "Telegram";
+            case GROUP -> "Grupos";
+            case A2A -> "Entre agentes";
+            case ROUTINE -> "Rutinas";
+            case MOBILITY -> "Viajes y mandados";
+            default -> channel.substring(0, 1).toUpperCase() + channel.substring(1);
+        };
+    }
+
+    /**
+     * Telegram alone starts silent, and only here.
+     *
+     * The same rule the panel has followed per device since lib/channels.ts,
+     * for the same reason and now on the device it was written about: Telegram
+     * is installed ON this phone, so an APX bubble about a Telegram reply is
+     * the second time that news arrives, seconds after Telegram's own. Every
+     * other channel has no other way to reach the phone at all.
+     *
+     * A default, not a decision: one tick in the menu overrides it, and that
+     * choice is what gets stored.
+     */
+    static boolean enabledByDefault(String channel) {
+        return !TELEGRAM.equals(channel);
+    }
+
+    /**
+     * An untagged line — an older daemon, or a bubble raised locally by the
+     * "test message" action — always rings. A notice whose channel we cannot
+     * read is not one to guess at and drop: news lost in silence is worse than
+     * news arriving on a muted channel, and it is the case the owner can see
+     * and fix.
+     */
+    static boolean known(String channel) {
+        return channel != null && ALL.contains(channel);
+    }
+}

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

@@ -0,0 +1,78 @@
+package dev.agentprojectcontext.apx;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.net.Uri;
+import android.util.Log;
+
+/**
+ * What a tap on one of the four proximity buttons does.
+ *
+ * TWO THINGS, IN THIS ORDER, and the order is the point. The answer goes to the
+ * daemon FIRST, then Maps opens. Launching Maps hands the foreground away, and
+ * an OEM that freezes the app on the way out would lose the answer — the tap
+ * would have started a route APX never learned about, so the end-of-trip
+ * follow-up would never ask whether the errand got done.
+ *
+ * The card is dismissed either way: it was answered, and a proximity alert that
+ * stays on screen after being answered is the one thing guaranteed to be tapped
+ * twice at the next red light.
+ */
+public class ProximityActionReceiver extends BroadcastReceiver {
+    private static final String TAG = "APXTravel";
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        if (!ProximityNotification.ACTION_ANSWER.equals(intent.getAction())) return;
+        String alertId = intent.getStringExtra(ProximityNotification.EXTRA_ALERT_ID);
+        String actionId = intent.getStringExtra(ProximityNotification.EXTRA_ACTION_ID);
+        String url = intent.getStringExtra(ProximityNotification.EXTRA_URL);
+        int notificationId = intent.getIntExtra(ProximityNotification.EXTRA_NOTIFICATION_ID, -1);
+        if (alertId == null || actionId == null) return;
+
+        Log.i(TAG, "proximity answer " + actionId + " for " + alertId);
+
+        ApxPreferences preferences = new ApxPreferences(context);
+        DaemonClient.answerAlert(
+            preferences.daemonUrl(),
+            preferences.token(),
+            alertId,
+            actionId,
+            new DaemonClient.AnswerCallback() {
+                @Override public void onAnswered() {
+                    Log.i(TAG, "proximity answer " + actionId + " recorded");
+                }
+                @Override public void onAnswerFailed(String message) {
+                    // Logged, not surfaced: the driver already pressed the
+                    // button and is looking at the road. The alert stays
+                    // recorded on the daemon side as unanswered, which is the
+                    // honest state — nothing here pretends otherwise.
+                    Log.w(TAG, "proximity answer " + actionId + " failed: " + message);
+                }
+            }
+        );
+
+        // Gone from the head unit too: answering on the phone must not leave
+        // the chip offering the same four buttons for the same place.
+        CarAlertStore.remove(alertId);
+        if (notificationId >= 0) ProximityNotification.cancel(context, notificationId);
+
+        if (url != null && !url.isBlank()) {
+            try {
+                context.startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse(url))
+                    .setPackage("com.google.android.apps.maps")
+                    .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK));
+            } catch (Exception ignored) {
+                // Maps missing or refusing the intent: fall back to whatever
+                // does handle it rather than dropping the tap.
+                try {
+                    context.startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse(url))
+                        .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK));
+                } catch (Exception error) {
+                    Log.w(TAG, "could not open " + url + ": " + error.getMessage());
+                }
+            }
+        }
+    }
+}