fix: Avoid start/end transitions overlap

Consider this scenario:
- A location point P1 is produced at 12:00:00 (T1), the last of a trip.
- An upload is done, with the stop transitions set at T1 + 1s =
  12:00:01
- P2 is produced at 12:00:01 (T2), the first of new trip
- At upload time, the start transitions will be set at T2 - 1s =
  12:00:00

Then, the start transition timestamp of the new trip will be before the stop
transition of the previous trip, which is not possible, and will be
discarded by the server, which will result in a missing trip.

To solve this, we now add/substract 1ms to the transitions w.r.t. to the
first or last location point. This should prevent overlapping transitions,
as long as locations between 2 trips are not produced in the same ms

Author: paultranvan

src/app/domain/geolocation/tracking/consts.js

@@ -35,6 +35,7 @@ export const MIN_SPEED_BETWEEN_DISTANT_POINTS = 0.5 // In m/s. Note the average
 export const MAX_DOCS_PER_BATCH = 30000 // Should be less than 10 MB. Should never reach 15 MB.
 export const MIN_DISTANCE_TO_USE_LAST_POINT = 50 // In meters.
 export const MAX_DISTANCE_TO_USE_LAST_POINT = 6000 // In meters. This value is quite high, but we noticed on iOS + Android that it can take this far to wake up when network data is disabled
+export const TRANSITION_TIME_SHIFT = 0.01 // In seconds. This is useful to ensure that start transitions are set just before the trip start and just after the trip end
 
 // All speed values in m/s
 export const AVG_WALKING_SPEED = 1.34

src/app/domain/geolocation/tracking/index.js

