react-native-nitro-location-tracking 0.1.11 → 0.1.13

package/README.md

@@ -703,14 +703,17 @@ type PermissionStatus =
 | `stopTripCalculation()`                      | `TripStats`                 | Stop recording and get final stats                                                       |
 | `getTripStats()`                             | `TripStats`                 | Get current trip stats without stopping                                                  |
 | `resetTripCalculation()`                     | `void`                      | Reset trip calculator                                                                    |
-| `isLocationServicesEnabled()`                | `boolean`                   | Check if GPS/location is enabled on device                                               |
-| `onProviderStatusChange(callback)`           | `void`                      | Register GPS/network provider status callback                                            |
-| `getLocationPermissionStatus()`              | `PermissionStatus`          | Check current location permission without prompting                                      |
-| `requestLocationPermission()`                | `Promise<PermissionStatus>` | Request location permission and return the resulting status                              |
-| `onPermissionStatusChange(callback)`         | `void`                      | Register a callback that fires when location permission status changes                   |
-| `showLocalNotification(title, body)`         | `void`                      | Show a local notification                                                                |
-| `updateForegroundNotification(title, body)`  | `void`                      | Update the foreground service notification                                               |
-| `destroy()`                                  | `void`                      | Stop tracking and disconnect                                                             |
+| `isLocationServicesEnabled()`                | `boolean`                   | Check if GPS/location is enabled on device                               |
+| `openLocationSettings(accuracy, interval)`   | `void`                      | Native app dialog to enable GPS or redirect to system settings           |
+| `onProviderStatusChange(callback)`           | `void`                      | Register GPS/network provider status callback                            |
+| `isAirplaneModeEnabled()`                    | `boolean`                   | Check if Airplane mode is active on Android                              |
+| `onAirplaneModeChange(callback)`             | `void`                      | Register Airplane mode state-transition callback                         |
+| `getLocationPermissionStatus()`              | `PermissionStatus`          | Check current location permission without prompting                      |
+| `requestLocationPermission()`                | `Promise<PermissionStatus>` | Request location permission and return the resulting status              |
+| `onPermissionStatusChange(callback)`         | `void`                      | Register a callback that fires when location permission status changes   |
+| `showLocalNotification(title, body)`         | `void`                      | Show a local notification                                                |
+| `updateForegroundNotification(title, body)`  | `void`                      | Update the foreground service notification                               |
+| `destroy()`                                  | `void`                      | Stop tracking and disconnect                                             |
 
 ### Utility Exports
 
@@ -721,6 +724,25 @@ type PermissionStatus =
 | `shortestRotation(from, to)`  | Calculate shortest rotation path to avoid spinning         |
 | `requestLocationPermission()` | Request location + notification permissions (Android)      |
 
+### Pure C++ Math Engine
+
+For computationally heavy tasks like array slicing and trip mapping, use the pure C++ Math Engine to bypass the JS thread entirely.
+
+```typescript
+import { NitroLocationCalculations } from 'react-native-nitro-location-tracking';
+
+// Instantly compute heavy math directly in C++
+const stats = NitroLocationCalculations.calculateTotalTripStats(points);
+```
+
+| Method | Returns | Description |
+| :--- | :--- | :--- |
+| `calculateTotalTripStats(points)` | `TripMathStats` | Instantly computes exact Haversine distance, time, and max/average speed over an array of thousands of points. |
+| `filterAnomalousPoints(points, maxSpeedMps)` | `LocationPoint[]` | Cleans an array of points by mathematically stripping out teleportation jumps that exceed the given speed limit. |
+| `smoothPath(points, toleranceMeters)` | `LocationPoint[]` | Simplifies a highly dense GPS path into perfect drawing lines using the Ramer-Douglas-Peucker algorithm. |
+| `calculateBearing(lat1, lon1, lat2, lon2)` | `number` | Lightning fast C++ trigonometric bearing computation for raw coordinates. |
+| `encodeGeohash(lat, lon, precision)` | `string` | Converts coordinates into a Geohash string instantly representing geological boundaries. |
+
 ## Publishing to npm
 
 ### Prerequisites

