@josuelmm/cordova-background-geolocation 3.0.0 → 3.0.1

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## [3.0.1](https://github.com/josuelmm/cordova-background-geolocation/tree/3.0.1) (2026-02-21)
+
+### Fixed
+
+- **Android (API 34+):** Foreground service type mismatch crash (`IllegalArgumentException: foregroundServiceType 0x00000004 is not a subset of ...`). The type passed to `startForeground()` now matches the merged app manifest:
+  - Read `foregroundServiceType` from the running service’s manifest at runtime and pass that value to `startForeground()` (so it works whether the merged manifest is `location`, `location|dataSync`, or overridden by the app to another type).
+  - On API 33+, use `getServiceInfo(ComponentName, ComponentInfoFlags)` (via reflection) instead of the deprecated `getServiceInfo(component, int)`, which could return an incomplete `ServiceInfo` and force an incorrect fallback to 4 (location) while the system validated against the real manifest (e.g. 0x9).
+  - Use `getClass()` for `ComponentName` so the manifest read corresponds to the actual running service instance.
+  - Debug log before `startForeground`: `startForeground serviceType=0x…` in logcat to confirm the type used.
+- **Android:** Avoid starting the foreground service when location permission is not granted: check in `LocationServiceImpl.startForeground()`, and in `BootCompletedReceiver` / `LocationServiceProxy` before calling `startForegroundService()` to prevent `SecurityException` and `ForegroundServiceDidNotStartInTimeException` when the app has no location permission at boot or when starting from background.
+
+### Changed
+
+- **Android:** Plugin manifests now declare the service with `foregroundServiceType`: `plugin.xml` uses `location|dataSync`; `android/common/AndroidManifest.xml` uses `location`.
+- **Angular:** Wrapper is built with **ng-packagr** (Ivy/AOT) so the service works in production without requiring the JIT compiler (fixes “The injectable 'BackgroundGeolocationService' needs to be compiled using the JIT compiler” when `@angular/compiler` is not available). Entry point is `angular/public-api.ts`; package exports point to `angular/dist/`.
+- **Angular:** Removed redundant files: `angular/index.ts`, `angular/tsconfig.lib.json`, and legacy tsc output (root-level `*.js` / `*.d.ts` in `angular/`). Only the ng-packagr build in `angular/dist/` is used.
+- **README:** New section *“Android: configuring your app (recommended)”*: how to force `foregroundServiceType="location"` in the app’s AndroidManifest with `tools:replace`, optionally disable `BootCompletedReceiver` at boot, and required `strings.xml` entries for the plugin’s sync account (`plugin_bgloc_account_name`, `plugin_bgloc_account_type`, `plugin_bgloc_content_authority`).
+- **package-lock.json:** Kept in sync with `package.json` (e.g. zone.js) so `npm ci` succeeds in CI.
+
+[Full Changelog](https://github.com/josuelmm/cordova-background-geolocation/compare/3.0.0...3.0.1)
+
+---
+
 ## [3.0.0](https://github.com/josuelmm/cordova-background-geolocation/tree/3.0.0) (2026-02-20)
 
 ### Added

package/README.md

@@ -63,6 +63,40 @@ cordova plugin add @josuelmm/cordova-background-geolocation \
 - **Android 13+:** Request runtime `POST_NOTIFICATION` permission if you want the tracking notification to show.
 - After changing plugin options, remove and reinstall the plugin for changes to take effect.
 
+### Android: configuring your app (recommended)
+
+If your app’s merged manifest ends up with a `foregroundServiceType` other than `location` (e.g. due to other libraries or templates), you may see *"foregroundServiceType 0x00000004 is not a subset of ..."* and the tracking notification may not show. To **force** the correct type and avoid starting the service at boot without permissions, add the following in **your** Android project (the app that consumes the plugin).
+
+**1. AndroidManifest.xml** (inside `<application>`, and add `xmlns:tools="http://schemas.android.com/tools"` on the root `<manifest>` if not already present):
+
+```xml
+<!-- Background Location Service: force foregroundServiceType="location" in the merged manifest -->
+<service
+    android:name="com.marianhello.bgloc.service.LocationServiceImpl"
+    android:exported="false"
+    android:foregroundServiceType="location"
+    tools:replace="android:foregroundServiceType" />
+
+<!-- Optional: disable start on boot to avoid ForegroundServiceDidNotStartInTimeException when location permission is not granted -->
+<receiver
+    android:name="com.marianhello.bgloc.BootCompletedReceiver"
+    android:enabled="false"
+    tools:replace="android:enabled" />
+```
+
+`tools:replace="android:foregroundServiceType"` makes the merged manifest use your `location` value instead of whatever another dependency might declare, so the type matches what the plugin uses in `startForeground()`.
+
+**2. res/values/strings.xml** (required by the plugin for the sync account; replace `site.seelight.client` with your app’s package or identifier if different):
+
+```xml
+<!-- Required by cordova-background-geolocation-plugin (sync account) -->
+<string name="plugin_bgloc_account_name">Background location</string>
+<string name="plugin_bgloc_account_type">site.seelight.client.bgloc.account</string>
+<string name="plugin_bgloc_content_authority">site.seelight.client.bgloc</string>
+```
+
+This makes your app enforce the correct foreground service type and defines the strings the plugin needs for the sync account.
+
 ---
 
 ## Usage (with or without Angular)

package/android/common/src/main/AndroidManifest.xml

@@ -45,7 +45,11 @@
             android:authorities="@string/plugin_bgloc_content_authority"
             android:exported="false"
             android:syncable="true"/>
-        <service android:enabled="true" android:exported="false" android:name="com.marianhello.bgloc.service.LocationServiceImpl" />
+        <service
+            android:enabled="true"
+            android:exported="false"
+            android:name="com.marianhello.bgloc.service.LocationServiceImpl"
+            android:foregroundServiceType="location" />
         <receiver android:enabled="true" android:exported="true" android:name="com.marianhello.bgloc.BootCompletedReceiver">
             <intent-filter>
                 <action android:name="android.intent.action.BOOT_COMPLETED" />

package/android/common/src/main/java/com/marianhello/bgloc/service/LocationServiceImpl.java

@@ -18,7 +18,9 @@ import android.content.ContentResolver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
+import android.content.ComponentName;
 import android.content.pm.PackageManager;
+import android.content.pm.ServiceInfo;
 import android.Manifest;
 import android.net.ConnectivityManager;
 import android.net.NetworkInfo;
@@ -475,6 +477,61 @@ public class LocationServiceImpl extends Service implements ProviderDelegate, Lo
                 || checkSelfPermission(Manifest.permission.ACCESS_COARSE_LOCATION) == PackageManager.PERMISSION_GRANTED;
     }
 