@@ -268,7 +268,8 @@ export const handleConnectivityChange = async event => {
  * @property {number} [untilTs] - Until when the locations points should be fetched. Default is 0
  * @property {boolean} [force] - Whether or not the upload should be forced
  *
- * @param {Params} - The method parmas
+ * @param {Params} - The method params
+ * @returns {Promise<number>} The number of uploaded tracking data points
  */
 export const startOpenPathUploadAndPipeline = async ({
   untilTs = 0,

src/app/domain/geolocation/tracking/tracking.js

@@ -30,7 +30,8 @@ import {
   UNKNOWN_ACTIVITY,
   VEHICLE_ACTIVITY,
   WALKING_ACTIVITY,
-  AVG_WALKING_SPEED
+  AVG_WALKING_SPEED,
+  TRANSITION_TIME_SHIFT
 } from '/app/domain/geolocation/tracking/consts'
 
 /**
@@ -50,7 +51,7 @@ export const createDataBatch = (locations, nRun, maxBatchSize) => {
  * @param {Array<Location>} locations - The location points to upload
  * @param {string} user - The openpath user id
  * @param {{boolean}} - Additional params
- * @returns {number} The number of uploaded tracking data
+ * @returns {Promise<number>} The number of uploaded tracking data
  */
 export const uploadTrackingData = async (
   locations,
@@ -143,7 +144,10 @@ const prepareMotionData = async ({ locations, lastUploadedPoint }) => {
           new Date(1000 * (getTs(point) - 1)) +
           's'
       )
-      await addStartTransitions(contentToUpload, getTs(point) - 1)
+      await addStartTransitions(
+        contentToUpload,
+        getTs(point) - TRANSITION_TIME_SHIFT
+      )
     } else {
       const deltaT = getTs(point) - getTs(previousPoint)
       if (deltaT > MAX_TEMPORAL_DELTA) {
@@ -160,10 +164,17 @@ const prepareMotionData = async ({ locations, lastUploadedPoint }) => {
         // Force a stop/start transition when the temporal delta is too high
         // Note forcing the transition won't automatically create a new trip, typically a long-distance
         // flight of 12h+ should behave as one trip, even with this transition.
-        await addStopTransitions(contentToUpload, getTs(previousPoint) + 1, {
-          withForceStop: true
-        })
-        await addStartTransitions(contentToUpload, getTs(point) - 1)
+        await addStopTransitions(
+          contentToUpload,
+          getTs(previousPoint) + TRANSITION_TIME_SHIFT,
+          {
+            withForceStop: true
+          }
+        )
+        await addStartTransitions(
+          contentToUpload,
+          getTs(point) - TRANSITION_TIME_SHIFT
+        )
       } else if (deltaT > LARGE_TEMPORAL_DELTA) {
         const distanceM = getDistanceFromLatLonInM(previousPoint, point)
         Log('Spatial distance between points : ' + distanceM)
@@ -172,10 +183,17 @@ const prepareMotionData = async ({ locations, lastUploadedPoint }) => {
 
         if (speed < MIN_SPEED_BETWEEN_DISTANT_POINTS) {
           Log('Very slow speed: force transition')
-          await addStopTransitions(contentToUpload, getTs(previousPoint) + 1, {
-            withForceStop: true
-          })
-          await addStartTransitions(contentToUpload, getTs(point) - 1)
+          await addStopTransitions(
+            contentToUpload,
+            getTs(previousPoint) + TRANSITION_TIME_SHIFT,
+            {
+              withForceStop: true
+            }
+          )
+          await addStartTransitions(
+            contentToUpload,
+            getTs(point) - TRANSITION_TIME_SHIFT
+          )
           // Here we forced a hard stop transition. This typically happens when the tracking was lost for
           // a significant time, for a significant distance, but with a speed not significant enough to be
           // considered as a continuing trip.
@@ -200,7 +218,10 @@ const prepareMotionData = async ({ locations, lastUploadedPoint }) => {
       const lastStopTransitionTs = await getLastStopTransitionTs()
       if (lastStopTransitionTs >= lastStartTransitionTs) {
         Log('Based on timestamps, this is a new trip')
-        await addStartTransitions(contentToUpload, getTs(point) - 1)
+        await addStartTransitions(
+          contentToUpload,
+          getTs(point) - TRANSITION_TIME_SHIFT
+        )
       }
     }
 
@@ -223,9 +244,13 @@ const prepareMotionData = async ({ locations, lastUploadedPoint }) => {
   // The stop transition might be missed?
   const deltaLastPoint = Date.now() / 1000 - lastPointTs
   Log('Delta last point : ' + deltaLastPoint)
-  await addStopTransitions(contentToUpload, lastPointTs + 1, {
-    withForceStop: false
-  })
+  await addStopTransitions(
+    contentToUpload,
+    lastPointTs + TRANSITION_TIME_SHIFT,
+    {
+      withForceStop: false
+    }
+  )
 
   return contentToUpload
 }
@@ -252,10 +277,16 @@ export const createNewStartPoint = (previousPoint, nextPoint) => {
     nextPoint.coords.speed > 0 ? nextPoint.coords.speed : AVG_WALKING_SPEED
   // Calculate the time to subtract based on speed and distance
   const timeToSubtract = (distance / speed) * 1000
-  const newTime = date.getTime() - timeToSubtract
-  if (newTime > new Date(previousPoint.timestamp).getTime()) {
+  let newTime = date.getTime() - timeToSubtract
+
+  // Check the new time is greater than the previous location point, plus 1s for safety.
+  // Here, we want to prevent overlaping points, that might results in overlapping transitions.
+  if (newTime > new Date(previousPoint.timestamp).getTime() + 1000) {
     // Subtract the time from the date
-    date.setTime(date.getTime() - timeToSubtract)
+    date.setTime(newTime)
+  } else {
+    newTime = date.getTime() - 1000
+    date.setTime(newTime)
   }
   const newTimestamp = date.toISOString()
   const newPoint = { ...previousPoint, timestamp: newTimestamp }

src/app/domain/geolocation/tracking/tracking.spec.js

@@ -255,6 +255,28 @@ describe('createNewStartPoint', () => {
       new Date(nextPoint.timestamp).getTime()
     )
   })
+  it('should create starting point just before next point if too close from the previous point', () => {
+    const prevPoint = {
+      coords: {
+        latitude: 45.766501482079,
+        longitude: 4.828593684206228,
+        speed: 4.66
+      },
+      timestamp: '2024-03-15T08:24:59'
+    }
+    const nextPoint = {
+      coords: {
+        latitude: 45.766841923882495,
+        longitude: 4.82800307468357,
+        speed: 1
+      },
+      timestamp: '2024-03-15T08:25:10'
+    }
+    const newPoint = createNewStartPoint(prevPoint, nextPoint)
+    expect(new Date(newPoint.timestamp).getTime()).toEqual(
+      new Date(nextPoint.timestamp).getTime() - 1000
+    )
+  })
 })
 
 describe('inferMotionActivity', () => {

src/app/domain/geolocation/tracking/upload.js

@@ -78,6 +78,17 @@ const filterBadContent = contentToUpload => {
   })
 }
 
+/**
+ * Get local location points and upload them
+ *
+ * @typedef {object} Params
+ * @property {number} [untilTs] - Until when the locations points should be fetched. Default is 0
+ * @property {boolean} [force] - Whether or not the upload should be forced
+ *
+ * @param {string} user - The openpath user
+ * @param {Params} - The method params
+ * @returns {number} The number of uploaded tracking data points
+ */
 export const uploadData = async (user, { untilTs = 0, force = false } = {}) => {
   Log(`Starting upload process for user ${user} ${force ? 'forced' : ''}`)
 

src/app/domain/geolocation/tracking/user.js

@@ -67,7 +67,8 @@ export const createOpenPathUserIfMissing = async user => {
     return uuid
   } catch (err) {
     // If the user actually exist, the creation will return the existing user
-    Log(`Error when trying to get openpath user, let's create one`)
+    Log(`Error when trying to get openpath user ${user}, let's create one`)
+    Log(err)
     return createUser(user)
   }
 }