@agentprojectcontext/apx 1.81.0 → 1.89.1

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

@@ -0,0 +1,165 @@
+package dev.agentprojectcontext.apx;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+
+import org.json.JSONObject;
+
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+final class ApxPreferences {
+    static final String SOURCE_MAPS = "maps";
+    static final String SOURCE_ANDROID_AUTO = "android_auto";
+
+    private static final String NAME = "apx_android";
+    private static final String URL = "daemon_url";
+    private static final String TOKEN = "client_token";
+    private static final String MASCOT = "mascot_enabled";
+    private static final String SOUND = "message_sound_enabled";
+    private static final String NOTIFY_CHANNELS = "notify_channels";
+    private static final String MASCOT_AVATAR = "mascot_avatar";
+    private static final String TRAVEL_ACTIVE = "maps_travel_active";
+    private static final String TRAVEL_CHANGED_AT = "maps_travel_changed_at";
+    private static final String TRAVEL_DESTINATION = "maps_travel_destination";
+    private static final String TRAVEL_TRIP_ID = "maps_travel_trip_id";
+    private static final String TRAVEL_SOURCE = "maps_travel_source";
+    private static final String TRAVEL_EVENT_SENT = "maps_travel_event_sent";
+    private static final String TRAVEL_LAST_SENT_AT = "maps_travel_last_sent_at";
+    private static final String TRAVEL_LAST_SENT_DESTINATION = "maps_travel_last_sent_destination";
+    private static final String X = "mascot_x";
+    private static final String Y = "mascot_y";
+
+    private final SharedPreferences prefs;
+
+    ApxPreferences(Context context) {
+        prefs = context.getSharedPreferences(NAME, Context.MODE_PRIVATE);
+    }
+
+    String daemonUrl() { return prefs.getString(URL, ""); }
+    String token() { return prefs.getString(TOKEN, ""); }
+    boolean paired() { return !daemonUrl().isBlank() && !token().isBlank(); }
+    boolean mascotEnabled() { return prefs.getBoolean(MASCOT, true); }
+    boolean soundEnabled() { return prefs.getBoolean(SOUND, true); }
+    String mascotAvatar() { return prefs.getString(MASCOT_AVATAR, MascotBlobCatalog.DEFAULT_KEY); }
+    boolean travelActive() { return prefs.getBoolean(TRAVEL_ACTIVE, false); }
+    long travelChangedAt() { return prefs.getLong(TRAVEL_CHANGED_AT, 0L); }
+    String travelDestination() { return prefs.getString(TRAVEL_DESTINATION, ""); }
+    String travelTripId() { return prefs.getString(TRAVEL_TRIP_ID, ""); }
+    /**
+     * What put APX in a trip: {@link #SOURCE_MAPS} (a Google Maps route) or
+     * {@link #SOURCE_ANDROID_AUTO} (the phone is projecting to a head unit).
+     * The two arrive independently and end independently — a route can finish
+     * while the car is still connected, and Auto can disconnect mid-route — so
+     * the trip only ends when NEITHER is live.
+     */
+    String travelSource() { return prefs.getString(TRAVEL_SOURCE, ""); }
+    boolean travelEventSent() { return prefs.getBoolean(TRAVEL_EVENT_SENT, false); }
+    long travelLastSentAt() {
+        return prefs.getLong(
+            TRAVEL_LAST_SENT_AT,
+            travelEventSent() ? travelChangedAt() : 0L
+        );
+    }
+    String travelLastSentDestination() {
+        return prefs.getString(
+            TRAVEL_LAST_SENT_DESTINATION,
+            travelEventSent() ? travelDestination() : ""
+        );
+    }
+    int mascotX(int fallback) { return prefs.getInt(X, fallback); }
+    int mascotY(int fallback) { return prefs.getInt(Y, fallback); }
+
+    void savePairing(String url, String token) {
+        prefs.edit().putString(URL, url).putString(TOKEN, token).apply();
+    }
+
+    void clearPairing() {
+        prefs.edit().remove(URL).remove(TOKEN).apply();
+    }
+
+    void setMascotEnabled(boolean enabled) {
+        prefs.edit().putBoolean(MASCOT, enabled).apply();
+    }
+
+    void setSoundEnabled(boolean enabled) {
+        prefs.edit().putBoolean(SOUND, enabled).apply();
+    }
+
+    /**
+     * The channels this phone was explicitly told to ring for, or not.
+     *
+     * Only EXPLICIT answers are stored, exactly as the panel does it: an
+     * untouched channel falls through to NotifyChannels.enabledByDefault, so
+     * a default we change later reaches a phone that never had an opinion,
+     * instead of being frozen at install time as though the owner had chosen
+     * it. Stored as one JSON object rather than a string set because the value
+     * is three-state — on, off, never asked.
+     */
+    Map<String, Boolean> notifyChannels() {
+        Map<String, Boolean> choices = new LinkedHashMap<>();
+        try {
+            JSONObject stored = new JSONObject(prefs.getString(NOTIFY_CHANNELS, "{}"));
+            // keys(), not keySet(): Android ships its own org.json, and that
+            // one has no keySet — a difference the JVM unit tests cannot see,
+            // because they run against the Maven artifact where both exist.
+            for (Iterator<String> keys = stored.keys(); keys.hasNext(); ) {
+                String key = keys.next();
+                if (stored.opt(key) instanceof Boolean on) choices.put(key, on);
+            }
+        } catch (Exception ignored) {
+            // Something else wrote the key: fall back to every default.
+        }
+        return choices;
+    }
+
+    boolean notifyChannelEnabled(String channel) {
+        if (!NotifyChannels.known(channel)) return true;
+        Boolean explicit = notifyChannels().get(channel);
+        return explicit == null ? NotifyChannels.enabledByDefault(channel) : explicit;
+    }
+
+    void setNotifyChannelEnabled(String channel, boolean on) {
+        if (!NotifyChannels.known(channel)) return;
+        Map<String, Boolean> next = notifyChannels();
+        next.put(channel, on);
+        prefs.edit().putString(NOTIFY_CHANNELS, new JSONObject(next).toString()).apply();
+    }
+
+    void setMascotAvatar(String key) {
+        prefs.edit().putString(MASCOT_AVATAR, MascotBlobCatalog.forKey(key).key).apply();
+    }
+
+    /** Keeps whatever source is already recorded (voice destination replies). */
+    void setTravelState(boolean active, String destination, String tripId) {
+        setTravelState(active, destination, tripId, travelSource());
+    }
+
+    void setTravelState(boolean active, String destination, String tripId, String source) {
+        prefs.edit()
+            .putBoolean(TRAVEL_ACTIVE, active)
+            .putLong(TRAVEL_CHANGED_AT, System.currentTimeMillis())
+            .putString(TRAVEL_DESTINATION, active && destination != null ? destination : "")
+            .putString(TRAVEL_TRIP_ID, active && tripId != null ? tripId : "")
+            .putString(TRAVEL_SOURCE, active && source != null ? source : "")
+            .putBoolean(TRAVEL_EVENT_SENT, active && travelEventSent())
+            .apply();
+    }
+
+    void setTravelEventSent(boolean sent) {
+        prefs.edit().putBoolean(TRAVEL_EVENT_SENT, sent).apply();
+    }
+
+    void recordTravelEventSent(String destination) {
+        prefs.edit()
+            .putBoolean(TRAVEL_EVENT_SENT, true)
+            .putLong(TRAVEL_LAST_SENT_AT, System.currentTimeMillis())
+            .putString(TRAVEL_LAST_SENT_DESTINATION, destination == null ? "" : destination.trim())
+            .apply();
+    }
+
+    void saveMascotPosition(int x, int y) {
+        prefs.edit().putInt(X, x).putInt(Y, y).apply();
+    }
+}

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