package/android/CMakeLists.txt

@@ -6,7 +6,10 @@ set(CMAKE_VERBOSE_MAKEFILE ON)
 set(CMAKE_CXX_STANDARD 20)
 
 # Define C++ library and add all sources
-add_library(${PACKAGE_NAME} SHARED src/main/cpp/cpp-adapter.cpp)
+add_library(${PACKAGE_NAME} SHARED 
+  src/main/cpp/cpp-adapter.cpp
+  ../cpp/HybridNitroLocationComplexLogicsCalculation.cpp
+)
 
 # Add Nitrogen specs :)
 include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/nitrolocationtracking+autolinking.cmake)

package/android/src/main/java/com/margelo/nitro/nitrolocationtracking/AirplaneModeMonitor.kt

@@ -0,0 +1,72 @@
+package com.margelo.nitro.nitrolocationtracking
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.os.Build
+import android.provider.Settings
+import android.util.Log
+
+class AirplaneModeMonitor(private val context: Context) {
+
+    companion object {
+        private const val TAG = "AirplaneModeMonitor"
+    }
+
+    private var callback: ((Boolean) -> Unit)? = null
+    private var lastState: Boolean? = null
+    private var receiver: BroadcastReceiver? = null
+
+    fun setCallback(callback: (Boolean) -> Unit) {
+        this.callback = callback
+        
+        // Emit current state immediately
+        val current = isAirplaneModeEnabled()
+        lastState = current
+        callback.invoke(current)
+        
+        registerReceiver()
+    }
+
+    fun isAirplaneModeEnabled(): Boolean {
+        return Settings.Global.getInt(
+            context.contentResolver,
+            Settings.Global.AIRPLANE_MODE_ON, 0
+        ) != 0
+    }
+
+    private fun registerReceiver() {
+        if (receiver != null) return
+
+        receiver = object : BroadcastReceiver() {
+            override fun onReceive(context: Context?, intent: Intent?) {
+                if (intent?.action == Intent.ACTION_AIRPLANE_MODE_CHANGED) {
+                    val isAirplaneModeOn = intent.getBooleanExtra("state", false)
+                    if (isAirplaneModeOn != lastState) {
+                        lastState = isAirplaneModeOn
+                        Log.d(TAG, "Airplane mode changed: $isAirplaneModeOn")
+                        callback?.invoke(isAirplaneModeOn)
+                    }
+                }
+            }
+        }
+
+        val filter = IntentFilter(Intent.ACTION_AIRPLANE_MODE_CHANGED)
+        context.registerReceiver(receiver, filter)
+        Log.d(TAG, "Airplane mode receiver registered")
+    }
+
+    fun destroy() {
+        receiver?.let {
+            try {
+                context.unregisterReceiver(it)
+            } catch (e: Exception) {
+                Log.w(TAG, "Error unregistering receiver: ${e.message}")
+            }
+        }
+        receiver = null
+        callback = null
+        lastState = null
+    }
+}

package/android/src/main/java/com/margelo/nitro/nitrolocationtracking/MockLocationMonitor.kt