+    /** FOREGROUND_SERVICE_TYPE_LOCATION = 4 when compileSdk >= 34. */
+    private static final int FOREGROUND_SERVICE_TYPE_LOCATION = 4;
+
+    /**
+     * Reads this service's foregroundServiceType from the merged AndroidManifest (API 34+).
+     * The type passed to startForeground() must be a subset of the value declared in the manifest.
+     * On API 33+ we use getServiceInfo(ComponentName, ComponentInfoFlags) because the deprecated
+     * getServiceInfo(component, int) can return an incomplete ServiceInfo (foregroundServiceType=0),
+     * which would make us fall back to 4 while the system validates against the real manifest (e.g. 0x9) and crash.
+     */
+    private int getForegroundServiceTypeFromManifest() {
+        if (Build.VERSION.SDK_INT < 34) {
+            return FOREGROUND_SERVICE_TYPE_LOCATION;
+        }
+        try {
+            ComponentName component = new ComponentName(this, getClass());
+            ServiceInfo info = getServiceInfoApi33Plus(component);
+            if (info != null) {
+                int type = getForegroundServiceTypeFromServiceInfo(info);
+                if (type != 0) return type;
+            }
+        } catch (Throwable e) {
+            logger.warn("Could not read foregroundServiceType from manifest: {}", e.getMessage());
+        }
+        return FOREGROUND_SERVICE_TYPE_LOCATION;
+    }
+
+    /** Calls getServiceInfo with ComponentInfoFlags on API 33+ so the result includes foregroundServiceType. */
+    private ServiceInfo getServiceInfoApi33Plus(ComponentName component) throws Exception {
+        if (Build.VERSION.SDK_INT < 33) {
+            return getPackageManager().getServiceInfo(component, PackageManager.GET_META_DATA);
+        }
+        // API 33+: use ComponentInfoFlags so getServiceInfo returns complete ServiceInfo (avoid deprecated int overload).
+        Class<?> flagsClass = Class.forName("android.content.pm.PackageManager$ComponentInfoFlags");
+        java.lang.reflect.Method ofMethod = flagsClass.getMethod("of", long.class);
+        Object flags = ofMethod.invoke(null, (long) PackageManager.GET_META_DATA);
+        java.lang.reflect.Method getServiceInfoMethod = getPackageManager().getClass().getMethod("getServiceInfo", ComponentName.class, flagsClass);
+        return (ServiceInfo) getServiceInfoMethod.invoke(getPackageManager(), component, flags);
+    }
+
+    /** Reads foregroundServiceType from ServiceInfo (API 34 field; use reflection to compile with any compileSdk). */
+    private int getForegroundServiceTypeFromServiceInfo(ServiceInfo info) {
+        try {
+            java.lang.reflect.Field f = ServiceInfo.class.getField("foregroundServiceType");
+            Object v = f.get(info);
+            if (v instanceof Integer) {
+                int type = (Integer) v;
+                if (type != 0) return type;
+            }
+        } catch (Throwable ignored) {
+            // field not present on older compileSdk / runtime
+        }
+        return 0;
+    }
+
     @Override
     public void startForeground() {
         if (sIsRunning && !mIsInForeground) {
@@ -494,10 +551,12 @@ public class LocationServiceImpl extends Service implements ProviderDelegate, Lo
                 mProvider.onCommand(LocationProvider.CMD_SWITCH_MODE,
                         LocationProvider.FOREGROUND_MODE);
             }
-            // Android 14+ (API 34) requires foreground service type for location services.
-            // Use literal 4 (FOREGROUND_SERVICE_TYPE_LOCATION) so this compiles with compileSdk < 34.
+            // Android 14+ (API 34): type passed to startForeground() must match the service's
+            // foregroundServiceType in the merged manifest (e.g. "location"=4 or "dataSync|specialUse"=0x9).
             if (Build.VERSION.SDK_INT >= 34) {
-                super.startForeground(NOTIFICATION_ID, notification, 4 /* ServiceInfo.FOREGROUND_SERVICE_TYPE_LOCATION */);
+                int serviceType = getForegroundServiceTypeFromManifest();
+                logger.info("startForeground serviceType=0x{}", Integer.toHexString(serviceType));
+                super.startForeground(NOTIFICATION_ID, notification, serviceType);
             } else {
                 super.startForeground(NOTIFICATION_ID, notification);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@josuelmm/cordova-background-geolocation",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "Cordova Background Geolocation (fork actualizado)",
   "main": "./www/BackgroundGeolocation.js",
   "types": "./www/BackgroundGeolocation.d.ts",

package/plugin.xml

@@ -2,7 +2,7 @@
 <plugin xmlns="http://www.phonegap.com/ns/plugins/1.0"
     xmlns:android="http://schemas.android.com/apk/res/android"
     id="cordova-background-geolocation"
-    version="3.0.0">
+    version="3.0.1">
     <name>cordova-background-geolocation</name>
     <description>Cordova Background Geolocation Plugin</description>
     <license>Apache-2.0</license>
@@ -157,7 +157,7 @@
                 android:enabled="true"
                 android:exported="false"
                 android:name="com.marianhello.bgloc.service.LocationServiceImpl"
-                android:foregroundServiceType="location"
+                android:foregroundServiceType="location|dataSync"
                 />
             <receiver
                   android:name="com.marianhello.bgloc.BootCompletedReceiver"
@@ -184,6 +184,7 @@
             <uses-permission android:name="android.permission.INTERNET" />
             <uses-permission android:name="android.permission.WAKE_LOCK" />
             <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+            <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />
             <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
             <uses-permission android:name="android.permission.FOREGROUND_SERVICE_LOCATION" />
             <uses-permission android:name="android.hardware.location" />