@@ -0,0 +1,84 @@
+package dev.agentprojectcontext.apx;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * The alerts the head unit should be showing, right now.
+ *
+ * A process-wide holder rather than a bound service, because both ends already
+ * live in this process: MascotOverlayService owns the socket to the daemon and
+ * the car app is started by Android Auto in the same app. Binding them would
+ * add a lifecycle to synchronise for no data that is not already here.
+ *
+ * BOUNDED AND KEYED BY ALERT ID. Two errands can come into range on one GPS
+ * sample and both are real, but a car screen is read at 110 km/h — past a
+ * handful nobody is choosing, and an unbounded list would grow for the whole
+ * drive because the car app has no reason to ever forget on its own.
+ *
+ * Answering removes the alert here as well as on the daemon: the head unit must
+ * not still be offering "Navegar ahora" for a place the driver already answered
+ * about on the phone.
+ */
+final class CarAlertStore {
+    /** What a head-unit screen can usefully offer at a glance. */
+    private static final int MAX_ALERTS = 5;
+
+    private static final Map<String, MessageFrameParser.MobilityAlert> alerts = new LinkedHashMap<>();
+    private static final List<Runnable> listeners = new ArrayList<>();
+
+    private CarAlertStore() {}
+
+    static synchronized void put(MessageFrameParser.MobilityAlert alert) {
+        if (alert == null) return;
+        alerts.remove(alert.id());          // re-insert so the newest is last
+        alerts.put(alert.id(), alert);
+        while (alerts.size() > MAX_ALERTS) {
+            alerts.remove(alerts.keySet().iterator().next());
+        }
+        notifyListeners();
+    }
+
+    static synchronized void remove(String alertId) {
+        if (alertId != null && alerts.remove(alertId) != null) notifyListeners();
+    }
+
+    static synchronized void clear() {
+        if (alerts.isEmpty()) return;
+        alerts.clear();
+        notifyListeners();
+    }
+
+    /** Newest last — the same order the driver was told about them. */
+    static synchronized List<MessageFrameParser.MobilityAlert> all() {
+        return new ArrayList<>(alerts.values());
+    }
+
+    static synchronized MessageFrameParser.MobilityAlert get(String alertId) {
+        return alertId == null ? null : alerts.get(alertId);
+    }
+
+    /**
+     * Called whenever the set changes, so an open car screen can invalidate.
+     * Listeners are held for the life of the screen and removed by it.
+     */
+    static synchronized void addListener(Runnable listener) {
+        if (listener != null && !listeners.contains(listener)) listeners.add(listener);
+    }
+
+    static synchronized void removeListener(Runnable listener) {
+        listeners.remove(listener);
+    }
+
+    private static void notifyListeners() {
+        for (Runnable listener : new ArrayList<>(listeners)) {
+            try {
+                listener.run();
+            } catch (Exception ignored) {
+                // A screen that has gone away must not stop the next one being told.
+            }
+        }
+    }
+}

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

