release: EVABRPUploader 2.1.2 — permissions declared but never granted

- Foreground service type: the service declares `location`, and the plain
  two-argument startForeground claims every declared type. Since API 34 each is
  validated against the permissions held right then, so on a car where position was
  never granted the service threw SecurityException in onCreate and never uploaded.
  The type is now claimed only while its permission is held, and re-asserted on
  every start so a later grant applies without a reboot.
- Ordering: the activity requested position *after* starting the service, which made
  the first launch on a new install the one case that could never work.
- CAR_EXTERIOR_ENVIRONMENT and CONTROL_CAR_CLIMATE were declared and read since 2.1.0
  but never requested, so outside and cabin temperature were dropped from every
  payload on cars that would have answered.
- POST_NOTIFICATIONS was declared and never requested: the service's only status
  display was silently dropped from Android 13 on.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: malys

CHANGELOG.md

@@ -4,6 +4,24 @@ All notable changes to this project are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); versions follow
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.1.2] - 2026-08-25
+
+### Fixed
+
+- **The uploader starts on a car that has not granted position yet.** The service declares the
+  `location` foreground type, and since Android 14 every declared type is checked against the
+  permissions held at the moment it enters the foreground — so a fresh install, or a boot
+  before the app had ever been opened, killed the service in its own `onCreate` before the
+  first tick. The type is now claimed only while the permission behind it is held, and the
+  activity asks for the permission *before* starting the service rather than after.
+- **Outside and cabin temperature reach ABRP again.** Both were declared and read since 2.1.0
+  but never requested at runtime, so both properties answered as unreadable and were dropped
+  from every payload.
+- **The service notification is visible.** `POST_NOTIFICATIONS` was declared and never asked
+  for; the only status the service has was being dropped silently on Android 13 and later.
+- A permission granted while the service is already running now takes effect at once instead
+  of at the next boot.
+
 ## [2.1.1] - 2026-08-23
 
 ### Fixed

app/build.gradle

@@ -34,8 +34,8 @@ android {
         applicationId "com.evsuite.abrp"
         minSdk 27
         targetSdk 36
-        versionCode 9
-        versionName "2.1.1"
+        versionCode 10
+        versionName "2.1.2"
 
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
     }

app/src/main/java/com/evsuite/abrp/AbrpUploadService.java

@@ -6,6 +6,8 @@
 import android.app.PendingIntent;
 import android.app.Service;
 import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.content.pm.ServiceInfo;
 import android.content.SharedPreferences;
 import android.location.Location;
 import android.location.LocationListener;
@@ -16,7 +18,11 @@
 import android.os.Looper;
 import android.util.Log;
 
+import android.Manifest;
+
 import androidx.core.app.NotificationCompat;
+import androidx.core.app.ServiceCompat;
+import androidx.core.content.ContextCompat;
 
 import com.evsuite.hardware.EVHardware;
 
@@ -107,6 +113,8 @@ public class AbrpUploadService extends Service {
     private final ChargeMeter    chargeMeter    = new ChargeMeter();
     private volatile UploadSettings settings = UploadSettings.defaults();
     /** False while no GPS subscription is delivering — drives the watchdog re-arm. */
+    /** What the foreground notification currently says, so re-asserting it does not blank it. */
+    private volatile String lastStatus = "Starting…";
     private volatile boolean locationUpdatesActive = false;
     private volatile long lastLocationRequestMs = 0L;
 
@@ -127,7 +135,7 @@ public void onCreate() {
         });
 
         createNotificationChannel();
-        startForeground(NOTIF_ID, buildNotification("Starting…"));
+        startInForeground();
         running = true;
         prefs.edit().putBoolean("service_running", true).apply();
 
@@ -158,9 +166,45 @@ public int onStartCommand(Intent intent, int flags, int startId) {
             stopSelf();
             return START_NOT_STICKY;
         }
+        // Re-asserted on every start: a position grant that arrives after the service is up
+        // changes which foreground types it may hold, and the activity starts it again as
+        // soon as the user answers. Without this the grant only took effect at the next boot.
+        startInForeground();
         return START_STICKY;
     }
 