@@ -0,0 +1,145 @@
+package com.margelo.nitro.nitrolocationtracking
+
+import android.annotation.SuppressLint
+import android.app.AppOpsManager
+import android.content.Context
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import android.provider.Settings
+import android.util.Log
+
+/**
+ * Periodically polls whether a mock/fake GPS provider is active on the device.
+ * This works independently of location tracking — it detects the presence of
+ * mock location apps (e.g. Fake GPS, Mock Locations) at the system level.
+ *
+ * On each poll it checks:
+ * - Pre-API 23: Settings.Secure.ALLOW_MOCK_LOCATION
+ * - API 23+: AppOpsManager OP_MOCK_LOCATION (op code 58)
+ * - Also checks all installed packages for mock location permission
+ *
+ * The callback fires only when the state changes (deduplicated).
+ */
+class MockLocationMonitor(private val context: Context) {
+
+    companion object {
+        private const val TAG = "MockLocationMonitor"
+        /** Default poll interval in milliseconds */
+        private const val DEFAULT_POLL_INTERVAL_MS = 3000L
+    }
+
+    private val mainHandler = Handler(Looper.getMainLooper())
+    private var callback: ((Boolean) -> Unit)? = null
+    private var lastState: Boolean? = null
+    private var polling = false
+    private var pollIntervalMs = DEFAULT_POLL_INTERVAL_MS
+
+    private val pollRunnable = object : Runnable {
+        override fun run() {
+            if (!polling) return
+            checkAndNotify()
+            mainHandler.postDelayed(this, pollIntervalMs)
+        }
+    }
+
+    fun setCallback(callback: (Boolean) -> Unit) {
+        this.callback = callback
+        // Emit current state immediately
+        val current = isMockLocationActive()
+        lastState = current
+        callback.invoke(current)
+        // Start polling
+        startPolling()
+    }
+
+    fun startPolling() {
+        if (polling) return
+        polling = true
+        mainHandler.postDelayed(pollRunnable, pollIntervalMs)
+        Log.d(TAG, "Mock location polling started (interval=${pollIntervalMs}ms)")
+    }
+
+    fun stopPolling() {
+        polling = false
+        mainHandler.removeCallbacks(pollRunnable)
+        Log.d(TAG, "Mock location polling stopped")
+    }
+
+    private fun checkAndNotify() {
+        val current = isMockLocationActive()
+        if (current != lastState) {
+            lastState = current
+            Log.d(TAG, "Mock location state changed: isMockEnabled=$current")
+            callback?.invoke(current)
+        }
+    }
+
+    /**
+     * Comprehensive check for mock location activity on the device.
+     */
+    @SuppressLint("DiscouragedPrivateApi")
+    fun isMockLocationActive(): Boolean {
+        // Pre-API 23: check the global mock location setting
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+            @Suppress("DEPRECATION")
+            val mockSetting = Settings.Secure.getString(
+                context.contentResolver,
+                Settings.Secure.ALLOW_MOCK_LOCATION
+            )
+            return mockSetting == "1"
+        }
+
+        // API 23+: check if any app holds MOCK_LOCATION permission via AppOpsManager
+        try {
+            val appOps = context.getSystemService(Context.APP_OPS_SERVICE) as AppOpsManager
+            val opMockLocation = 58 // OP_MOCK_LOCATION
+            val method = AppOpsManager::class.java.getMethod(
+                "checkOp",
+                Int::class.javaPrimitiveType,
+                Int::class.javaPrimitiveType,
+                String::class.java
+            )
+            val result = method.invoke(
+                appOps, opMockLocation, android.os.Process.myUid(), context.packageName
+            ) as Int
+            if (result == AppOpsManager.MODE_ALLOWED) return true
+        } catch (e: Exception) {
+            Log.w(TAG, "Could not check mock location app ops: ${e.message}")
+        }
+
+        // Additional check: scan installed packages for known mock location apps
+        try {
+            val pm = context.packageManager
+            val knownMockApps = listOf(
+                "com.lexa.fakegps",
+                "com.incorporateapps.fakegps.fre",
+                "com.fakegps.mock",
+                "com.lkr.fakegps",
+                "com.fake.gps.go.location.spoofer.free",
+                "com.theappninjas.gpsjoystick",
+                "com.evezzon.fgl",
+                "com.mock.location"
+            )
+            for (pkg in knownMockApps) {
+                try {
+                    pm.getApplicationInfo(pkg, 0)
+                    Log.d(TAG, "Known mock location app detected: $pkg")
+                    return true
+                } catch (_: Exception) {
+                    // Not installed
+                }
+            }
+        } catch (e: Exception) {
+            Log.w(TAG, "Could not check for mock location apps: ${e.message}")
+        }
+
+        return false
+    }
+
+    fun destroy() {
+        stopPolling()
+        callback = null
+        lastState = null
+    }
+}