@@ -0,0 +1,47 @@
+package dev.agentprojectcontext.apx;
+
+import android.app.NotificationManager;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import android.widget.Toast;
+
+import androidx.core.app.RemoteInput;
+
+public final class CarMessageActionReceiver extends BroadcastReceiver {
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        NotificationManager manager = context.getSystemService(NotificationManager.class);
+        manager.cancel(CarMessageNotification.ID);
+
+        boolean destinationReply = CarMessageNotification.ACTION_MOBILITY_DESTINATION.equals(intent.getAction());
+        if (!CarMessageNotification.ACTION_REPLY.equals(intent.getAction()) && !destinationReply) return;
+        Bundle results = RemoteInput.getResultsFromIntent(intent);
+        CharSequence reply = results == null ? null : results.getCharSequence(CarMessageNotification.KEY_REPLY);
+        if (reply != null && !reply.toString().trim().isEmpty()) {
+            if (destinationReply) {
+                ApxPreferences preferences = new ApxPreferences(context);
+                String spoken = reply.toString().trim();
+                String parsed = MapsNavigationDetector.destinationFrom(spoken);
+                String destination = parsed.isBlank() ? spoken : parsed;
+                String tripId = preferences.travelTripId();
+                if (preferences.travelActive() && !tripId.isBlank()) {
+                    preferences.setTravelState(true, destination, tripId);
+                    context.sendBroadcast(new Intent(MapsNavigationListenerService.ACTION_TRAVEL_STATE_CHANGED)
+                        .setPackage(context.getPackageName()));
+                    DaemonClient.notifyTripStarted(
+                        preferences.daemonUrl(),
+                        preferences.token(),
+                        tripId,
+                        destination,
+                        DeviceLocation.latest(context)
+                    );
+                    Toast.makeText(context, "Destino enviado a Roby", Toast.LENGTH_SHORT).show();
+                }
+            } else {
+                Toast.makeText(context, "Respuesta recibida", Toast.LENGTH_SHORT).show();
+            }
+        }
+    }
+}

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

