@josuelmm/cordova-background-geolocation 3.2.0 → 4.2.2

package/README.md

@@ -193,15 +193,19 @@ Set your preferred provider, accuracy, intervals, and optional server URLs. All
 | `syncUrl` | Server URL where **pending** locations are sent in batch (when count reaches `syncThreshold` or on `forceSync()`) |
 | `syncThreshold` | Number of pending locations before automatic batch sync (default 100) |
 | `sync` | When `true` (default), automatic sync and `forceSync()` run. When `false`, sync is disabled (locations are still stored). |
-| `httpHeaders` | Headers for every POST (e.g. `{ 'Content-Type': 'application/json', 'Authorization': 'Bearer TOKEN' }`) |
-| `postTemplate` | Object or array of properties to send (use `@latitude`, `@longitude`, etc.). See [Custom post template](docs/api.md#custom-post-template). |
+| `httpHeaders` / `headers` | Headers for every request (e.g. `{ 'Content-Type': 'application/json', 'Authorization': 'Bearer TOKEN' }`). `headers` is the alias added in 3.3.0; both are supported. |
+| `httpMethod` | **Since 3.3.0.** HTTP method for `url`. `POST` (default) `| GET | PUT | PATCH`. Use `GET` together with URL templating to deliver positions through the query string. |
+| `syncHttpMethod` | **Since 3.3.0.** HTTP method for `syncUrl`. Same values as `httpMethod`. |
+| `httpMode` / `syncMode` | **Since 3.3.0.** `batch` (default) or `single` (one HTTP request per location). `single` is required when the corresponding method is `GET`. |
+| `queryParams` | **Since 3.3.0.** Static placeholder values for URL/body templating (e.g. `{ device_id: 'USER_123' }`). See [HTTP transport](docs/api.md#http-transport-since-330). |
+| `postTemplate` / `bodyTemplate` | Object or array of properties to send. Supports `@latitude`, `@longitude`, ... and the new `{latitude}`, `{lon}`, `{timestamp_iso}`, ... placeholders on string values. `bodyTemplate` is the alias added in 3.3.0. |
 | `maxLocations` | Max locations kept in DB (default 10000). Should be > `syncThreshold`. |
 
 **Android-only:** `notificationSyncTitle`, `notificationSyncText`, `notificationSyncCompletedText`, `notificationSyncFailedText` — texts shown in the notification while syncing (defaults in English; set for localization). `startForeground`, `notificationsEnabled`, `startOnBoot`, `stopOnTerminate`, `enableWatchdog`.
 
-**iOS-only:** `activityType`, `pauseLocationUpdates`, `saveBatteryOnBackground`.
+**iOS-only:** `activityType`, `pauseLocationUpdates`, `saveBatteryOnBackground`, `showsBackgroundLocationIndicator` (since 3.4.0; iOS 11+, shows the blue background indicator).
 
-Example:
+Example (default POST + JSON):
 
 ```js
 BackgroundGeolocation.configure({
@@ -215,6 +219,8 @@ BackgroundGeolocation.configure({
   interval: 10000,
   fastestInterval: 5000,
   activitiesInterval: 10000,
+  startOnBoot: true,
+  stopOnTerminate: false,
   url: 'https://yourserver.com/location',
   syncUrl: 'https://yourserver.com/location',
   syncThreshold: 5,
@@ -231,6 +237,21 @@ BackgroundGeolocation.configure({
 });
 ```
 
+Example (since 3.3.0, GET with URL templating — works against Traccar OsmAnd, GPSWox, custom REST, etc.):
+
+```js
+BackgroundGeolocation.configure({
+  url: 'https://your-backend/track?uid={uid}&lat={latitude}&lon={longitude}&t={timestamp_iso}&spd={speed}',
+  httpMethod: 'GET',
+  httpMode: 'single',
+  queryParams: { uid: 'USER_DEVICE_123' },
+  startOnBoot: true,
+  stopOnTerminate: false
+});
+```
+
+> **Android runtime permissions.** With `startOnBoot: true`, the app must request `ACCESS_FINE_LOCATION` first, then `POST_NOTIFICATIONS` (Android 13+), and finally `ACCESS_BACKGROUND_LOCATION` (Android 10+, the user must pick **Allow all the time**). Without the background permission the plugin will skip the start on boot. iOS does **not** allow auto-start on device boot (Apple restriction). See [Auto-start on Android boot](docs/api.md#auto-start-on-android-boot-since-330) for the full flow.
+
 ### 2. Start tracking
 
 ```js
@@ -347,6 +368,87 @@ Subscribe with `BackgroundGeolocation.on(eventName, callback)`. Unsubscribe with
 
 Full event payloads and options: [Events](docs/events.md). Full API (all options, all methods): [API](docs/api.md).
 
+### New in 4.2.2
+
+- Build hotfixes — required when consuming the plugin via Capacitor (Gradle 8.x):
+  - `PostLocationTask.postLocation`: cast `LocationTemplate.locationToJson` (returns `Object`) to the right `HttpPostService.postJSON` overload.
+  - `BackgroundGeolocationPlugin.buildDiagnostics`: wrap `facade.locationServicesEnabled()` in `try/catch (PluginException)`.
+
+### New in 4.2.0
+
+- **Real sensor fusion (Phase 8).** Optional accelerometer + gyroscope pipeline (`drivingEvents.sensorFusion: true`). On Android uses `Sensor.TYPE_LINEAR_ACCELERATION` + `Sensor.TYPE_GYROSCOPE`; on iOS uses `CMMotionManager.startDeviceMotionUpdatesToQueue` at 50 Hz.
+- **Sensor-driven `possibleCrash`.** When the pipeline detects `|a| ≥ crashImpactG` (default 3 g) during an active trip, emits `possibleCrash` with `source: "sensor"`. GPS-derived `possibleCrash` keeps emitting with `source: "gps"`. Detects parking-lot impacts that GPS alone misses.
+- **New event `phoneUsageWhileDriving`.** Sustained device interaction (gyro/accel jitter + screen on) during an active trip.
+- New thresholds in `drivingEvents`: `crashImpactG`, `sensorCrashCooldownMs`, `phoneUsageWindowMs`, `phoneUsageCooldownMs`.
+- Hot-reload: changes to `drivingEvents.sensorFusion` via `configure()` (re)start the pipeline without a full service restart.
+- Battery: pipeline only samples while a trip is active. Off by default — opt in with `sensorFusion: true`.
+
+```javascript
+BackgroundGeolocation.configure({
+  drivingEvents: {
+    enabled: true,
+    sensorFusion: true,        // v4.2 — opt in
+    crashImpactG: 3.0,         // |a| in g for sensor-driven possibleCrash (default 3.0)
+    phoneUsageWindowMs: 4000,
+    phoneUsageCooldownMs: 60000
+  }
+});
+
+BackgroundGeolocation.on('possibleCrash', (d) => {
+  // d.source === 'gps' (GPS heuristic) or 'sensor' (accelerometer impact, higher confidence)
+});
+BackgroundGeolocation.on('phoneUsageWhileDriving', (location) => {
+  // Sustained device interaction during an active trip with the screen on.
+});
+```
+
+Full reference (all thresholds, when to enable, iOS screen-on caveat): [docs/api.md → Driver insights](docs/api.md#driver-insights-since-400).
+
+### New in 4.1.0
+
+- **GPS-derived driving events.** Four new events: `hardBrake`, `rapidAcceleration`, `sharpTurn`, `possibleCrash`. All derived from GPS speed and bearing — **no accelerometer/gyroscope required**. Configure thresholds via the extended `drivingEvents` config (`hardBrakeMps2`, `rapidAccelMps2`, `sharpTurnDegPerSec`, `crashImpactKmh`, `crashWindowMs`). Each event has a 4 s cooldown.
+- `possibleCrash` is heuristic. **Always confirm with the user** before notifying contacts; false positives are expected (sudden tunnel exit, GPS glitches).
+- TypeScript: 4 new typed `on()` overloads with `{ location, value }` payloads.
+- v4.2 adds real sensor fusion on top of these events.
+
+### New in 4.0.0
+
+- **Driver insights (Phase 6).** New GPS-only state machine emits `tripStart`, `tripEnd`, `moving`, `stopped`, `speeding`, `providerChange`, `sos` events end-to-end (Android + iOS). Configure thresholds via the new `drivingEvents` option.
+- New method **`triggerSOS(payload?)`** — fires a single `sos` event with the latest known location plus your payload. The host app handles the actual SOS workflow (notify contacts, push, alarm UI).
+- The Angular service exposes `triggerSOS()`.
+- ✅ Driving events (`hardBrake`, `rapidAcceleration`, `sharpTurn`, `possibleCrash`) ya están disponibles en v4.1.0 — derivados de GPS (sin sensores adicionales). Real sensor fusion (acelerómetro/giroscopio) se planea para v4.2.
+
+### New in 3.6.0
+
+- **Battery / OEM helpers (Phase 5).** Five new methods to guide the user through the steps required for reliable background tracking on aggressive OEMs:
+  - `isIgnoringBatteryOptimizations()` — Android Doze whitelist state.
+  - `requestIgnoreBatteryOptimizations()` — opens the system dialog.
+  - `openBatterySettings()` — opens the per-app battery screen.
+  - `openAutoStartSettings()` — opens the OEM-specific auto-start screen on Xiaomi MIUI, Huawei EMUI, Oppo ColorOS, Vivo FunTouch, OnePlus, Asus (Samsung falls back to app-info).
+  - `getManufacturerHelp()` — returns OEM-specific guidance text the app can render as a help screen.
+- The Angular service exposes all 5 methods.
+- Combine with `getDiagnostics()` to build a "Tracking is being killed by your phone — fix it here" flow.
+
+### New in 3.5.0
+
+- **`getDiagnostics()` (Phase 4).** New extended diagnostics method that helps you debug "tracking is not running" in production. Returns permissions (`fineLocationGranted`, `coarseLocationGranted`, `backgroundLocationGranted`, `notificationPermissionGranted`, `activityRecognitionGranted`), battery optimisation state (`batteryOptimizationIgnored`), OEM manufacturer (`manufacturer`), last-fix timestamp, pending sync count, declared `foregroundServiceType` (Android), and `preciseLocationEnabled`, `backgroundRefreshStatus`, `lowPowerModeEnabled`, `motionPermissionStatus` (iOS). Use it to surface actionable hints to users like "Allow all the time" or "Disable battery optimisation". See [getDiagnostics](docs/api.md#getdiagnosticssuccess-fail).
+- **`mockLocationPolicy: 'allow' | 'flag' | 'drop'`** — policy for mocked locations. Detection (`isFromMockProvider` Android, `simulated` iOS) was already present; this option controls what to do with those samples. Recommended for anti-fraud: `'flag'` (keep them but tagged) or `'drop'` (discard).
+- **`heartbeatInterval`** option plus events `heartbeat`, `syncStart`, `syncProgress`, `syncSuccess`, `syncError` are all wired end-to-end with native emission on Android and iOS. Subscribe via `BackgroundGeolocation.on('heartbeat', cb)` etc.
+- The Angular service exposes `getDiagnostics()` directly.
+
+### New in 3.4.0
+
+- **Location API modernization (Phase 3).** The Android Activity provider now uses `LocationRequest.Builder` + `Priority.PRIORITY_*` (replaces the deprecated `LocationRequest.create()` / `setPriority` / `setInterval` / `LocationRequest.PRIORITY_*` family from `play-services-location 21.0.0+`). The Distance Filter and Raw providers no longer use the deprecated `Criteria` API; provider selection is now an explicit GPS-first / Network-fallback. iOS migrates `[NSURLConnection sendSynchronousRequest:]` (deprecated since iOS 9) to `NSURLSession + dispatch_semaphore`, and adds the iOS 14+ `locationManagerDidChangeAuthorization:` callback alongside the legacy one.
+- **`showsBackgroundLocationIndicator`** (iOS 11+). Set to `true` to display the blue status indicator while the app uses location in the background.
+- **Bug fixes:** iOS `activitiesInterval` is now correctly read from the dictionary (the previous `isNull` check was inverted, dropping user input). Android `Content-Length` is computed in UTF-8 byte length instead of `String.length()`, so multi-byte characters (`ñ`, `é`, emoji) no longer mismatch the body size.
+- **Default `GOOGLE_PLAY_SERVICES_VERSION`** raised to `21.0.1`. Apps that override it via `--variable` keep their override.
+
+### New in 3.3.0
+
+- **Auto-start Android (Phase 1).** The plugin's boot receiver now also handles `QUICKBOOT_POWERON` (HTC, MIUI / Xiaomi), `com.htc.intent.action.QUICKBOOT_POWERON`, and `MY_PACKAGE_REPLACED` (the service relaunches after a Play Store update). Added `ACCESS_BACKGROUND_LOCATION` to the manifest with runtime validation on Android 10+. `ForegroundServiceStartNotAllowedException` (Android 12+) is caught with clear logging — WorkManager is **not** used as a fallback for tracking. The `foregroundServiceType` is now `"location"` only (dropped `dataSync`); the runtime type is read dynamically from the merged manifest. `<uses-library org.apache.http.legacy>` and `useLibrary 'org.apache.http.legacy'` are removed (the plugin uses `HttpURLConnection`). `jcenter()` → `mavenCentral()`.
+- **Backend-agnostic HTTP transport (Phase 2).** New `httpMethod`, `syncHttpMethod`, `httpMode`, `syncMode`, `queryParams`, `headers` (alias of `httpHeaders`), `bodyTemplate` (alias of `postTemplate`). URL templating with `{latitude}`, `{longitude}`, `{lat}`, `{lon}`, `{time}`, `{timestamp}`, `{timestamp_iso}`, `{speed}`, `{altitude}`, `{bearing}`, `{accuracy}`, `{provider}` and any keys from `queryParams`. The plugin no longer hardcodes `POST` on Android (`HttpPostService`) or iOS (`MAURPostLocationTask`, `MAURBackgroundSync`). Compatibility is fully preserved — apps that only set `url` + `httpHeaders` + `postTemplate` keep working unchanged. See [HTTP transport](docs/api.md#http-transport-since-330) for backend examples (REST, GET single, form-urlencoded, Firebase, n8n).
+- **Engines:** `cordova-android >= 12.0.0` is now the minimum.
+
 ### New in 3.2.0
 
 - **Session API for route/recording** — Store all locations for the *current route* in the plugin, independent of sync. When the user reopens the app without internet, you can restore the full track from the plugin (no need for `localStorage` for points).
@@ -435,6 +537,89 @@ No extra wrapper (e.g. Awesome Cordova Plugins) is required.
 
 ## Compatibility
 
+| Plugin version | Cordova CLI | Cordova Android | Cordova iOS |
+|----------------|-------------|-----------------|-------------|
+| 1.x            | ≥ 8.0.0     | ≥ 8.0.0         | ≥ 6.0.0     |
+| 2.x            | ≥ 10.0.0    | ≥ 10.0.0        | ≥ 6.0.0     |
+| 3.0.x – 3.2.x  | ≥ 10.0.0    | ≥ 10.0.0        | ≥ 6.0.0     |
+| 3.3.x – 4.1.x  | ≥ 10.0.0    | ≥ 12.0.0        | ≥ 6.2.0     |
+
+> 3.3.0+: `cordova-android >= 12` is required for `targetSdk 34+` and the modernised foreground-service handling. The new iOS APIs (`showsBackgroundLocationIndicator` iOS 11+, `locationManagerDidChangeAuthorization:` iOS 14+) are gated by runtime `@available` checks, so older iOS versions still link and run.
+
+---
+
+## Documentation and changelog
+
+This README is the main entry point. For more detail, edge cases and examples use the docs below (and the [online documentation](https://josuelmm.github.io/cordova-background-geolocation/)).
+
+| Doc | What you'll find |
+|-----|------------------|
+| **[API reference](docs/api.md)** | Every `configure` option, every method (`configure`, `start`, `stop`, `getPendingSyncCount`, `forceSync`, `clearSync`, `startSession`, `getSessionLocations`, `clearSession`, `getSessionLocationsCount`, `getConfig`, `getLocations`, etc.), TypeScript types. Also covers the **HTTP transport (3.3.0)** and **auto-start on Android boot (3.3.0)**. |
+| **[HTTP transport (3.3.0)](docs/http-transport.md)** | `httpMethod`, `httpMode`, URL templating, `bodyTemplate`, `queryParams`, examples for REST, GET single, form-urlencoded, Firebase, n8n, Traccar. |
+| **[Auto-start on boot (3.3.0)](docs/auto-start.md)** | Android receiver actions, `ACCESS_BACKGROUND_LOCATION` runtime flow, OEM caveats, iOS limitation. |
+| **[Traccar integration example](docs/traccar.md)** | Optional backend: how to deliver positions to Traccar (or Firebase, n8n, custom REST) via the HTTP transport. The plugin is backend-agnostic. |
+| **[Location modernization (3.4.0)](docs/location-modernization.md)** | What was modernised in Phase 3 (LocationRequest.Builder, NSURLSession, iOS 14+ auth callback) and what is still legacy. |
+| **[Roadmap](docs/ROADMAP.md)** | Phases 1–6, what's released, what's next. |
+| **[HTTP posting](docs/http_posting.md)** | `url` vs `syncUrl`, Content-Type (JSON = one POST with array; form-urlencoded = one POST per location), headers, retries, `postTemplate`, sync behaviour. |
+| **[Events](docs/events.md)** | All events (`location`, `error`, `stationary`, `activity`, `http_authorization`, etc.) and payloads. |
+| **[Angular / Ionic](docs/angular.md)** | Injectable service, module, lazy-loaded modules and token "must be defined", `ng serve` / browser build. |
+| **[Example](docs/example.md)** | Full example with events and sync. |
+| **[CHANGELOG](CHANGELOG.md)** | Version history. |
+
+This project is based on [@mauron85/cordova-plugin-background-geolocation](https://github.com/mauron85/cordova-plugin-background-geolocation) and the original by [christocracy](https://github.com/christocracy). Maintained at [josuelmm/cordova-background-geolocation](https://github.com/josuelmm/cordova-background-geolocation). Issues and PRs welcome.
+
+---
+
+## Licence
+
+[Apache License](http://www.apache.org/licenses/LICENSE-2.0)
+
+Copyright (c) 2013 Christopher Scott, Transistor Software
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+    return this.bg.on('location', (loc: BackgroundGeolocationResponse) => console.log(loc));
+    // subscription.unsubscribe() when done
+  }
+}
+```
+
+**You must import `BackgroundGeolocationModule`** in your `AppModule` (or feature module) so the service is provided and AOT builds work. Then inject `BackgroundGeolocationService` as in the example above. See [docs/angular.md](docs/angular.md) for the full snippet.
+
+**`ng serve` / browser:** From 3.1.1 the plugin includes browser stubs so `ng serve` and web builds complete without "Can't resolve 'cordova/exec'" — see [docs/angular.md](docs/angular.md#build-ng-serve--browser).
+
+**Lazy-loaded pages:** If you see **NG0202** or *"dependency at index N is invalid"* when opening a page that injects this service, use an app-defined token and inject by that token (the plugin token can be undefined in the lazy chunk). See [docs/angular.md](docs/angular.md) (Lazy-loaded modules).
+
+**Migrating from @awesome-cordova-plugins/background-geolocation:** there you inject a class named `BackgroundGeolocation`. In this package, `BackgroundGeolocation` is the **global plugin object**, not an injectable class. Use `BackgroundGeolocationService` instead (same API). See [docs/angular.md](docs/angular.md) for details.
+
+### Summary
+
+| Use case              | What to do |
+|-----------------------|------------|
+| **Without Angular**   | Use global `BackgroundGeolocation` after `deviceready`. Types: main package or Awesome-style aliases (see [TypeScript imports](#typescript-imports) above). |
+| **With Angular**      | Import from `@josuelmm/cordova-background-geolocation/angular`: add `BackgroundGeolocationModule` to your module `imports`, then inject `BackgroundGeolocationService`. Do **not** inject the global `BackgroundGeolocation`. |
+
+No extra wrapper (e.g. Awesome Cordova Plugins) is required.
+
+---
+
+## Compatibility
+
 | Plugin version | Cordova CLI | Cordova Android | Cordova iOS |
 |----------------|-------------|-----------------|-------------|
 | 1.x            | ≥ 8.0.0     | ≥ 8.0.0         | ≥ 6.0.0     |

package/android/CDVBackgroundGeolocation/src/main/java/com/marianhello/bgloc/cordova/ConfigMapper.java

@@ -99,12 +99,17 @@ public class ConfigMapper {
         if (jObject.has("sync")) {
             config.setSyncEnabled(jObject.getBoolean("sync"));
         }
+        // headers (alias of httpHeaders)
         if (jObject.has("httpHeaders")) {
             config.setHttpHeaders(jObject.getJSONObject("httpHeaders"));
         }
+        if (jObject.has("headers")) {
+            config.setHttpHeaders(jObject.getJSONObject("headers"));
+        }
         if (jObject.has("maxLocations")) {
             config.setMaxLocations(jObject.getInt("maxLocations"));
         }
+        // bodyTemplate (alias of postTemplate)
         if (jObject.has("postTemplate")) {
             if (jObject.isNull("postTemplate")) {
                 config.setTemplate(LocationTemplateFactory.getDefault());
@@ -113,6 +118,60 @@ public class ConfigMapper {
                 config.setTemplate(LocationTemplateFactory.fromJSON(postTemplate));
             }
         }
+        if (jObject.has("bodyTemplate")) {
+            if (jObject.isNull("bodyTemplate")) {
+                config.setTemplate(LocationTemplateFactory.getDefault());
+            } else {
+                Object bodyTemplate = jObject.get("bodyTemplate");
+                config.setTemplate(LocationTemplateFactory.fromJSON(bodyTemplate));
+            }
+        }
+        // v3.3 Phase 2: HTTP transport
+        if (jObject.has("httpMethod") && !jObject.isNull("httpMethod")) {
+            config.setHttpMethod(jObject.getString("httpMethod"));
+        }
+        if (jObject.has("syncHttpMethod") && !jObject.isNull("syncHttpMethod")) {
+            config.setSyncHttpMethod(jObject.getString("syncHttpMethod"));
+        }
+        if (jObject.has("httpMode") && !jObject.isNull("httpMode")) {
+            config.setHttpMode(jObject.getString("httpMode"));
+        }
+        if (jObject.has("syncMode") && !jObject.isNull("syncMode")) {
+            config.setSyncMode(jObject.getString("syncMode"));
+        }
+        if (jObject.has("queryParams") && !jObject.isNull("queryParams")) {
+            config.setQueryParams(jObject.getJSONObject("queryParams"));
+        }
+        if (jObject.has("heartbeatInterval") && !jObject.isNull("heartbeatInterval")) {
+            config.setHeartbeatInterval(jObject.getInt("heartbeatInterval"));
+        }
+        if (jObject.has("mockLocationPolicy") && !jObject.isNull("mockLocationPolicy")) {
+            config.setMockLocationPolicy(jObject.getString("mockLocationPolicy"));
+        }
+        // v4.0 Phase 6: drivingEvents
+        if (jObject.has("drivingEvents") && !jObject.isNull("drivingEvents")) {
+            JSONObject de = jObject.getJSONObject("drivingEvents");
+            Config.DrivingEventsOptions opts = new Config.DrivingEventsOptions();
+            if (de.has("enabled"))          opts.enabled            = de.getBoolean("enabled");
+            if (de.has("speedLimit"))       opts.speedLimitKmh      = de.getDouble("speedLimit");
+            if (de.has("minMovingSpeed"))   opts.minMovingSpeedMps  = de.getDouble("minMovingSpeed");
+            if (de.has("stoppedDuration"))  opts.stoppedDurationMs  = de.getLong("stoppedDuration");
+            if (de.has("minTripSpeed"))     opts.minTripSpeedMps    = de.getDouble("minTripSpeed");
+            if (de.has("minTripDuration"))  opts.minTripDurationMs  = de.getLong("minTripDuration");
+            // v4.1
+            if (de.has("hardBrakeMps2"))    opts.hardBrakeMps2      = de.getDouble("hardBrakeMps2");
+            if (de.has("rapidAccelMps2"))   opts.rapidAccelMps2     = de.getDouble("rapidAccelMps2");
+            if (de.has("sharpTurnDegPerSec")) opts.sharpTurnDegPerSec = de.getDouble("sharpTurnDegPerSec");
+            if (de.has("crashImpactKmh"))   opts.crashImpactKmh     = de.getDouble("crashImpactKmh");
+            if (de.has("crashWindowMs"))    opts.crashWindowMs      = de.getLong("crashWindowMs");
+            // v4.2 sensor fusion
+            if (de.has("sensorFusion"))         opts.sensorFusion           = de.getBoolean("sensorFusion");
+            if (de.has("crashImpactG"))         opts.crashImpactG           = de.getDouble("crashImpactG");
+            if (de.has("sensorCrashCooldownMs"))opts.sensorCrashCooldownMs  = de.getLong("sensorCrashCooldownMs");
+            if (de.has("phoneUsageWindowMs"))   opts.phoneUsageWindowMs     = de.getLong("phoneUsageWindowMs");
+            if (de.has("phoneUsageCooldownMs")) opts.phoneUsageCooldownMs   = de.getLong("phoneUsageCooldownMs");
+            config.setDrivingEvents(opts);
+        }
         if (jObject.has("enableWatchdog")) {
             config.setEnableWatchdog(jObject.getBoolean("enableWatchdog"));
         }
@@ -175,6 +234,37 @@ public class ConfigMapper {
 
         json.put("postTemplate", template);
 
+        json.put("httpMethod", config.getHttpMethod());
+        json.put("syncHttpMethod", config.getSyncHttpMethod());
+        json.put("httpMode", config.getHttpMode());
+        json.put("syncMode", config.getSyncMode());
+        json.put("queryParams", config.getQueryParams() != null ? new JSONObject(config.getQueryParams()) : JSONObject.NULL);
+        json.put("heartbeatInterval", config.getHeartbeatInterval());
+        json.put("mockLocationPolicy", config.getMockLocationPolicy());
+
+        Config.DrivingEventsOptions de = config.getDrivingEvents();
+        if (de != null) {
+            JSONObject deJson = new JSONObject();
+            deJson.put("enabled", de.enabled);
+            deJson.put("speedLimit", de.speedLimitKmh);
+            deJson.put("minMovingSpeed", de.minMovingSpeedMps);
+            deJson.put("stoppedDuration", de.stoppedDurationMs);
+            deJson.put("minTripSpeed", de.minTripSpeedMps);
+            deJson.put("minTripDuration", de.minTripDurationMs);
+            deJson.put("hardBrakeMps2", de.hardBrakeMps2);
+            deJson.put("rapidAccelMps2", de.rapidAccelMps2);
+            deJson.put("sharpTurnDegPerSec", de.sharpTurnDegPerSec);
+            deJson.put("crashImpactKmh", de.crashImpactKmh);
+            deJson.put("crashWindowMs", de.crashWindowMs);
+            // v4.2 sensor fusion
+            deJson.put("sensorFusion", de.sensorFusion);
+            deJson.put("crashImpactG", de.crashImpactG);
+            deJson.put("sensorCrashCooldownMs", de.sensorCrashCooldownMs);
+            deJson.put("phoneUsageWindowMs", de.phoneUsageWindowMs);
+            deJson.put("phoneUsageCooldownMs", de.phoneUsageCooldownMs);
+            json.put("drivingEvents", deJson);
+        }
+
         return json;
     }
 }