FENCE-2308: Add batching options to tracking options

sdk/src/main/java/io/radar/sdk/Radar.kt

@@ -3693,6 +3693,18 @@ object Radar {
         replayBuffer.write(replayParams)
     }
 
+    internal fun addToBatch(batchParams: JSONObject, options: RadarTrackingOptions) {
+        replayBuffer.addToBatch(batchParams, options)
+    }
+
+    internal fun shouldFlushBatch(options: RadarTrackingOptions): Boolean {
+        return replayBuffer.shouldFlushBatch(options)
+    }
+
+    internal fun flushBatch(): Boolean {
+        return replayBuffer.flushBatch()
+    }
+
     @JvmStatic
     internal fun loadReplayBufferFromSharedPreferences() {
         replayBuffer.loadFromSharedPreferences()

sdk/src/main/java/io/radar/sdk/RadarApiClient.kt

@@ -470,6 +470,25 @@ internal class RadarApiClient(
             this.getConfig(usage)
         }
 
+        // Check if batching is enabled and should be used for this track request
+        val batchingEnabled = (options.batchSize > 0 || options.batchInterval > 0)
+
+        if (batchingEnabled && 
+            source != RadarLocationSource.MANUAL_LOCATION && 
+            source != RadarLocationSource.FOREGROUND_LOCATION) {
+
+            val batchParams = JSONObject(params.toString())
+
+            Radar.addToBatch(batchParams, options)
+
+            if (Radar.shouldFlushBatch(options)) {
+                Radar.flushBatch()
+            }
+
+            callback?.onComplete(RadarStatus.SUCCESS)
+            return
+        }
+
         val hasReplays = Radar.hasReplays()
         var requestParams = params
         // before we track, check if replays need to sync

sdk/src/main/java/io/radar/sdk/RadarTrackingOptions.kt

@@ -123,6 +123,16 @@ data class RadarTrackingOptions(
      * Determines whether to collect pressure data.
      */
     var usePressure: Boolean,
+
+    /**
+     * Determines the time interval between batch events, in seconds.
+     */
+    var batchInterval: Int,
+
+    /**
+     * Determines the number of events per batch.
+     */
+    var batchSize: Int,
 ) {
 
     /**
@@ -433,7 +443,9 @@ data class RadarTrackingOptions(
             foregroundServiceEnabled = true,
             beacons = false,
             useMotion = false,
-            usePressure = false
+            usePressure = false,
+            batchInterval = 0,
+            batchSize = 0
         )
 
         /**
@@ -464,7 +476,9 @@ data class RadarTrackingOptions(
             foregroundServiceEnabled = false,
             beacons = false,
             useMotion = false,
-            usePressure = false
+            usePressure = false,
+            batchInterval = 0,
+            batchSize = 0
         )
 
         /**
@@ -495,7 +509,9 @@ data class RadarTrackingOptions(
             foregroundServiceEnabled = false,
             beacons = false,
             useMotion = false,
-            usePressure = false
+            usePressure = false,
+            batchInterval = 0,
+            batchSize = 0
         )
 
         internal const val KEY_DESIRED_STOPPED_UPDATE_INTERVAL = "desiredStoppedUpdateInterval"
@@ -520,6 +536,8 @@ data class RadarTrackingOptions(
         internal const val KEY_BEACONS = "beacons"
         internal const val KEY_USE_MOTION = "useMotion"
         internal const val KEY_USE_PRESSURE = "usePressure"
+        internal const val KEY_BATCH_INTERVAL = "batchInterval"
+        internal const val KEY_BATCH_SIZE = "batchSize"
         @JvmStatic
         fun fromJson(obj: JSONObject): RadarTrackingOptions {
             val desiredAccuracy = if (obj.has(KEY_DESIRED_ACCURACY) && obj.get(KEY_DESIRED_ACCURACY) is String) {
@@ -590,7 +608,9 @@ data class RadarTrackingOptions(
                 foregroundServiceEnabled = obj.optBoolean(KEY_FOREGROUND_SERVICE_ENABLED, false),
                 beacons = obj.optBoolean(KEY_BEACONS),
                 useMotion = obj.optBoolean(KEY_USE_MOTION),
-                usePressure = obj.optBoolean(KEY_USE_PRESSURE)
+                usePressure = obj.optBoolean(KEY_USE_PRESSURE),
+                batchInterval = obj.optInt(KEY_BATCH_INTERVAL),
+                batchSize =  obj.optInt(KEY_BATCH_SIZE)
             )
         }
     }
@@ -619,6 +639,8 @@ data class RadarTrackingOptions(
         obj.put(KEY_BEACONS, beacons)
         obj.put(KEY_USE_MOTION, useMotion)
         obj.put(KEY_USE_PRESSURE, usePressure)
+        obj.put(KEY_BATCH_INTERVAL, batchInterval)
+        obj.put(KEY_BATCH_SIZE, batchSize)
         return obj
     }
 

sdk/src/main/java/io/radar/sdk/util/RadarReplayBuffer.kt

@@ -1,5 +1,6 @@
 package io.radar.sdk.util
 
+import io.radar.sdk.RadarTrackingOptions
 import io.radar.sdk.model.RadarReplay
 import org.json.JSONObject
 
@@ -12,4 +13,15 @@ internal interface RadarReplayBuffer {
     fun getFlushableReplaysStash(): Flushable<RadarReplay>
 
     fun loadFromSharedPreferences()
+
+    // Batching methods
+    fun addToBatch(batchParams: JSONObject, options: RadarTrackingOptions)
+
+    fun shouldFlushBatch(options: RadarTrackingOptions): Boolean
+
+    fun flushBatch(): Boolean
+
+    fun scheduleBatchTimer(options: RadarTrackingOptions)
+
+    fun cancelBatchTimer()
 }

sdk/src/main/java/io/radar/sdk/util/RadarSimpleReplayBuffer.kt

@@ -1,11 +1,18 @@
 package io.radar.sdk.util
 
+import io.radar.sdk.Radar
 import io.radar.sdk.RadarSettings
+import io.radar.sdk.RadarTrackingOptions
 import io.radar.sdk.model.RadarReplay
+import android.os.Build
+import android.os.SystemClock
 import android.content.Context
 import android.content.SharedPreferences
+import android.os.Handler
+import android.os.Looper
 import androidx.core.content.edit
 import java.util.concurrent.LinkedBlockingDeque
+import java.util.concurrent.atomic.AtomicInteger
 import org.json.JSONObject
 import org.json.JSONArray
 
@@ -18,6 +25,9 @@ internal class RadarSimpleReplayBuffer(private val context: Context) : RadarRepl
     }
 
     private val buffer = LinkedBlockingDeque<RadarReplay>(MAXIMUM_CAPACITY)
+    private val handler = Handler(Looper.getMainLooper())
+    private var batchTimerRunnable: Runnable? = null
+    private val batchCount = AtomicInteger(0)
 
     override fun getSize(): Int {
         return buffer.size
@@ -75,6 +85,74 @@ internal class RadarSimpleReplayBuffer(private val context: Context) : RadarRepl
         }
     }
 
+    override fun addToBatch(batchParams: JSONObject, options: RadarTrackingOptions) {
+        val updatedBatchParams = JSONObject(batchParams.toString())
+        updatedBatchParams.put("replayed", true)
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
+            val nowMs = SystemClock.elapsedRealtimeNanos() / 1000000
+            updatedBatchParams.put("updatedAtMs", nowMs)
+        }
+        updatedBatchParams.remove("updatedAtMsDiff")
+
+        batchCount.incrementAndGet()
+        write(updatedBatchParams)
+
+        // Schedule timer if interval is set and timer not already running
+        if (options.batchInterval > 0 && batchTimerRunnable == null) {
+            scheduleBatchTimer(options)
+        }
+    }
+
+    override fun shouldFlushBatch(options: RadarTrackingOptions): Boolean {
+        val currentCount = batchCount.get()
+
+        if (currentCount == 0) {
+            return false
+        }
+
+        if (options.batchSize > 0 && currentCount >= options.batchSize) {
+            return true
+        }
+
+        return false
+    }
+
+    override fun flushBatch(): Boolean {
+        val currentCount = batchCount.getAndSet(0)
+        if (currentCount == 0) {
+            return false
+        }
+
+        cancelBatchTimer()
+        Radar.flushReplays()
+        Radar.logger.d("[BATCH] Batch flushed | count = $currentCount | buffer size = ${buffer.size}")
+
+        return true
+    }
+
+    override fun scheduleBatchTimer(options: RadarTrackingOptions) {
+        if (options.batchInterval <= 0) return
+
+        cancelBatchTimer()
+
+        batchTimerRunnable = Runnable {
+            if (batchCount.get() > 0) {
+                // Timer fired, trigger flush
+                flushBatch()
+            }
+        }
+
+        handler.postDelayed(batchTimerRunnable!!, (options.batchInterval * 1000L))
+    }
+
+    override fun cancelBatchTimer() {
+        batchTimerRunnable?.let { runnable ->
+            handler.removeCallbacks(runnable)
+            batchTimerRunnable = null
+        }
+    }
+
     private fun getSharedPreferences(context: Context): SharedPreferences {
         return context.getSharedPreferences(PREFERENCES_NAME, Context.MODE_PRIVATE)
     }