@@ -0,0 +1,152 @@
+package dev.agentprojectcontext.apx;
+
+import android.app.Notification;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+import android.graphics.BitmapFactory;
+
+import androidx.core.app.NotificationCompat;
+import androidx.core.app.Person;
+import androidx.core.app.RemoteInput;
+
+final class CarMessageNotification {
+    static final String CHANNEL = "apx_messages_custom_sound";
+    static final int ID = 7100;
+    static final int DESTINATION_ID = 7101;
+    static final String ACTION_REPLY = "dev.agentprojectcontext.apx.CAR_MESSAGE_REPLY";
+    static final String ACTION_MOBILITY_DESTINATION = "dev.agentprojectcontext.apx.MOBILITY_DESTINATION";
+    static final String ACTION_READ = "dev.agentprojectcontext.apx.CAR_MESSAGE_READ";
+    static final String KEY_REPLY = "apx_car_reply";
+
+    private CarMessageNotification() {}
+
+    static Notification build(Context context, String message, PendingIntent openApp) {
+        return build(context, message, openApp, ACTION_REPLY, "Responder a APX");
+    }
+
+    private static Notification build(
+        Context context,
+        String message,
+        PendingIntent openApp,
+        String replyAction,
+        String replyLabel
+    ) {
+        ensureChannel(context);
+
+        Person apx = new Person.Builder()
+            .setName("APX")
+            .setIcon(androidx.core.graphics.drawable.IconCompat.createWithResource(context, R.drawable.apx_logo))
+            .build();
+        Person user = new Person.Builder().setName("Vos").build();
+
+        RemoteInput replyInput = new RemoteInput.Builder(KEY_REPLY)
+            .setLabel(replyLabel)
+            .build();
+        NotificationCompat.Action reply = new NotificationCompat.Action.Builder(
+            R.drawable.ic_apx_notification,
+            "Responder",
+            pendingBroadcast(context, replyAction, 40, true)
+        )
+            .addRemoteInput(replyInput)
+            .setSemanticAction(NotificationCompat.Action.SEMANTIC_ACTION_REPLY)
+            .setShowsUserInterface(false)
+            .build();
+        NotificationCompat.Action read = new NotificationCompat.Action.Builder(
+            R.drawable.ic_apx_notification,
+            "Marcar leído",
+            pendingBroadcast(context, ACTION_READ, 41, false)
+        )
+            .setSemanticAction(NotificationCompat.Action.SEMANTIC_ACTION_MARK_AS_READ)
+            .setShowsUserInterface(false)
+            .build();
+
+        return new NotificationCompat.Builder(context, CHANNEL)
+            .setSmallIcon(R.drawable.ic_apx_notification)
+            .setLargeIcon(BitmapFactory.decodeResource(context.getResources(), R.drawable.apx_logo))
+            .setCategory(NotificationCompat.CATEGORY_MESSAGE)
+            .setPriority(NotificationCompat.PRIORITY_HIGH)
+            .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+            .setContentIntent(openApp)
+            .setAutoCancel(true)
+            .setOnlyAlertOnce(false)
+            .setStyle(new NotificationCompat.MessagingStyle(user)
+                .setConversationTitle("APX")
+                .addMessage(message, System.currentTimeMillis(), apx))
+            .addAction(reply)
+            .addAction(read)
+            .extend(new NotificationCompat.CarExtender()
+                .setUnreadConversation(new NotificationCompat.CarExtender.UnreadConversation.Builder("APX")
+                    .addMessage(message)
+                    .setLatestTimestamp(System.currentTimeMillis())
+                    .setReadPendingIntent(pendingBroadcast(context, ACTION_READ, 42, false))
+                    .setReplyAction(pendingBroadcast(context, replyAction, 43, true), replyInput)
+                    .build()))
+            .build();
+    }
+
+    static void show(Context context, String message) {
+        show(context, ID, message, ACTION_REPLY, "Responder a APX");
+    }
+
+    static void showDestinationRequest(Context context) {
+        show(
+            context,
+            DESTINATION_ID,
+            "¿A dónde vas? Respondé por voz para completar la ruta.",
+            ACTION_MOBILITY_DESTINATION,
+            "Decí tu destino"
+        );
+    }
+
+    static void cancel(Context context) {
+        context.getSystemService(NotificationManager.class).cancel(DESTINATION_ID);
+    }
+
+    private static void show(
+        Context context,
+        int notificationId,
+        String message,
+        String replyAction,
+        String replyLabel
+    ) {
+        Intent open = new Intent(context, MainActivity.class)
+            .putExtra(MainActivity.EXTRA_PATH, "/mobile")
+            .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_SINGLE_TOP);
+        PendingIntent openApp = PendingIntent.getActivity(
+            context,
+            44,
+            open,
+            PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE
+        );
+        NotificationManager manager = context.getSystemService(NotificationManager.class);
+        manager.notify(notificationId, build(context, message, openApp, replyAction, replyLabel));
+    }
+
+    private static void ensureChannel(Context context) {
+        NotificationManager manager = context.getSystemService(NotificationManager.class);
+        NotificationChannel channel = new NotificationChannel(
+            CHANNEL,
+            context.getString(R.string.messages_channel),
+            NotificationManager.IMPORTANCE_HIGH
+        );
+        channel.setDescription("Mensajes directos APX, también visibles en Android Auto.");
+        channel.setSound(null, null);
+        channel.setBypassDnd(manager.isNotificationPolicyAccessGranted());
+        manager.createNotificationChannel(channel);
+    }
+
+    private static PendingIntent pendingBroadcast(
+        Context context,
+        String action,
+        int requestCode,
+        boolean mutable
+    ) {
+        Intent intent = new Intent(context, CarMessageActionReceiver.class).setAction(action);
+        int flags = PendingIntent.FLAG_UPDATE_CURRENT |
+            (mutable ? PendingIntent.FLAG_MUTABLE : PendingIntent.FLAG_IMMUTABLE);
+        return PendingIntent.getBroadcast(context, requestCode, intent, flags);
+    }
+}

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