+    /**
+     * Enters the foreground holding only the service types this app currently has the
+     * permissions for.
+     *
+     * The service declares {@code foregroundServiceType="location"}, and since API 34 the
+     * platform validates every declared type against what is held at the moment
+     * startForeground runs — the plain two-argument call claims them all. On a car where
+     * position had not been granted yet (a fresh install, or the boot receiver starting the
+     * service before the app was ever opened) that threw a SecurityException and the uploader
+     * died before its first tick. Without the permission the service still runs and still
+     * uploads; it simply has no position to send, exactly as before.
+     */
+    private void startInForeground() {
+        if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.Q) {
+            // Service types do not exist before API 29: nothing is declared and nothing is
+            // checked, so the plain call is the only correct one there.
+            startForeground(NOTIF_ID, buildNotification(lastStatus));
+            return;
+        }
+        int types = hasLocationPermission()
+                ? ServiceInfo.FOREGROUND_SERVICE_TYPE_LOCATION
+                : ServiceInfo.FOREGROUND_SERVICE_TYPE_NONE;
+        ServiceCompat.startForeground(this, NOTIF_ID, buildNotification(lastStatus), types);
+    }
+
+    private boolean hasLocationPermission() {
+        return ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION)
+                        == PackageManager.PERMISSION_GRANTED
+                || ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION)
+                        == PackageManager.PERMISSION_GRANTED;
+    }
+
     @Override
     public IBinder onBind(Intent intent) { return null; }
 
@@ -542,6 +586,7 @@ private Notification buildNotification(String status) {
     }
 
     private void updateNotification(String status) {
+        lastStatus = status;
         getSystemService(NotificationManager.class).notify(NOTIF_ID, buildNotification(status));
     }
 }

app/src/main/java/com/evsuite/abrp/MainActivity.java

@@ -223,8 +223,12 @@ protected void onCreate(Bundle savedInstanceState) {
         boolean haveCreds = !securePrefs.getString(SecurePrefs.KEY_TOKEN, "").trim().isEmpty()
                          && !securePrefs.getString(SecurePrefs.KEY_API_KEY, "").trim().isEmpty();
         if (enabled && haveCreds) {
-            startForegroundService(new Intent(this, AbrpUploadService.class));
+            // Asked for first, and deliberately: the service declares the `location`
+            // foreground type, and since API 34 starting it without the permission behind
+            // that type is a SecurityException in its own onCreate. Started this way round,
+            // the very first launch after an install could never bring the uploader up.
             requestLocationPermissionIfNeeded();
+            startForegroundService(new Intent(this, AbrpUploadService.class));
         }
 
         abrpPane.findViewById(R.id.save_button).setOnClickListener(v -> saveCredentials());
@@ -675,11 +679,30 @@ private String textOf(TextInputEditText field) {
             "android.car.permission.CAR_SPEED",
             "android.car.permission.CAR_ENERGY",
             "android.car.permission.CAR_ENERGY_PORTS",
+            // Outside temperature and cabin temperature: declared and read since 2.1.0, but
+            // never asked for, so both came back unreadable and were dropped from every
+            // payload on a car that would have answered them.
+            "android.car.permission.CAR_EXTERIOR_ENVIRONMENT",
+            "android.car.permission.CONTROL_CAR_CLIMATE",
     };
 
+    /**
+     * Asked for alongside the telemetry permissions from API 33, and separately because a
+     * denial costs something different: the foreground notification is the only status this
+     * service has, and without this it is dropped silently while the service runs on.
+     */
+    private static String[] runtimePermissions() {
+        if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.TIRAMISU) {
+            return RUNTIME_PERMISSIONS;
+        }
+        String[] all = java.util.Arrays.copyOf(RUNTIME_PERMISSIONS, RUNTIME_PERMISSIONS.length + 1);
+        all[RUNTIME_PERMISSIONS.length] = Manifest.permission.POST_NOTIFICATIONS;
+        return all;
+    }
+
     private void requestLocationPermissionIfNeeded() {
         java.util.List<String> missing = new java.util.ArrayList<>();
-        for (String p : RUNTIME_PERMISSIONS) {
+        for (String p : runtimePermissions()) {
             if (ContextCompat.checkSelfPermission(this, p)
                     != PackageManager.PERMISSION_GRANTED) {
                 missing.add(p);
@@ -714,6 +737,13 @@ public void onRequestPermissionsResult(int requestCode, @NonNull String[] permis
             }
         }
 
+        // A grant that arrives after the service is already up changes which foreground
+        // types it may hold, and which properties it may read. Starting it again is what
+        // applies both without waiting for the next boot.
+        if (prefs.getBoolean("service_enabled", false)) {
+            startForegroundService(new Intent(this, AbrpUploadService.class));
+        }
+
         if (locationDenied && carDataDenied) {
             setConnectionStatus(COLOR_ERROR, getString(R.string.perm_denied_all));
         } else if (locationDenied) {