package/android/src/main/java/com/margelo/nitro/nitrolocationtracking/NitroLocationTracking.kt

@@ -27,6 +27,8 @@ class NitroLocationTracking : HybridNitroLocationTrackingSpec() {
     private var geofenceManager: GeofenceManager? = null
     private var providerStatusMonitor: ProviderStatusMonitor? = null
     private var permissionStatusMonitor: PermissionStatusMonitor? = null
+    private var mockLocationMonitor: MockLocationMonitor? = null
+    private var airplaneModeMonitor: AirplaneModeMonitor? = null
 
     private var locationCallback: ((LocationData) -> Unit)? = null
     private var motionCallback: ((Boolean) -> Unit)? = null
@@ -36,6 +38,8 @@ class NitroLocationTracking : HybridNitroLocationTrackingSpec() {
     private var speedAlertCallback: ((SpeedAlertType, Double) -> Unit)? = null
     private var providerStatusCallback: ((LocationProviderStatus, LocationProviderStatus) -> Unit)? = null
     private var permissionStatusCallback: ((PermissionStatus) -> Unit)? = null
+    private var mockLocationCallback: ((Boolean) -> Unit)? = null
+    private var airplaneModeCallback: ((Boolean) -> Unit)? = null
 
     private var locationConfig: LocationConfig? = null
 
@@ -53,6 +57,8 @@ class NitroLocationTracking : HybridNitroLocationTrackingSpec() {
         geofenceManager = GeofenceManager(context)
         providerStatusMonitor = ProviderStatusMonitor(context)
         permissionStatusMonitor = PermissionStatusMonitor(context)
+        mockLocationMonitor = MockLocationMonitor(context)
+        airplaneModeMonitor = AirplaneModeMonitor(context)
         locationEngine?.dbWriter = dbWriter
         connectionManager.dbWriter = dbWriter
         Log.d(TAG, "Components initialized successfully")
@@ -186,6 +192,12 @@ class NitroLocationTracking : HybridNitroLocationTrackingSpec() {
         locationEngine?.rejectMockLocations = reject
     }
 
+    override fun onMockLocationDetected(callback: (isMockEnabled: Boolean) -> Unit) {
+        mockLocationCallback = callback
+        ensureInitialized()
+        mockLocationMonitor?.setCallback(callback)
+    }
+
     // === Geofencing ===
 
     override fun addGeofence(region: GeofenceRegion) {
@@ -355,6 +367,67 @@ class NitroLocationTracking : HybridNitroLocationTrackingSpec() {
         }
     }
 
+    override fun openLocationSettings(accuracy: AccuracyLevel, intervalMs: Double) {
+        val context = NitroModules.applicationContext ?: return
+        val activity = (context as? com.facebook.react.bridge.ReactContext)?.currentActivity
+        
+        if (activity != null) {
+            val priority = when (accuracy) {
+                AccuracyLevel.BALANCED -> com.google.android.gms.location.Priority.PRIORITY_BALANCED_POWER_ACCURACY
+                AccuracyLevel.LOW -> com.google.android.gms.location.Priority.PRIORITY_LOW_POWER
+                else -> com.google.android.gms.location.Priority.PRIORITY_HIGH_ACCURACY
+            }
+            val interval = intervalMs.toLong()
+
+            val locationRequest = com.google.android.gms.location.LocationRequest.Builder(
+                priority, interval
+            ).build()
+            val builder = com.google.android.gms.location.LocationSettingsRequest.Builder()
+                .addLocationRequest(locationRequest)
+                .setAlwaysShow(true)
+                
+            val client = com.google.android.gms.location.LocationServices.getSettingsClient(context)
+            val task = client.checkLocationSettings(builder.build())
+
+            task.addOnFailureListener { exception ->
+                if (exception is com.google.android.gms.common.api.ResolvableApiException) {
+                    try {
+                        exception.startResolutionForResult(activity, 9002) // arbitrary request code
+                    } catch (e: Exception) {
+                        openLocationSettingsFallback(context)
+                    }
+                } else {
+                    openLocationSettingsFallback(context)
+                }
+            }
+        } else {
+            openLocationSettingsFallback(context)
+        }
+    }
+
+    private fun openLocationSettingsFallback(context: android.content.Context) {
+        val intent = android.content.Intent(android.provider.Settings.ACTION_LOCATION_SOURCE_SETTINGS)
+        intent.addFlags(android.content.Intent.FLAG_ACTIVITY_NEW_TASK)
+        try {
+            context.startActivity(intent)
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to open location settings: ${e.message}")
+        }
+    }
+
+    // === Device State Monitoring ===
+    
+    override fun isAirplaneModeEnabled(): Boolean {
+        ensureInitialized()
+        return airplaneModeMonitor?.isAirplaneModeEnabled() ?: false
+    }
+
+    override fun onAirplaneModeChange(callback: (isEnabled: Boolean) -> Unit) {
+        airplaneModeCallback = callback
+        ensureInitialized()
+        airplaneModeMonitor?.setCallback(callback)
+    }
+
     // === Distance Utilities ===
 
     override fun getDistanceBetween(lat1: Double, lon1: Double, lat2: Double, lon2: Double): Double {
@@ -389,5 +462,7 @@ class NitroLocationTracking : HybridNitroLocationTrackingSpec() {
         geofenceManager?.destroy()
         providerStatusMonitor?.destroy()
         permissionStatusMonitor?.destroy()
+        mockLocationMonitor?.destroy()
+        airplaneModeMonitor?.destroy()
     }
 }

package/cpp/HybridNitroLocationComplexLogicsCalculation.cpp

@@ -0,0 +1,204 @@
+#include "HybridNitroLocationComplexLogicsCalculation.hpp"
+#include <cmath>
+#include <algorithm>
+
+namespace margelo::nitro::nitrolocationtracking {
+
+  // Mathematical constants
+  constexpr double PI = 3.14159265358979323846;
+  constexpr double EARTH_RADIUS_M = 6371000.0;
+
+  double HybridNitroLocationComplexLogicsCalculation::haversineDistance(double lat1, double lon1, double lat2, double lon2) {
+      double p = PI / 180.0;
+      double a = 0.5 - std::cos((lat2 - lat1) * p)/2.0 + 
+                 std::cos(lat1 * p) * std::cos(lat2 * p) * 
+                 (1.0 - std::cos((lon2 - lon1) * p))/2.0;
+
+      return 2.0 * EARTH_RADIUS_M * std::asin(std::sqrt(a));
+  }
+
+  TripMathStats HybridNitroLocationComplexLogicsCalculation::calculateTotalTripStats(const std::vector<LocationPoint>& points) {
+      TripMathStats stats = {0.0, 0.0, 0.0, 0.0};
+      
+      if (points.size() < 2) return stats;
+
+      double totalDist = 0.0;
+      double maxSpeed = 0.0;
+      double totalTimeMs = points.back().timestamp - points.front().timestamp;
+
+      for (size_t i = 1; i < points.size(); ++i) {
+          const auto& p1 = points[i-1];
+          const auto& p2 = points[i];
+          
+          double dist = haversineDistance(p1.latitude, p1.longitude, p2.latitude, p2.longitude);
+          totalDist += dist;
+          
+          if (p2.speed > maxSpeed) {
+              maxSpeed = p2.speed;
+          }
+      }
+
+      stats.totalDistanceMeters = totalDist;
+      stats.elapsedTimeMs = totalTimeMs;
+      
+      // Convert max speed m/s to km/h if it comes in m/s, assume it's m/s
+      stats.maxSpeedKmh = maxSpeed * 3.6;
+      
+      if (totalTimeMs > 0) {
+          double avgSpeedMps = totalDist / (totalTimeMs / 1000.0);
+          stats.averageSpeedKmh = avgSpeedMps * 3.6;
+      }
+
+      return stats;
+  }
+
+  std::vector<LocationPoint> HybridNitroLocationComplexLogicsCalculation::filterAnomalousPoints(const std::vector<LocationPoint>& points, double maxSpeedLimitMs) {
+      std::vector<LocationPoint> filtered;
+      if (points.empty()) return filtered;
+
+      filtered.push_back(points.front());
+
+      for (size_t i = 1; i < points.size(); ++i) {
+          const auto& curr = points[i];
+          const auto& last = filtered.back();
+          
+          double dist = haversineDistance(last.latitude, last.longitude, curr.latitude, curr.longitude);
+          double timeDiffSec = (curr.timestamp - last.timestamp) / 1000.0;
+          
+          if (timeDiffSec <= 0) continue; // Invalid time
+          
+          double calcSpeed = dist / timeDiffSec;
+          
+          // If the calculated speed is ridiculously high (teleportation), ignore point
+          if (calcSpeed <= maxSpeedLimitMs) {
+              filtered.push_back(curr);
+          }
+      }
+
+      return filtered;
+  }
+
+  double HybridNitroLocationComplexLogicsCalculation::perpendicularDistance(const LocationPoint& pt, const LocationPoint& lineStart, const LocationPoint& lineEnd) {
+      double dx = lineEnd.longitude - lineStart.longitude;
+      double dy = lineEnd.latitude - lineStart.latitude;
+      
+      double mag = std::sqrt(dx*dx + dy*dy);
+      if (mag > 0.0) {
+          dx /= mag;
+          dy /= mag;
+      }
+      
+      double pvx = pt.longitude - lineStart.longitude;
+      double pvy = pt.latitude - lineStart.latitude;
+      
+      double pvdot = dx * pvx + dy * pvy;
+      
+      double ax = pvx - pvdot * dx;
+      double ay = pvy - pvdot * dy;
+      
+      // Calculate distance in coordinates and roughly convert to meters using Haversine
+      double projLat = pt.latitude - ay;
+      double projLon = pt.longitude - ax;
+      return haversineDistance(pt.latitude, pt.longitude, projLat, projLon);
+  }
+
+  void HybridNitroLocationComplexLogicsCalculation::douglasPeucker(const std::vector<LocationPoint>& points, double tolerance, int firstIdx, int lastIdx, std::vector<int>& keepIndexes) {
+      if (lastIdx <= firstIdx + 1) return;
+
+      double maxDist = 0.0;
+      int index = firstIdx;
+
+      for (int i = firstIdx + 1; i < lastIdx; ++i) {
+          double dist = perpendicularDistance(points[i], points[firstIdx], points[lastIdx]);
+          if (dist > maxDist) {
+              index = i;
+              maxDist = dist;
+          }
+      }
+
+      if (maxDist > tolerance) {
+          keepIndexes.push_back(index);
+          douglasPeucker(points, tolerance, firstIdx, index, keepIndexes);
+          douglasPeucker(points, tolerance, index, lastIdx, keepIndexes);
+      }
+  }
+
+  std::vector<LocationPoint> HybridNitroLocationComplexLogicsCalculation::smoothPath(const std::vector<LocationPoint>& points, double toleranceMeters) {
+      if (points.size() < 3) return points;
+
+      std::vector<int> keepIndexes;
+      keepIndexes.push_back(0);
+      keepIndexes.push_back(points.size() - 1);
+
+      douglasPeucker(points, toleranceMeters, 0, points.size() - 1, keepIndexes);
+
+      std::sort(keepIndexes.begin(), keepIndexes.end());
+
+      std::vector<LocationPoint> smoothed;
+      for (int idx : keepIndexes) {
+          smoothed.push_back(points[idx]);
+      }
+
+      return smoothed;
+  }
+
+  double HybridNitroLocationComplexLogicsCalculation::calculateBearing(double lat1, double lon1, double lat2, double lon2) {
+      double p = PI / 180.0;
+      double dLon = (lon2 - lon1) * p;
+      double rLat1 = lat1 * p;
+      double rLat2 = lat2 * p;
+
+      double y = std::sin(dLon) * std::cos(rLat2);
+      double x = std::cos(rLat1) * std::sin(rLat2) -
+                 std::sin(rLat1) * std::cos(rLat2) * std::cos(dLon);
+
+      double bearing = std::atan2(y, x) * (180.0 / PI);
+      return std::fmod((bearing + 360.0), 360.0);
+  }
+
+  std::string HybridNitroLocationComplexLogicsCalculation::encodeGeohash(double latitude, double longitude, double precisionRaw) {
+      static const char BASE32[] = "0123456789bcdefghjkmnpqrstuvwxyz";
+      
+      int precision = static_cast<int>(precisionRaw);
+      if (precision < 1) precision = 1;
+      if (precision > 12) precision = 12;
+
+      bool is_even = true;
+      double lat[2] = {-90.0, 90.0};
+      double lon[2] = {-180.0, 180.0};
+      int bit = 0;
+      int ch = 0;
+      std::string geohash = "";
+
+      while (geohash.length() < precision) {
+          if (is_even) {
+              double mid = (lon[0] + lon[1]) / 2;
+              if (longitude > mid) {
+                  ch |= (1 << (4 - bit));
+                  lon[0] = mid;
+              } else {
+                  lon[1] = mid;
+              }
+          } else {
+              double mid = (lat[0] + lat[1]) / 2;
+              if (latitude > mid) {
+                  ch |= (1 << (4 - bit));
+                  lat[0] = mid;
+              } else {
+                  lat[1] = mid;
+              }
+          }
+
+          is_even = !is_even;
+          if (bit < 4) {
+              bit++;
+          } else {
+              geohash += BASE32[ch];
+              bit = 0;
+              ch = 0;
+          }
+      }
+      return geohash;
+  }
+
+} // namespace margelo::nitro::nitrolocationtracking

package/cpp/HybridNitroLocationComplexLogicsCalculation.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "HybridNitroLocationComplexLogicsCalculationSpec.hpp"
+#include <vector>
+
+namespace margelo::nitro::nitrolocationtracking {
+
+  class HybridNitroLocationComplexLogicsCalculation : public HybridNitroLocationComplexLogicsCalculationSpec {
+  public:
+    HybridNitroLocationComplexLogicsCalculation() : HybridObject(TAG) {}
+
+    // Methods
+    TripMathStats calculateTotalTripStats(const std::vector<LocationPoint>& points) override;
+    
+    std::vector<LocationPoint> filterAnomalousPoints(const std::vector<LocationPoint>& points, double maxSpeedLimitMs) override;
+    
+    std::vector<LocationPoint> smoothPath(const std::vector<LocationPoint>& points, double toleranceMeters) override;
+    
+    double calculateBearing(double lat1, double lon1, double lat2, double lon2) override;
+    
+    std::string encodeGeohash(double latitude, double longitude, double precision) override;
+    
+  private:
+    double haversineDistance(double lat1, double lon1, double lat2, double lon2);
+    double perpendicularDistance(const LocationPoint& pt, const LocationPoint& lineStart, const LocationPoint& lineEnd);
+    void douglasPeucker(const std::vector<LocationPoint>& points, double tolerance, int firstIdx, int lastIdx, std::vector<int>& keepIndexes);
+  };
+
+} // namespace margelo::nitro::nitrolocationtracking