@@ -0,0 +1,35 @@
+package dev.agentprojectcontext.apx;
+
+import java.net.URI;
+
+final class DaemonAddress {
+    private DaemonAddress() {}
+
+    static String normalize(String raw) {
+        String value = raw == null ? "" : raw.trim();
+        if (value.isEmpty()) throw new IllegalArgumentException("Ingresá URL del daemon.");
+        if (!value.contains("://")) value = "http://" + value;
+        URI uri;
+        try {
+            uri = URI.create(value);
+        } catch (IllegalArgumentException error) {
+            throw new IllegalArgumentException("URL inválida.");
+        }
+        String scheme = uri.getScheme();
+        if (!("http".equalsIgnoreCase(scheme) || "https".equalsIgnoreCase(scheme))) {
+            throw new IllegalArgumentException("Usá URL http:// o https://.");
+        }
+        if (uri.getHost() == null || uri.getHost().isBlank()) {
+            throw new IllegalArgumentException("URL sin host.");
+        }
+        int port = uri.getPort();
+        String authority = uri.getHost() + (port >= 0 ? ":" + port : "");
+        return scheme.toLowerCase() + "://" + authority;
+    }
+
+    static String webSocketUrl(String baseUrl, String token) {
+        String scheme = baseUrl.startsWith("https://") ? "wss://" : "ws://";
+        String host = baseUrl.replaceFirst("^https?://", "");
+        return scheme + host + "/api/events/ws?token=" + android.net.Uri.encode(token);
+    }
+}