Skip to content

Colota - Android GPS Location tracker

refactor(sync): split NetworkManager and sort the sync code into folders (#983)

Max Dietrichbfb2001ed2b6
diff --git a/apps/docs/docs/development/architecture.md b/apps/docs/docs/development/architecture.md
index bb646dc8..88191029 100644
--- a/apps/docs/docs/development/architecture.md
+++ b/apps/docs/docs/development/architecture.md
@@ -48,7 +48,7 @@ The mobile app has a **React Native** UI layer and **native Kotlin** modules for
All native code lives in `apps/mobile/android/app/src/`, organized by build flavor:
-- `src/main/java/com/colota/` - Shared code: `bridge/`, `service/`, `data/`, `sync/`, `util/`, `location/` (interface + `LocationAccuracy`), `backup/`, `export/`
+- `src/main/java/com/colota/` - Shared code: `bridge/`, `service/`, `data/`, `sync/` (with `sync/http/` for the request code), `network/`, `util/`, `location/` (interface + `LocationAccuracy`), `backup/`, `export/`
- `src/gms/java/com/colota/location/` - Google Play Services location provider
- `src/foss/java/com/colota/location/` - Native Android location provider
@@ -214,12 +214,16 @@ Orchestrates batch location uploads with:
### NetworkManager
-HTTP client. Injects auth headers, caches connectivity checks, and detects unmetered connections and VPN status for sync condition filtering. SSID detection needs a location-flagged network callback, which is attributed as location access, so it is registered only while the sync `wifi_ssid` condition is active; profile conditions read the name through a one-shot probe when the network changes. Connected Wi-Fi is tracked separately with a plain (unflagged) Wi-Fi-transport callback, so the profile conditions also see the network under a VPN. Endpoint policy (HTTPS-for-public, private host detection) is delegated to `UrlSafety`.
+HTTP client. Sends each request and maps failures to a result; it asks `NetworkMonitor` whether a network is available first. `RequestBuilder` opens the connection and sets headers and body, `ResponseReader` turns the reply into a result, and `EndpointUrl` resolves URL variables. Endpoint policy (HTTPS-for-public, private host detection) is delegated to `UrlSafety`.
Every request uses its own connection: it sends `Connection: close` and closes the response before disconnecting, so Android releases the connection at once instead of keeping it in its pool.
For mTLS-protected endpoints, builds the `HttpsURLConnection` with a custom `SSLSocketFactory` supplied by `ClientCertSslContextProvider` (per-instance, never `setDefaultSSLSocketFactory()` - the override is scoped to outbound location sync, not the whole process).
+### NetworkMonitor
+
+Network state for the sync conditions and the profile Wi-Fi conditions. Caches connectivity checks and detects unmetered connections and VPN status. SSID detection needs a location-flagged network callback, which is attributed as location access, so it is registered only while the sync `wifi_ssid` condition is active; profile conditions read the name through a one-shot probe when the network changes. Connected Wi-Fi is tracked separately with a plain (unflagged) Wi-Fi-transport callback, so the profile conditions also see the network under a VPN.
+
### UrlSafety
HTTP endpoint policy: HTTPS is required for public hosts, HTTP is only allowed when the host resolves to a private/local address (loopback, RFC 1918 site-local, link-local, or CGNAT 100.64.0.0/10). Resolves hostnames via `InetAddress` so server.local-style mDNS names work. The lookup runs on every call, so a host that stops resolving to a private address is no longer trusted for plain HTTP after a network change. Pure validation with no transport state, also exposed to the JS bridge for pre-save endpoint checks.
@@ -264,7 +268,7 @@ Database access layer for tracking profiles and trip events. Maintains a `TimedC
### ConditionMonitor
-Monitors charging state via `BroadcastReceiver`, Android Auto connection via the `CarConnection` API, Bluetooth device connections via the ACL `BroadcastReceiver` (seeded from the A2DP and headset profile proxies on every monitor start, since ACL broadcasts report changes only; a device on neither profile is seen at its next connect), and Wi-Fi transport changes from `NetworkManager`, reading the network name one-shot when a named-network profile needs it: on every Wi-Fi network that comes or goes and when Location comes back on, because a name read while Location was off is blank. Forwards state changes to `ProfileManager` for condition evaluation.
+Monitors charging state via `BroadcastReceiver`, Android Auto connection via the `CarConnection` API, Bluetooth device connections via the ACL `BroadcastReceiver` (seeded from the A2DP and headset profile proxies on every monitor start, since ACL broadcasts report changes only; a device on neither profile is seen at its next connect), and Wi-Fi transport changes from `NetworkMonitor`, reading the network name one-shot when a named-network profile needs it: on every Wi-Fi network that comes or goes and when Location comes back on, because a name read while Location was off is blank. Forwards state changes to `ProfileManager` for condition evaluation.
### ProfileConstants
diff --git a/apps/mobile/android/app/src/main/java/com/colota/bridge/LocationServiceModule.kt b/apps/mobile/android/app/src/main/java/com/colota/bridge/LocationServiceModule.kt
index 544c5b49..269e6192 100644
--- a/apps/mobile/android/app/src/main/java/com/colota/bridge/LocationServiceModule.kt
+++ b/apps/mobile/android/app/src/main/java/com/colota/bridge/LocationServiceModule.kt
@@ -27,8 +27,8 @@ import com.Colota.service.getIntOrNull
import com.Colota.service.getStringOrNull
import com.Colota.service.getBooleanOrNull
import com.Colota.sync.SyncState
-import com.Colota.sync.NetworkManager
-import com.Colota.sync.UrlSafety
+import com.Colota.network.NetworkMonitor
+import com.Colota.sync.http.UrlSafety
import com.Colota.util.DeviceInfoHelper
import com.Colota.export.AutoExportConfig
import com.Colota.export.AutoExportScheduler
@@ -77,7 +77,7 @@ class LocationServiceModule(reactContext: ReactApplicationContext) :
private val geofenceHelper = GeofenceHelper(reactContext)
private val profileHelper = ProfileHelper(reactContext)
private val secureStorage = SecureStorageHelper.getInstance(reactContext)
- private val networkManager = NetworkManager(reactContext)
+ private val networkMonitor = NetworkMonitor(reactContext)
private val moduleScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
@@ -860,17 +860,17 @@ class LocationServiceModule(reactContext: ReactApplicationContext) :
@ReactMethod
fun isNetworkAvailable(promise: Promise) {
- promise.resolve(networkManager.isNetworkAvailable())
+ promise.resolve(networkMonitor.isNetworkAvailable())
}
@ReactMethod
fun isUnmeteredConnection(promise: Promise) {
- promise.resolve(networkManager.isUnmeteredConnection())
+ promise.resolve(networkMonitor.isUnmeteredConnection())
}
@ReactMethod
fun getCurrentSsid(promise: Promise) {
- networkManager.readSsidOnce { promise.resolve(it) }
+ networkMonitor.readSsidOnce { promise.resolve(it) }
}
@ReactMethod
diff --git a/apps/mobile/android/app/src/main/java/com/colota/bridge/MtlsBridgeModule.kt b/apps/mobile/android/app/src/main/java/com/colota/bridge/MtlsBridgeModule.kt
index 40488bd2..7689efb5 100644
--- a/apps/mobile/android/app/src/main/java/com/colota/bridge/MtlsBridgeModule.kt
+++ b/apps/mobile/android/app/src/main/java/com/colota/bridge/MtlsBridgeModule.kt
@@ -8,8 +8,9 @@ package com.Colota.bridge
import android.app.Activity
import android.content.Intent
import com.Colota.sync.ApiFormat
-import com.Colota.sync.NetworkManager
-import com.Colota.sync.tls.ClientCertSslContextProvider
+import com.Colota.sync.http.NetworkManager
+import com.Colota.network.NetworkMonitor
+import com.Colota.sync.http.tls.ClientCertSslContextProvider
import com.Colota.util.AppLogger
import com.Colota.util.SecureStorageHelper
import com.facebook.react.bridge.Arguments
@@ -44,7 +45,7 @@ class MtlsBridgeModule(reactContext: ReactApplicationContext) :
ReactContextBaseJavaModule(reactContext) {
private val secureStorage = SecureStorageHelper.getInstance(reactContext)
- private val networkManager = NetworkManager(reactContext)
+ private val networkManager = NetworkManager(reactContext, NetworkMonitor(reactContext))
private val moduleScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
// @ReactMethod writes, onActivityResult reads on the main thread - CAS prevents double-pick races.
diff --git a/apps/mobile/android/app/src/main/java/com/colota/network/NetworkMonitor.kt b/apps/mobile/android/app/src/main/java/com/colota/network/NetworkMonitor.kt
new file mode 100644
index 00000000..194f558a
--- /dev/null
+++ b/apps/mobile/android/app/src/main/java/com/colota/network/NetworkMonitor.kt
@@ -0,0 +1,311 @@
+/**
+ * Copyright (C) 2026 Max Dietrich
+ * Licensed under the GNU AGPLv3. See LICENSE in the project root for details.
+ */
+
+package com.Colota.network
+
+import android.content.Context
+import android.net.ConnectivityManager
+import android.net.Network
+import android.net.NetworkCapabilities
+import android.net.NetworkRequest
+import android.net.wifi.WifiInfo
+import android.net.wifi.WifiManager
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import com.Colota.util.AppLogger
+import com.Colota.util.TimedCache
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicInteger
+
+/**
+ * Watches the device's network state: availability, metering, Wi-Fi, its name and VPN.
+ */
+class NetworkMonitor(context: Context) {
+
+ companion object {
+ private const val TAG = "NetworkMonitor"
+ private const val NETWORK_CHECK_CACHE_MS = 5000L
+ private const val SSID_PROBE_TIMEOUT_MS = 3000L
+ /** What Android returns instead of the SSID without location permission or with Location off. */
+ private const val UNKNOWN_SSID = "<unknown ssid>"
+ }
+
+ private val connectivityManager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+
+ @Volatile var currentSsid: String = ""
+ private set
+ @Volatile private var isVpn: Boolean = false
+ @Volatile private var isWifi: Boolean = false
+ @Volatile private var ssidTracking: Boolean = false
+ /** Notified on the callback thread when the transport, VPN or SSID state actually changes. */
+ @Volatile private var wifiStateListener: (() -> Unit)? = null
+ // What the listener last saw; callbacks fire for bandwidth and validation churn too.
+ private var notifiedWifi = false
+ private var notifiedVpn = false
+ private var notifiedSsid = ""
+ /** Connected Wi-Fi networks, counted so losing one of several does not clear the state. */
+ private val availableWifiNetworks = AtomicInteger(0)
+ private val wifiManager = context.getSystemService(Context.WIFI_SERVICE) as? WifiManager
+
+ private var networkCallback = createNetworkCallback(withSsid = false)
+
+ /**
+ * Tracks connected Wi-Fi networks by transport alone. It carries no location flag, so it can
+ * stay registered for the manager's lifetime without lighting the privacy indicator, and it
+ * sees Wi-Fi even when a VPN owns the default network.
+ */
+ private val wifiTransportCallback = object : ConnectivityManager.NetworkCallback() {
+ // A switch between two networks keeps the count above zero, so notify even when isWifi stays true
+ override fun onAvailable(network: Network) {
+ availableWifiNetworks.incrementAndGet()
+ refreshWifiTransport(force = true)
+ }
+
+ override fun onLost(network: Network) {
+ availableWifiNetworks.updateAndGet { maxOf(0, it - 1) }
+ refreshWifiTransport(force = true)
+ }
+ }
+
+ /**
+ * The mockable android.jar cannot build a request, so a JVM test without a Builder mock gets
+ * null and skips the registration; on device this never fails.
+ */
+ private val wifiRequest: NetworkRequest? by lazy {
+ try {
+ NetworkRequest.Builder()
+ .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
+ .build()
+ } catch (e: Exception) {
+ AppLogger.w(TAG, "Wi-Fi transport request unavailable: ${e.message}")
+ null
+ }
+ }
+
+ /**
+ * The location-flagged callback notes FINE_LOCATION on every delivery, which lights the privacy
+ * indicator with GPS stopped. Register it only while the SSID is needed; VPN state needs no flag.
+ */
+ @Synchronized
+ fun setSsidTracking(enabled: Boolean) {
+ if (enabled == ssidTracking) return
+ try {
+ connectivityManager.unregisterNetworkCallback(networkCallback)
+ } catch (e: Exception) {
+ AppLogger.e(TAG, "Failed to unregister network callback", e)
+ }
+ networkCallback = createNetworkCallback(withSsid = enabled)
+ try {
+ connectivityManager.registerDefaultNetworkCallback(networkCallback)
+ // Committed only once a callback is live, so a failed swap can be retried.
+ ssidTracking = enabled
+ // A cleared cache must not notify later as if the name just changed.
+ if (!enabled) {
+ currentSsid = ""
+ notifiedSsid = ""
+ }
+ } catch (e: Exception) {
+ AppLogger.e(TAG, "Failed to register network callback", e)
+ }
+ }
+
+ /**
+ * One-shot SSID read: the flagged callback is registered for this call only. The probe asks for
+ * a Wi-Fi network rather than the default one, so it also reads the name under a VPN, where the
+ * default network is the tunnel and carries no Wi-Fi info.
+ */
+ fun readSsidOnce(onResult: (String) -> Unit) {
+ // A live value avoids a second flagged probe; a blank one still probes (VPN, or not yet read).
+ if (ssidTracking && currentSsid.isNotBlank()) {
+ onResult(currentSsid)
+ return
+ }
+
+ if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) {
+ // Below S the SSID comes from WifiManager, not the callback, so waiting on one would
+ // only stall. WifiManager reports the connected network regardless of the VPN.
+ onResult(readSsid(null))
+ return
+ }
+
+ val request = wifiRequest
+ if (request == null) {
+ onResult("")
+ return
+ }
+
+ val done = AtomicBoolean(false)
+ var probe: ConnectivityManager.NetworkCallback? = null
+ fun finish(ssid: String) {
+ if (!done.compareAndSet(false, true)) return
+ probe?.let {
+ try {
+ connectivityManager.unregisterNetworkCallback(it)
+ } catch (e: Exception) {
+ AppLogger.e(TAG, "Failed to unregister SSID probe", e)
+ }
+ }
+ onResult(ssid)
+ }
+
+ probe = object : ConnectivityManager.NetworkCallback(FLAG_INCLUDE_LOCATION_INFO) {
+ override fun onCapabilitiesChanged(network: Network, caps: NetworkCapabilities) = finish(readSsid(caps))
+ }
+
+ try {
+ connectivityManager.registerNetworkCallback(request, probe)
+ } catch (e: Exception) {
+ AppLogger.e(TAG, "Failed to register SSID probe", e)
+ probe = null
+ finish("")
+ return
+ }
+ Handler(Looper.getMainLooper()).postDelayed({ finish("") }, SSID_PROBE_TIMEOUT_MS)
+ }
+
+ private fun createNetworkCallback(withSsid: Boolean): ConnectivityManager.NetworkCallback {
+ fun update(caps: NetworkCapabilities) {
+ if (withSsid) currentSsid = readSsid(caps)
+ isVpn = caps.hasTransport(NetworkCapabilities.TRANSPORT_VPN)
+ notifyWifiStateIfChanged()
+ }
+ fun clear() {
+ currentSsid = ""
+ isVpn = false
+ notifyWifiStateIfChanged()
+ }
+
+ return if (withSsid && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+ object : ConnectivityManager.NetworkCallback(FLAG_INCLUDE_LOCATION_INFO) {
+ override fun onCapabilitiesChanged(network: Network, caps: NetworkCapabilities) = update(caps)
+ override fun onLost(network: Network) = clear()
+ }
+ } else {
+ object : ConnectivityManager.NetworkCallback() {
+ override fun onCapabilitiesChanged(network: Network, caps: NetworkCapabilities) = update(caps)
+ override fun onLost(network: Network) = clear()
+ }
+ }
+ }
+
+ private fun readSsid(caps: NetworkCapabilities?): String {
+ val raw = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+ (caps?.transportInfo as? WifiInfo)?.ssid
+ } else {
+ @Suppress("DEPRECATION")
+ wifiManager?.connectionInfo?.ssid
+ }
+ val ssid = raw?.removeSurrounding("\"") ?: ""
+ // Android reports the placeholder without location permission or with Location off; treat
+ // it as no name so the condition simply does not match (and the picker cannot offer it).
+ return if (ssid == UNKNOWN_SSID) "" else ssid
+ }
+
+ private fun refreshWifiTransport(force: Boolean) {
+ isWifi = availableWifiNetworks.get() > 0
+ notifyWifiStateIfChanged(force)
+ }
+
+ /** Profile evaluation is not free, so only real state changes reach the listener, unless forced. */
+ @Synchronized
+ private fun notifyWifiStateIfChanged(force: Boolean = false) {
+ val ssid = if (ssidTracking) currentSsid else ""
+ if (!force && isWifi == notifiedWifi && isVpn == notifiedVpn && ssid == notifiedSsid) return
+ notifiedWifi = isWifi
+ notifiedVpn = isVpn
+ notifiedSsid = ssid
+ wifiStateListener?.invoke()
+ }
+
+ init {
+ try {
+ connectivityManager.registerDefaultNetworkCallback(networkCallback)
+ } catch (e: Exception) {
+ AppLogger.e(TAG, "Failed to register network callback", e)
+ }
+ wifiRequest?.let { request ->
+ try {
+ connectivityManager.registerNetworkCallback(request, wifiTransportCallback)
+ } catch (e: Exception) {
+ AppLogger.e(TAG, "Failed to register Wi-Fi transport callback", e)
+ }
+ }
+ }
+
+ private val networkCache = TimedCache(NETWORK_CHECK_CACHE_MS) {
+ try {
+ val network = connectivityManager.activeNetwork
+ val capabilities = connectivityManager.getNetworkCapabilities(network)
+ capabilities != null &&
+ capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET) &&
+ capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)
+ } catch (e: Exception) {
+ AppLogger.e(TAG, "Network check failed", e)
+ false
+ }
+ }
+
+ /**
+ * Checks for an active, validated internet connection with caching.
+ */
+ fun isNetworkAvailable(): Boolean = networkCache.get()
+
+ private val unmeteredCache = TimedCache(NETWORK_CHECK_CACHE_MS) {
+ try {
+ val network = connectivityManager.activeNetwork
+ val capabilities = connectivityManager.getNetworkCapabilities(network)
+ capabilities != null &&
+ capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED)
+ } catch (e: Exception) {
+ AppLogger.e(TAG, "Unmetered check failed", e)
+ false
+ }
+ }
+
+ /**
+ * Returns true when the active network is unmetered (Wi-Fi, Ethernet, etc.).
+ * Cached for [NETWORK_CHECK_CACHE_MS] to avoid repeated IPC calls.
+ */
+ fun isUnmeteredConnection(): Boolean = unmeteredCache.get()
+
+ /**
+ * Returns true when connected to a WiFi network matching the given SSID.
+ * Only meaningful while setSsidTracking(true) holds the location-flagged callback.
+ */
+ fun isConnectedToSsid(ssid: String): Boolean {
+ if (ssid.isBlank()) return false
+ return currentSsid.equals(ssid, ignoreCase = true)
+ }
+
+ /** True while any Wi-Fi network is connected, also under a VPN. Needs no location-flagged callback. */
+ fun isWifiConnected(): Boolean = isWifi
+
+ /**
+ * Registers a callback for Wi-Fi connection, VPN and SSID changes, and for every Wi-Fi network
+ * that comes or goes. The listener runs on the ConnectivityManager callback thread; callers that
+ * touch app state must marshal it themselves.
+ * Used by the profile Wi-Fi conditions, which care about more than sync's one boolean.
+ */
+ fun setWifiStateListener(listener: (() -> Unit)?) {
+ wifiStateListener = listener
+ }
+
+ /**
+ * Returns true when the active network uses a VPN transport.
+ * Updated via NetworkCallback.
+ */
+ fun isVpnConnected(): Boolean = isVpn
+
+ fun destroy() {
+ wifiStateListener = null
+ try {
+ connectivityManager.unregisterNetworkCallback(networkCallback)
+ } catch (_: Exception) {}
+ try {
+ connectivityManager.unregisterNetworkCallback(wifiTransportCallback)
+ } catch (_: Exception) {}
+ }
+}
diff --git a/apps/mobile/android/app/src/main/java/com/colota/service/ConditionMonitor.kt b/apps/mobile/android/app/src/main/java/com/colota/service/ConditionMonitor.kt
index ffe5546e..15511ef6 100644
--- a/apps/mobile/android/app/src/main/java/com/colota/service/ConditionMonitor.kt
+++ b/apps/mobile/android/app/src/main/java/com/colota/service/ConditionMonitor.kt
@@ -22,7 +22,7 @@ import android.os.Handler
import android.os.Looper
import androidx.car.app.connection.CarConnection
import androidx.lifecycle.Observer
-import com.Colota.sync.NetworkManager
+import com.Colota.network.NetworkMonitor
import com.Colota.util.AppLogger
/**
@@ -31,7 +31,7 @@ import com.Colota.util.AppLogger
*
* Android Auto is detected via the [CarConnection] API, which reliably
* reports projection and native car connections. Wi-Fi transport changes come
- * from the service's [NetworkManager], which tracks connected Wi-Fi networks
+ * from the service's [NetworkMonitor], which tracks connected Wi-Fi networks
* with a plain (unflagged) callback; a named-network profile reads the name
* through a one-shot location-flagged probe when that transport changes.
* Bluetooth devices are tracked by their ACL connection broadcasts.
@@ -41,7 +41,7 @@ import com.Colota.util.AppLogger
*/
class ConditionMonitor(
private val context: Context,
- private val networkManager: NetworkManager,
+ private val networkMonitor: NetworkMonitor,
private val profileManager: ProfileManager
) {
companion object {
@@ -90,7 +90,7 @@ class ConditionMonitor(
fun stop() {
chargingReceiver = unregisterSafely(chargingReceiver)
stopCarConnectionMonitor()
- networkManager.setWifiStateListener(null)
+ networkMonitor.setWifiStateListener(null)
wifiMonitorActive = false
bluetoothReceiver = unregisterSafely(bluetoothReceiver)
bluetoothGeneration++
@@ -169,7 +169,7 @@ class ConditionMonitor(
* first read, so a change landing in that window still arrives instead of being missed.
*/
private fun startWifiMonitor() {
- networkManager.setWifiStateListener {
+ networkMonitor.setWifiStateListener {
mainHandler.post { pushWifiState() }
}
wifiMonitorActive = true
@@ -190,12 +190,12 @@ class ConditionMonitor(
*/
private fun pushWifiState() {
val generation = ++wifiPushGeneration
- val connected = networkManager.isWifiConnected()
+ val connected = networkMonitor.isWifiConnected()
if (connected && ProfileConstants.CONDITION_WIFI_SSID in profileManager.getNeededConditionTypes()) {
- networkManager.readSsidOnce { ssid ->
+ networkMonitor.readSsidOnce { ssid ->
mainHandler.post {
if (generation == wifiPushGeneration) {
- profileManager.onWifiStateChanged(networkManager.isWifiConnected(), ssid)
+ profileManager.onWifiStateChanged(networkMonitor.isWifiConnected(), ssid)
}
}
}
diff --git a/apps/mobile/android/app/src/main/java/com/colota/service/LocationForegroundService.kt b/apps/mobile/android/app/src/main/java/com/colota/service/LocationForegroundService.kt
index 644c9af7..68833d05 100644
--- a/apps/mobile/android/app/src/main/java/com/colota/service/LocationForegroundService.kt
+++ b/apps/mobile/android/app/src/main/java/com/colota/service/LocationForegroundService.kt
@@ -24,7 +24,8 @@ import com.Colota.data.GeofenceHelper
import com.Colota.data.ProfileHelper
import com.Colota.data.SettingsKeys
import com.Colota.sync.ApiFormat
-import com.Colota.sync.NetworkManager
+import com.Colota.sync.http.NetworkManager
+import com.Colota.network.NetworkMonitor
import com.Colota.sync.PayloadBuilder
import com.Colota.sync.SyncManager
import com.Colota.util.DeviceInfoHelper
@@ -51,6 +52,7 @@ class LocationForegroundService : Service() {
@Volatile private var payloadCustomFields: Map<String, String> = emptyMap()
private lateinit var deviceInfoHelper: DeviceInfoHelper
private lateinit var networkManager: NetworkManager
+ private lateinit var networkMonitor: NetworkMonitor
private lateinit var geofenceHelper: GeofenceHelper
private lateinit var secureStorage: SecureStorageHelper
private lateinit var syncManager: SyncManager
@@ -230,10 +232,11 @@ class LocationForegroundService : Service() {
deviceInfoHelper = DeviceInfoHelper(this)
batteryMonitor = BatteryMonitor(this, deviceInfoHelper) { onBatteryCritical() }
lastBroadcastLocationEnabled = deviceInfoHelper.isLocationEnabled()
- networkManager = NetworkManager(this)
+ networkMonitor = NetworkMonitor(this)
+ networkManager = NetworkManager(this, networkMonitor)
geofenceHelper = GeofenceHelper(this)
secureStorage = SecureStorageHelper.getInstance(this)
- syncManager = SyncManager(dbHelper, networkManager, serviceScope!!)
+ syncManager = SyncManager(dbHelper, networkManager, networkMonitor, serviceScope!!)
profileHelper = ProfileHelper(this)
profileManager = ProfileManager(
profileHelper, serviceScope!!,
@@ -242,7 +245,7 @@ class LocationForegroundService : Service() {
},
onStationaryChanged = ::handleStationaryChanged
)
- conditionMonitor = ConditionMonitor(this, networkManager, profileManager)
+ conditionMonitor = ConditionMonitor(this, networkMonitor, profileManager)
notificationHelper = NotificationHelper(this, notificationManager)
notificationHelper.createChannel()
@@ -485,7 +488,7 @@ class LocationForegroundService : Service() {
teardownStep("locationUpdates") { stopLocationUpdates() }
teardownStep("trackingHeartbeatLogger") { cancelTrackingHeartbeatLogger() }
teardownStep("periodicSync") { syncManager.stopPeriodicSync() }
- teardownStep("networkManager") { networkManager.destroy() }
+ teardownStep("networkMonitor") { networkMonitor.destroy() }
// Critical teardown: must run so pauseAllDbWriters' poll loop sees isRunning=false.
serviceScope?.cancel()
@@ -1657,7 +1660,7 @@ class LocationForegroundService : Service() {
private fun pushConfigToSyncManager() {
// Only wifi_ssid reads the SSID, and reading it is attributed as location access.
- networkManager.setSsidTracking(config.syncCondition == "wifi_ssid")
+ networkMonitor.setSsidTracking(config.syncCondition == "wifi_ssid")
// Instant mode bypasses the queue and posts one flat payload, which 4xxs
// forever against /api/v1/overland/batches. Defensive net under the UI guard.
diff --git a/apps/mobile/android/app/src/main/java/com/colota/sync/NetworkManager.kt b/apps/mobile/android/app/src/main/java/com/colota/sync/NetworkManager.kt
deleted file mode 100644
index ca4ca3ff..00000000
--- a/apps/mobile/android/app/src/main/java/com/colota/sync/NetworkManager.kt
+++ /dev/null
@@ -1,677 +0,0 @@
-package com.Colota.sync
-
-import android.content.Context
-import android.net.wifi.WifiInfo
-import android.net.wifi.WifiManager
-import com.Colota.BuildConfig
-import com.Colota.util.AppLogger
-import com.Colota.sync.tls.ClientCertSslContextProvider
-import com.Colota.util.TimedCache
-import android.os.Build
-import android.os.Handler
-import android.os.Looper
-import android.net.ConnectivityManager
-import android.net.Network
-import android.net.NetworkCapabilities
-import android.net.NetworkRequest
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.withContext
-import org.json.JSONObject
-import java.net.HttpURLConnection
-import java.net.URL
-import java.net.URLEncoder
-import java.nio.charset.StandardCharsets
-import java.security.UnrecoverableKeyException
-import java.util.concurrent.atomic.AtomicBoolean
-import java.util.concurrent.atomic.AtomicInteger
-import java.time.Instant
-import java.time.ZoneId
-import java.time.format.DateTimeFormatter
-import javax.net.ssl.HttpsURLConnection
-import javax.net.ssl.SSLHandshakeException
-
-/**
- * Handles all outgoing network communication for the tracking engine.
- */
-class NetworkManager(private val context: Context) {
-
- companion object {
- private const val TAG = "NetworkManager"
- private const val CONNECTION_TIMEOUT = 10000
- private const val READ_TIMEOUT = 10000
- private const val NETWORK_CHECK_CACHE_MS = 5000L
- private const val SSID_PROBE_TIMEOUT_MS = 3000L
- private const val ERROR_BODY_MAX_CHARS = 200
- /** What Android returns instead of the SSID without location permission or with Location off. */
- private const val UNKNOWN_SSID = "<unknown ssid>"
- private val WHITESPACE = Regex("\\s+")
- }
-
- private val connectivityManager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
-
- @Volatile var currentSsid: String = ""
- private set
- @Volatile private var isVpn: Boolean = false
- @Volatile private var isWifi: Boolean = false
- @Volatile private var ssidTracking: Boolean = false
- /** Notified on the callback thread when the transport, VPN or SSID state actually changes. */
- @Volatile private var wifiStateListener: (() -> Unit)? = null
- // What the listener last saw; callbacks fire for bandwidth and validation churn too.
- private var notifiedWifi = false
- private var notifiedVpn = false
- private var notifiedSsid = ""
- /** Connected Wi-Fi networks, counted so losing one of several does not clear the state. */
- private val availableWifiNetworks = AtomicInteger(0)
- private val wifiManager = context.getSystemService(Context.WIFI_SERVICE) as? WifiManager
-
- // Lazy so existing unit tests that mock Context don't trigger EncryptedSharedPreferences init.
- // Singleton so invalidation propagates between every NetworkManager (foreground service +
- // mTLS bridge module both hold their own NetworkManager).
- private val clientCertProvider by lazy { ClientCertSslContextProvider.getInstance(context) }
-
- /** Call after a client cert or trusted CA change so the next request picks it up. */
- fun invalidateClientCertCache() {
- clientCertProvider.invalidate()
- }
-
- private var networkCallback = createNetworkCallback(withSsid = false)
-
- /**
- * Tracks connected Wi-Fi networks by transport alone. It carries no location flag, so it can
- * stay registered for the manager's lifetime without lighting the privacy indicator, and it
- * sees Wi-Fi even when a VPN owns the default network.
- */
- private val wifiTransportCallback = object : ConnectivityManager.NetworkCallback() {
- // A switch between two networks keeps the count above zero, so notify even when isWifi stays true
- override fun onAvailable(network: Network) {
- availableWifiNetworks.incrementAndGet()
- refreshWifiTransport(force = true)
- }
-
- override fun onLost(network: Network) {
- availableWifiNetworks.updateAndGet { maxOf(0, it - 1) }
- refreshWifiTransport(force = true)
- }
- }
-
- /**
- * The mockable android.jar cannot build a request, so a JVM test without a Builder mock gets
- * null and skips the registration; on device this never fails.
- */
- private val wifiRequest: NetworkRequest? by lazy {
- try {
- NetworkRequest.Builder()
- .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
- .build()
- } catch (e: Exception) {
- AppLogger.w(TAG, "Wi-Fi transport request unavailable: ${e.message}")
- null
- }
- }
-
- /**
- * The location-flagged callback notes FINE_LOCATION on every delivery, which lights the privacy
- * indicator with GPS stopped. Register it only while the SSID is needed; VPN state needs no flag.
- */
- @Synchronized
- fun setSsidTracking(enabled: Boolean) {
- if (enabled == ssidTracking) return
- try {
- connectivityManager.unregisterNetworkCallback(networkCallback)
- } catch (e: Exception) {
- AppLogger.e(TAG, "Failed to unregister network callback", e)
- }
- networkCallback = createNetworkCallback(withSsid = enabled)
- try {
- connectivityManager.registerDefaultNetworkCallback(networkCallback)
- // Committed only once a callback is live, so a failed swap can be retried.
- ssidTracking = enabled
- // A cleared cache must not notify later as if the name just changed.
- if (!enabled) {
- currentSsid = ""
- notifiedSsid = ""
- }
- } catch (e: Exception) {
- AppLogger.e(TAG, "Failed to register network callback", e)
- }
- }
-
- /**
- * One-shot SSID read: the flagged callback is registered for this call only. The probe asks for
- * a Wi-Fi network rather than the default one, so it also reads the name under a VPN, where the
- * default network is the tunnel and carries no Wi-Fi info.
- */
- fun readSsidOnce(onResult: (String) -> Unit) {
- // A live value avoids a second flagged probe; a blank one still probes (VPN, or not yet read).
- if (ssidTracking && currentSsid.isNotBlank()) {
- onResult(currentSsid)
- return
- }
-
- if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) {
- // Below S the SSID comes from WifiManager, not the callback, so waiting on one would
- // only stall. WifiManager reports the connected network regardless of the VPN.
- onResult(readSsid(null))
- return
- }
-
- val request = wifiRequest
- if (request == null) {
- onResult("")
- return
- }
-
- val done = AtomicBoolean(false)
- var probe: ConnectivityManager.NetworkCallback? = null
- fun finish(ssid: String) {
- if (!done.compareAndSet(false, true)) return
- probe?.let {
- try {
- connectivityManager.unregisterNetworkCallback(it)
- } catch (e: Exception) {
- AppLogger.e(TAG, "Failed to unregister SSID probe", e)
- }
- }
- onResult(ssid)
- }
-
- probe = object : ConnectivityManager.NetworkCallback(FLAG_INCLUDE_LOCATION_INFO) {
- override fun onCapabilitiesChanged(network: Network, caps: NetworkCapabilities) = finish(readSsid(caps))
- }
-
- try {
- connectivityManager.registerNetworkCallback(request, probe)
- } catch (e: Exception) {
- AppLogger.e(TAG, "Failed to register SSID probe", e)
- probe = null
- finish("")
- return
- }
- Handler(Looper.getMainLooper()).postDelayed({ finish("") }, SSID_PROBE_TIMEOUT_MS)
- }
-
- private fun createNetworkCallback(withSsid: Boolean): ConnectivityManager.NetworkCallback {
- fun update(caps: NetworkCapabilities) {
- if (withSsid) currentSsid = readSsid(caps)
- isVpn = caps.hasTransport(NetworkCapabilities.TRANSPORT_VPN)
- notifyWifiStateIfChanged()
- }
- fun clear() {
- currentSsid = ""
- isVpn = false
- notifyWifiStateIfChanged()
- }
-
- return if (withSsid && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
- object : ConnectivityManager.NetworkCallback(FLAG_INCLUDE_LOCATION_INFO) {
- override fun onCapabilitiesChanged(network: Network, caps: NetworkCapabilities) = update(caps)
- override fun onLost(network: Network) = clear()
- }
- } else {
- object : ConnectivityManager.NetworkCallback() {
- override fun onCapabilitiesChanged(network: Network, caps: NetworkCapabilities) = update(caps)
- override fun onLost(network: Network) = clear()
- }
- }
- }
-
- private fun readSsid(caps: NetworkCapabilities?): String {
- val raw = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
- (caps?.transportInfo as? WifiInfo)?.ssid
- } else {
- @Suppress("DEPRECATION")
- wifiManager?.connectionInfo?.ssid
- }
- val ssid = raw?.removeSurrounding("\"") ?: ""
- // Android reports the placeholder without location permission or with Location off; treat
- // it as no name so the condition simply does not match (and the picker cannot offer it).
- return if (ssid == UNKNOWN_SSID) "" else ssid
- }
-
- private fun refreshWifiTransport(force: Boolean) {
- isWifi = availableWifiNetworks.get() > 0
- notifyWifiStateIfChanged(force)
- }
-
- /** Profile evaluation is not free, so only real state changes reach the listener, unless forced. */
- @Synchronized
- private fun notifyWifiStateIfChanged(force: Boolean = false) {
- val ssid = if (ssidTracking) currentSsid else ""
- if (!force && isWifi == notifiedWifi && isVpn == notifiedVpn && ssid == notifiedSsid) return
- notifiedWifi = isWifi
- notifiedVpn = isVpn
- notifiedSsid = ssid
- wifiStateListener?.invoke()
- }
-
- init {
- try {
- connectivityManager.registerDefaultNetworkCallback(networkCallback)
- } catch (e: Exception) {
- AppLogger.e(TAG, "Failed to register network callback", e)
- }
- wifiRequest?.let { request ->
- try {
- connectivityManager.registerNetworkCallback(request, wifiTransportCallback)
- } catch (e: Exception) {
- AppLogger.e(TAG, "Failed to register Wi-Fi transport callback", e)
- }
- }
- }
-
- private val networkCache = TimedCache(NETWORK_CHECK_CACHE_MS) {
- try {
- val network = connectivityManager.activeNetwork
- val capabilities = connectivityManager.getNetworkCapabilities(network)
- capabilities != null &&
- capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET) &&
- capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)
- } catch (e: Exception) {
- AppLogger.e(TAG, "Network check failed", e)
- false
- }
- }
-
- /**
- * Sends a location payload to the configured endpoint.
- * POST sends JSON in the body; GET appends fields as query parameters.
- */
- suspend fun sendToEndpoint(
- payload: JSONObject,
- endpoint: String,
- extraHeaders: Map<String, String> = emptyMap(),
- httpMethod: String = "POST",
- apiFormat: ApiFormat = ApiFormat.FIELD_MAPPED
- ): BatchResult {
- val result = runRequest(payload, endpoint, extraHeaders, httpMethod, apiFormat, emptyMap())
- if (result.ok) {
- AppLogger.d(TAG, "Location successfully sent")
- } else if (result.errorMessage != null) {
- AppLogger.e(TAG, result.errorMessage)
- }
- return if (result.httpStatus == 0) BatchResult.NetworkError else verdictFor(result.httpStatus, result.retryAfterSeconds)
- }
-
- private fun buildConnection(
- targetUrl: URL,
- isGet: Boolean,
- extraHeaders: Map<String, String>,
- ): HttpURLConnection = (targetUrl.openConnection() as HttpURLConnection).apply {
- requestMethod = if (isGet) "GET" else "POST"
- if (!isGet) {
- setRequestProperty("Content-Type", "application/json; charset=UTF-8")
- setRequestProperty("Accept", "application/json")
- doOutput = true
- }
- extraHeaders.forEach { (key, value) -> setRequestProperty(key, value) }
- setRequestProperty("Connection", "close")
- connectTimeout = CONNECTION_TIMEOUT
- readTimeout = READ_TIMEOUT
- useCaches = false
- if (this is HttpsURLConnection) {
- clientCertProvider.get()?.let { sslSocketFactory = it }
- }
- }
-
- private fun writeBody(connection: HttpURLConnection, payload: JSONObject) {
- val bodyBytes = payload.toString().toByteArray(StandardCharsets.UTF_8)
- connection.setFixedLengthStreamingMode(bodyBytes.size)
- connection.outputStream.use { it.write(bodyBytes) }
- }
-
- private fun logRequest(
- connection: HttpURLConnection,
- isGet: Boolean,
- resolvedEndpoint: String,
- targetUrl: URL,
- payload: JSONObject,
- ) {
- if (!BuildConfig.DEBUG) return
- AppLogger.d(TAG, "=== HTTP REQUEST ===")
- AppLogger.d(TAG, "Endpoint: ${AppLogger.maskSensitiveUrlValues(if (isGet) targetUrl.toString() else resolvedEndpoint)}")
- AppLogger.d(TAG, "Method: ${connection.requestMethod}")
- AppLogger.d(TAG, "Headers:")
- connection.requestProperties.forEach { (key, values) ->
- val masked = values.map { AppLogger.maskSensitiveHeaderValue(key, it) }
- AppLogger.d(TAG, "$key: ${masked.joinToString()}")
- }
- if (!isGet) {
- AppLogger.d(TAG, "Body: ${payload.toString(2)}")
- }
- AppLogger.d(TAG, "===================")
- }
-
- suspend fun sendBatchToEndpoint(
- items: List<JSONObject>,
- customFields: Map<String, String>,
- endpoint: String,
- extraHeaders: Map<String, String> = emptyMap(),
- ): BatchResult = withContext(Dispatchers.IO) {
- if (items.isEmpty()) return@withContext BatchResult.Success
- if (endpoint.isBlank()) {
- AppLogger.d(TAG, "Empty endpoint provided")
- return@withContext BatchResult.NetworkError
- }
-
- val resolvedEndpoint = resolveUrlVariables(endpoint, items.first())
-
- val url = try {
- URL(resolvedEndpoint)
- } catch (e: Exception) {
- AppLogger.e(TAG, "Invalid URL: ${AppLogger.maskSensitiveUrlValues(resolvedEndpoint)}")
- return@withContext BatchResult.NetworkError
- }
-
- if (!UrlSafety.isValidProtocol(resolvedEndpoint)) {
- AppLogger.e(TAG, "Protocol blocked or invalid: ${AppLogger.maskSensitiveUrlValues(endpoint)}")
- return@withContext BatchResult.NetworkError
- }
-
- if (!isNetworkAvailable()) {
- AppLogger.d(TAG, "Sync skipped: No internet")
- return@withContext BatchResult.NetworkError
- }
-
- val envelope = PayloadBuilder.buildOverlandBatchPayload(items, customFields)
-
- var connection: HttpURLConnection? = null
- try {
- connection = buildConnection(url, isGet = false, extraHeaders)
- logRequest(connection, isGet = false, resolvedEndpoint, url, envelope)
- writeBody(connection, envelope)
- return@withContext readBatchResponse(connection, items.size)
- } catch (e: java.net.SocketException) {
- if (UrlSafety.isPrivateHost(url.host ?: "") && e.message?.contains("EPERM") == true) {
- AppLogger.e(TAG, "Local network access denied - grant Local Network Access permission", e)
- } else {
- AppLogger.e(TAG, "Network error: ${e.message}", e)
- }
- BatchResult.NetworkError
- } catch (e: SSLHandshakeException) {
- AppLogger.e(TAG, mtlsErrorMessage(e), e)
- BatchResult.NetworkError
- } catch (e: UnrecoverableKeyException) {
- AppLogger.e(TAG, "Client certificate password is incorrect - re-import the .p12", e)
- BatchResult.NetworkError
- } catch (e: Exception) {
- AppLogger.e(TAG, "Network error: ${e.message}", e)
- BatchResult.NetworkError
- } finally {
- connection?.disconnect()
- }
- }
-
- /** Same as [sendToEndpoint] but returns status + error text instead of a verdict. */
- suspend fun testEndpoint(
- payload: JSONObject,
- endpoint: String,
- extraHeaders: Map<String, String> = emptyMap(),
- httpMethod: String = "POST",
- apiFormat: ApiFormat = ApiFormat.FIELD_MAPPED,
- customFields: Map<String, String> = emptyMap(),
- ): TestEndpointResult = runRequest(payload, endpoint, extraHeaders, httpMethod, apiFormat, customFields)
-
- /**
- * Shared request implementation. Returns a fully-populated [TestEndpointResult];
- * production callers project this to a [BatchResult] via [sendToEndpoint], while the
- * Test Connection path exposes it directly via [testEndpoint].
- */
- private suspend fun runRequest(
- payload: JSONObject,
- endpoint: String,
- extraHeaders: Map<String, String>,
- httpMethod: String,
- apiFormat: ApiFormat,
- customFields: Map<String, String>,
- ): TestEndpointResult = withContext(Dispatchers.IO) {
- if (endpoint.isBlank()) {
- return@withContext TestEndpointResult(false, errorMessage = "Endpoint is empty")
- }
- val resolvedEndpoint = resolveUrlVariables(endpoint, payload)
- val url = try {
- URL(resolvedEndpoint)
- } catch (_: Exception) {
- return@withContext TestEndpointResult(false, errorMessage = "Invalid URL: ${AppLogger.maskSensitiveUrlValues(resolvedEndpoint)}")
- }
- if (!UrlSafety.isValidProtocol(resolvedEndpoint)) {
- return@withContext TestEndpointResult(
- false,
- errorMessage = "HTTPS is required for public endpoints. HTTP is only allowed for private/local addresses."
- )
- }
- if (!isNetworkAvailable()) {
- return@withContext TestEndpointResult(false, errorMessage = "No internet connection")
- }
-
- val transformedPayload = when (apiFormat) {
- ApiFormat.TRACCAR_JSON -> PayloadBuilder.buildTraccarJsonPayload(payload)
- ApiFormat.OVERLAND_BATCH -> PayloadBuilder.buildOverlandBatchPayload(listOf(payload), customFields)
- ApiFormat.FIELD_MAPPED -> payload
- }
- val isGet = httpMethod.equals("GET", ignoreCase = true)
- val targetUrl = if (isGet) {
- val query = buildQueryString(transformedPayload)
- val separator = if (url.query != null) "&" else "?"
- URL("$resolvedEndpoint$separator$query")
- } else url
-
- var connection: HttpURLConnection? = null
- try {
- connection = buildConnection(targetUrl, isGet, extraHeaders)
- logRequest(connection, isGet, resolvedEndpoint, targetUrl, transformedPayload)
- if (!isGet) writeBody(connection, transformedPayload)
- readResponse(connection)
- } catch (e: SSLHandshakeException) {
- TestEndpointResult(false, errorMessage = mtlsErrorMessage(e))
- } catch (e: UnrecoverableKeyException) {
- TestEndpointResult(false, errorMessage = "Client certificate password is incorrect - re-import the .p12")
- } catch (e: java.net.SocketException) {
- val msg = if (UrlSafety.isPrivateHost(url.host ?: "") && e.message?.contains("EPERM") == true) {
- "Local network access denied - grant Local Network Access permission"
- } else "Network error: ${e.message}"
- TestEndpointResult(false, errorMessage = msg)
- } catch (e: java.net.SocketTimeoutException) {
- TestEndpointResult(false, errorMessage = "Connection timed out")
- } catch (e: Exception) {
- TestEndpointResult(false, errorMessage = "Connection failed: ${e.message ?: e.javaClass.simpleName}")
- } finally {
- connection?.disconnect()
- }
- }
-
- // Disambiguates the three TLS failure modes that look similar in logs but
- // need different fixes: untrusted server cert, missing client cert, rejected
- // client cert.
- private fun mtlsErrorMessage(e: SSLHandshakeException): String {
- val detail = (e.message ?: "") + " " + (e.cause?.message ?: "")
- val isServerNotTrusted = detail.contains("Trust anchor", ignoreCase = true) ||
- detail.contains("CertPathValidator", ignoreCase = true) ||
- detail.contains("unable to find valid certification path", ignoreCase = true)
- val isClientRejected = detail.contains("certificate_required", ignoreCase = true) ||
- detail.contains("bad_certificate", ignoreCase = true) ||
- detail.contains("handshake_failure", ignoreCase = true)
- val hasClientCert = clientCertProvider.get() != null
-
- return when {
- isServerNotTrusted ->
- "Server certificate is not trusted (self-signed or unknown CA). Import the server's CA under Connection > Client certificate, or use a publicly trusted certificate."
- isClientRejected && hasClientCert ->
- "Server rejected the client certificate. Common causes: cert signed by wrong CA, cert expired, or cert revoked."
- isClientRejected && !hasClientCert ->
- "Server requires a client certificate (mutual TLS) but none is configured. Add one under Connection > Client certificate."
- else ->
- "TLS handshake failed: ${e.message ?: e.javaClass.simpleName}"
- }
- }
-
- private fun readResponse(connection: HttpURLConnection): TestEndpointResult {
- val responseCode = connection.responseCode
- try {
- if (responseCode in 200..299) return TestEndpointResult(true, httpStatus = responseCode)
- val errorBody = readErrorBody(connection)
- return TestEndpointResult(
- false,
- httpStatus = responseCode,
- errorMessage = "Server returned $responseCode: $errorBody",
- retryAfterSeconds = if (responseCode == 429) retryAfterOf(connection) else null
- )
- } finally {
- discardBody(connection)
- }
- }
-
- private fun readBatchResponse(connection: HttpURLConnection, batchSize: Int): BatchResult {
- val responseCode = connection.responseCode
- try {
- return batchVerdict(connection, responseCode, batchSize)
- } finally {
- discardBody(connection)
- }
- }
-
- private fun batchVerdict(connection: HttpURLConnection, responseCode: Int, batchSize: Int): BatchResult =
- when (responseCode) {
- in 200..299 -> {
- AppLogger.d(TAG, "Batch of $batchSize sent successfully")
- BatchResult.Success
- }
- 429 -> {
- val retryAfter = retryAfterOf(connection)
- AppLogger.w(TAG, "Batch rate limited (429)" + (retryAfter?.let { ", retry after ${it}s" } ?: ""))
- BatchResult.RateLimited(retryAfter)
- }
- in 400..499 -> {
- val errorBody = readErrorBody(connection)
- AppLogger.w(TAG, "Batch rejected (4xx): $responseCode - $errorBody")
- BatchResult.ClientError(responseCode)
- }
- in 500..599 -> {
- val errorBody = readErrorBody(connection)
- AppLogger.e(TAG, "Batch failed (5xx): $responseCode - $errorBody")
- BatchResult.ServerError(responseCode)
- }
- else -> {
- AppLogger.e(TAG, "Batch failed with unexpected code: $responseCode")
- BatchResult.ServerError(responseCode)
- }
- }
-
- // disconnect() alone leaves a connection whose reply was never closed in the platform's pool for minutes.
- private fun discardBody(connection: HttpURLConnection) {
- try {
- (connection.errorStream ?: connection.inputStream)?.close()
- } catch (_: Exception) {
- }
- }
-
- private fun retryAfterOf(connection: HttpURLConnection): Long? =
- parseRetryAfter(connection.getHeaderField("Retry-After"), System.currentTimeMillis())
-
- /**
- * Bounded and single-line. A rate-limited flush logs one of these per rejected point, and an
- * nginx error page is 7 lines each - enough to push real events out of the rolling log file.
- */
- private fun readErrorBody(connection: HttpURLConnection): String = try {
- connection.errorStream?.bufferedReader()?.use { it.readText() }
- ?.replace(WHITESPACE, " ")?.trim()?.take(ERROR_BODY_MAX_CHARS) ?: "No error body"
- } catch (_: Exception) { "Could not read error body" }
-
- /**
- * Resolves template variables in the endpoint URL.
- * Uses the location's timestamp, not wall clock time,
- * so queued sends get the correct date.
- */
- @androidx.annotation.VisibleForTesting
- internal fun resolveUrlVariables(endpoint: String, payload: JSONObject): String {
- if (!endpoint.contains('%')) return endpoint
-
- val tst = payload.optLong("tst", 0L)
- val timestamp = if (tst > 0) tst else System.currentTimeMillis() / 1000
- val zoned = Instant.ofEpochSecond(timestamp).atZone(ZoneId.systemDefault())
-
- return endpoint
- .replace("%DATE", zoned.format(DateTimeFormatter.ISO_LOCAL_DATE))
- .replace("%YEAR", zoned.year.toString())
- .replace("%MONTH", String.format(java.util.Locale.ROOT, "%02d", zoned.monthValue))
- .replace("%DAY", String.format(java.util.Locale.ROOT, "%02d", zoned.dayOfMonth))
- .replace("%TIMESTAMP", timestamp.toString())
- }
-
- private fun buildQueryString(payload: JSONObject): String {
- val params = mutableListOf<String>()
- val keys = payload.keys()
- while (keys.hasNext()) {
- val key = keys.next()
- val raw = payload.opt(key) ?: continue
- val value = formatQueryValue(raw)
- params.add("${URLEncoder.encode(key, "UTF-8")}=${URLEncoder.encode(value, "UTF-8")}")
- }
- return params.joinToString("&")
- }
-
- private fun formatQueryValue(raw: Any): String = when {
- raw is Double && raw == raw.toLong().toDouble() -> raw.toLong().toString()
- else -> raw.toString()
- }
-
- /**
- * Checks for an active, validated internet connection with caching.
- */
- fun isNetworkAvailable(): Boolean = networkCache.get()
-
- private val unmeteredCache = TimedCache(NETWORK_CHECK_CACHE_MS) {
- try {
- val network = connectivityManager.activeNetwork
- val capabilities = connectivityManager.getNetworkCapabilities(network)
- capabilities != null &&
- capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED)
- } catch (e: Exception) {
- AppLogger.e(TAG, "Unmetered check failed", e)
- false
- }
- }
-
- /**
- * Returns true when the active network is unmetered (Wi-Fi, Ethernet, etc.).
- * Cached for [NETWORK_CHECK_CACHE_MS] to avoid repeated IPC calls.
- */
- fun isUnmeteredConnection(): Boolean = unmeteredCache.get()
-
- /**
- * Returns true when connected to a WiFi network matching the given SSID.
- * Only meaningful while setSsidTracking(true) holds the location-flagged callback.
- */
- fun isConnectedToSsid(ssid: String): Boolean {
- if (ssid.isBlank()) return false
- return currentSsid.equals(ssid, ignoreCase = true)
- }
-
- /** True while any Wi-Fi network is connected, also under a VPN. Needs no location-flagged callback. */
- fun isWifiConnected(): Boolean = isWifi
-
- /**
- * Registers a callback for Wi-Fi connection, VPN and SSID changes, and for every Wi-Fi network
- * that comes or goes. The listener runs on the ConnectivityManager callback thread; callers that
- * touch app state must marshal it themselves.
- * Used by the profile Wi-Fi conditions, which care about more than sync's one boolean.
- */
- fun setWifiStateListener(listener: (() -> Unit)?) {
- wifiStateListener = listener
- }
-
- /**
- * Returns true when the active network uses a VPN transport.
- * Updated via NetworkCallback.
- */
- fun isVpnConnected(): Boolean = isVpn
-
- fun destroy() {
- wifiStateListener = null
- try {
- connectivityManager.unregisterNetworkCallback(networkCallback)
- } catch (_: Exception) {}
- try {
- connectivityManager.unregisterNetworkCallback(wifiTransportCallback)
- } catch (_: Exception) {}
- }
-}
\ No newline at end of file
diff --git a/apps/mobile/android/app/src/main/java/com/colota/sync/PayloadBuilder.kt b/apps/mobile/android/app/src/main/java/com/colota/sync/PayloadBuilder.kt
index cca58c62..91400117 100644
--- a/apps/mobile/android/app/src/main/java/com/colota/sync/PayloadBuilder.kt
+++ b/apps/mobile/android/app/src/main/java/com/colota/sync/PayloadBuilder.kt
@@ -9,6 +9,7 @@ import android.location.Location
import com.Colota.util.AppLogger
import com.Colota.util.BatteryStatus
import org.json.JSONObject
+import java.net.URLEncoder
import java.time.Instant
import kotlin.math.roundToInt
@@ -206,4 +207,20 @@ object PayloadBuilder {
}
}
+ fun buildQueryString(payload: JSONObject): String {
+ val params = mutableListOf<String>()
+ val keys = payload.keys()
+ while (keys.hasNext()) {
+ val key = keys.next()
+ val raw = payload.opt(key) ?: continue
+ val value = formatQueryValue(raw)
+ params.add("${URLEncoder.encode(key, "UTF-8")}=${URLEncoder.encode(value, "UTF-8")}")
+ }
+ return params.joinToString("&")
+ }
+
+ private fun formatQueryValue(raw: Any): String = when {
+ raw is Double && raw == raw.toLong().toDouble() -> raw.toLong().toString()
+ else -> raw.toString()
+ }
}
diff --git a/apps/mobile/android/app/src/main/java/com/colota/sync/SyncManager.kt b/apps/mobile/android/app/src/main/java/com/colota/sync/SyncManager.kt
index 029293f3..04692fd8 100644
--- a/apps/mobile/android/app/src/main/java/com/colota/sync/SyncManager.kt
+++ b/apps/mobile/android/app/src/main/java/com/colota/sync/SyncManager.kt
@@ -16,6 +16,9 @@ import kotlinx.coroutines.sync.withLock
import org.json.JSONException
import org.json.JSONObject
import java.util.concurrent.ConcurrentHashMap
+import com.Colota.sync.http.NetworkManager
+import com.Colota.sync.http.BatchResult
+import com.Colota.network.NetworkMonitor
/**
* Two sync modes: instant (syncInterval=0) sends each location on arrival,
@@ -24,6 +27,7 @@ import java.util.concurrent.ConcurrentHashMap
class SyncManager(
private val dbHelper: DatabaseHelper,
private val networkManager: NetworkManager,
+ private val networkMonitor: NetworkMonitor,
private val scope: CoroutineScope,
private val clock: () -> Long = System::currentTimeMillis
) {
@@ -239,11 +243,11 @@ class SyncManager(
}
fun isSyncAllowed(): Boolean {
- if (isOfflineMode || !networkManager.isNetworkAvailable()) return false
+ if (isOfflineMode || !networkMonitor.isNetworkAvailable()) return false
val allowed = when (syncCondition) {
- "wifi_any" -> networkManager.isUnmeteredConnection()
- "wifi_ssid" -> networkManager.isConnectedToSsid(syncSsid)
- "vpn" -> networkManager.isVpnConnected()
+ "wifi_any" -> networkMonitor.isUnmeteredConnection()
+ "wifi_ssid" -> networkMonitor.isConnectedToSsid(syncSsid)
+ "vpn" -> networkMonitor.isVpnConnected()
else -> true // "any"
}
if (!allowed && syncCondition != "any") {
diff --git a/apps/mobile/android/app/src/main/java/com/colota/sync/http/EndpointUrl.kt b/apps/mobile/android/app/src/main/java/com/colota/sync/http/EndpointUrl.kt
new file mode 100644
index 00000000..e715444f
--- /dev/null
+++ b/apps/mobile/android/app/src/main/java/com/colota/sync/http/EndpointUrl.kt
@@ -0,0 +1,34 @@
+/**
+ * Copyright (C) 2026 Max Dietrich
+ * Licensed under the GNU AGPLv3. See LICENSE in the project root for details.
+ */
+
+package com.Colota.sync.http
+
+import org.json.JSONObject
+import java.time.Instant
+import java.time.ZoneId
+import java.time.format.DateTimeFormatter
+
+internal object EndpointUrl {
+
+ /**
+ * Resolves template variables in the endpoint URL.
+ * Uses the location's timestamp, not wall clock time,
+ * so queued sends get the correct date.
+ */
+ fun resolveUrlVariables(endpoint: String, payload: JSONObject): String {
+ if (!endpoint.contains('%')) return endpoint
+
+ val tst = payload.optLong("tst", 0L)
+ val timestamp = if (tst > 0) tst else System.currentTimeMillis() / 1000
+ val zoned = Instant.ofEpochSecond(timestamp).atZone(ZoneId.systemDefault())
+
+ return endpoint
+ .replace("%DATE", zoned.format(DateTimeFormatter.ISO_LOCAL_DATE))
+ .replace("%YEAR", zoned.year.toString())
+ .replace("%MONTH", String.format(java.util.Locale.ROOT, "%02d", zoned.monthValue))
+ .replace("%DAY", String.format(java.util.Locale.ROOT, "%02d", zoned.dayOfMonth))
+ .replace("%TIMESTAMP", timestamp.toString())
+ }
+}
diff --git a/apps/mobile/android/app/src/main/java/com/colota/sync/http/NetworkManager.kt b/apps/mobile/android/app/src/main/java/com/colota/sync/http/NetworkManager.kt
new file mode 100644
index 00000000..e1a064a8
--- /dev/null
+++ b/apps/mobile/android/app/src/main/java/com/colota/sync/http/NetworkManager.kt
@@ -0,0 +1,196 @@
+package com.Colota.sync.http
+
+import android.content.Context
+import com.Colota.util.AppLogger
+import com.Colota.sync.http.tls.ClientCertSslContextProvider
+import com.Colota.sync.http.tls.TlsFailure
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import org.json.JSONObject
+import java.net.HttpURLConnection
+import java.net.URL
+import java.security.UnrecoverableKeyException
+import javax.net.ssl.SSLHandshakeException
+import com.Colota.network.NetworkMonitor
+import com.Colota.sync.PayloadBuilder
+import com.Colota.sync.ApiFormat
+
+/**
+ * Sends requests to the user's endpoint.
+ */
+class NetworkManager(private val context: Context, private val networkMonitor: NetworkMonitor) {
+
+ companion object {
+ private const val TAG = "NetworkManager"
+ }
+
+ // Lazy so existing unit tests that mock Context don't trigger EncryptedSharedPreferences init.
+ // Singleton so invalidation propagates between every NetworkManager (foreground service +
+ // mTLS bridge module both hold their own NetworkManager).
+ private val clientCertProvider by lazy { ClientCertSslContextProvider.getInstance(context) }
+
+ private fun tlsFailureMessage(e: SSLHandshakeException) = TlsFailure.describe(e, clientCertProvider.get() != null)
+
+ /** Call after a client cert or trusted CA change so the next request picks it up. */
+ fun invalidateClientCertCache() {
+ clientCertProvider.invalidate()
+ }
+
+ /**
+ * Sends a location payload to the configured endpoint.
+ * POST sends JSON in the body; GET appends fields as query parameters.
+ */
+ suspend fun sendToEndpoint(
+ payload: JSONObject,
+ endpoint: String,
+ extraHeaders: Map<String, String> = emptyMap(),
+ httpMethod: String = "POST",
+ apiFormat: ApiFormat = ApiFormat.FIELD_MAPPED
+ ): BatchResult {
+ val result = runRequest(payload, endpoint, extraHeaders, httpMethod, apiFormat, emptyMap())
+ if (result.ok) {
+ AppLogger.d(TAG, "Location successfully sent")
+ } else if (result.errorMessage != null) {
+ AppLogger.e(TAG, result.errorMessage)
+ }
+ return if (result.httpStatus == 0) BatchResult.NetworkError else verdictFor(result.httpStatus, result.retryAfterSeconds)
+ }
+
+ suspend fun sendBatchToEndpoint(
+ items: List<JSONObject>,
+ customFields: Map<String, String>,
+ endpoint: String,
+ extraHeaders: Map<String, String> = emptyMap(),
+ ): BatchResult = withContext(Dispatchers.IO) {
+ if (items.isEmpty()) return@withContext BatchResult.Success
+ if (endpoint.isBlank()) {
+ AppLogger.d(TAG, "Empty endpoint provided")
+ return@withContext BatchResult.NetworkError
+ }
+
+ val resolvedEndpoint = EndpointUrl.resolveUrlVariables(endpoint, items.first())
+
+ val url = try {
+ URL(resolvedEndpoint)
+ } catch (e: Exception) {
+ AppLogger.e(TAG, "Invalid URL: ${AppLogger.maskSensitiveUrlValues(resolvedEndpoint)}")
+ return@withContext BatchResult.NetworkError
+ }
+
+ if (!UrlSafety.isValidProtocol(resolvedEndpoint)) {
+ AppLogger.e(TAG, "Protocol blocked or invalid: ${AppLogger.maskSensitiveUrlValues(endpoint)}")
+ return@withContext BatchResult.NetworkError
+ }
+
+ if (!networkMonitor.isNetworkAvailable()) {
+ AppLogger.d(TAG, "Sync skipped: No internet")
+ return@withContext BatchResult.NetworkError
+ }
+
+ val envelope = PayloadBuilder.buildOverlandBatchPayload(items, customFields)
+
+ var connection: HttpURLConnection? = null
+ try {
+ connection = RequestBuilder.open(url, isGet = false, extraHeaders) { clientCertProvider.get() }
+ RequestBuilder.logRequest(connection, isGet = false, resolvedEndpoint, url, envelope)
+ RequestBuilder.writeBody(connection, envelope)
+ return@withContext ResponseReader.readBatchResponse(connection, items.size)
+ } catch (e: java.net.SocketException) {
+ if (UrlSafety.isPrivateHost(url.host ?: "") && e.message?.contains("EPERM") == true) {
+ AppLogger.e(TAG, "Local network access denied - grant Local Network Access permission", e)
+ } else {
+ AppLogger.e(TAG, "Network error: ${e.message}", e)
+ }
+ BatchResult.NetworkError
+ } catch (e: SSLHandshakeException) {
+ AppLogger.e(TAG, tlsFailureMessage(e), e)
+ BatchResult.NetworkError
+ } catch (e: UnrecoverableKeyException) {
+ AppLogger.e(TAG, "Client certificate password is incorrect - re-import the .p12", e)
+ BatchResult.NetworkError
+ } catch (e: Exception) {
+ AppLogger.e(TAG, "Network error: ${e.message}", e)
+ BatchResult.NetworkError
+ } finally {
+ connection?.disconnect()
+ }
+ }
+
+ /** Same as [sendToEndpoint] but returns status + error text instead of a verdict. */
+ suspend fun testEndpoint(
+ payload: JSONObject,
+ endpoint: String,
+ extraHeaders: Map<String, String> = emptyMap(),
+ httpMethod: String = "POST",
+ apiFormat: ApiFormat = ApiFormat.FIELD_MAPPED,
+ customFields: Map<String, String> = emptyMap(),
+ ): TestEndpointResult = runRequest(payload, endpoint, extraHeaders, httpMethod, apiFormat, customFields)
+
+ /**
+ * Shared request implementation. Returns a fully-populated [TestEndpointResult];
+ * production callers project this to a [BatchResult] via [sendToEndpoint], while the
+ * Test Connection path exposes it directly via [testEndpoint].
+ */
+ private suspend fun runRequest(
+ payload: JSONObject,
+ endpoint: String,
+ extraHeaders: Map<String, String>,
+ httpMethod: String,
+ apiFormat: ApiFormat,
+ customFields: Map<String, String>,
+ ): TestEndpointResult = withContext(Dispatchers.IO) {
+ if (endpoint.isBlank()) {
+ return@withContext TestEndpointResult(false, errorMessage = "Endpoint is empty")
+ }
+ val resolvedEndpoint = EndpointUrl.resolveUrlVariables(endpoint, payload)
+ val url = try {
+ URL(resolvedEndpoint)
+ } catch (_: Exception) {
+ return@withContext TestEndpointResult(false, errorMessage = "Invalid URL: ${AppLogger.maskSensitiveUrlValues(resolvedEndpoint)}")
+ }
+ if (!UrlSafety.isValidProtocol(resolvedEndpoint)) {
+ return@withContext TestEndpointResult(
+ false,
+ errorMessage = "HTTPS is required for public endpoints. HTTP is only allowed for private/local addresses."
+ )
+ }
+ if (!networkMonitor.isNetworkAvailable()) {
+ return@withContext TestEndpointResult(false, errorMessage = "No internet connection")
+ }
+
+ val transformedPayload = when (apiFormat) {
+ ApiFormat.TRACCAR_JSON -> PayloadBuilder.buildTraccarJsonPayload(payload)
+ ApiFormat.OVERLAND_BATCH -> PayloadBuilder.buildOverlandBatchPayload(listOf(payload), customFields)
+ ApiFormat.FIELD_MAPPED -> payload
+ }
+ val isGet = httpMethod.equals("GET", ignoreCase = true)
+ val targetUrl = if (isGet) {
+ val query = PayloadBuilder.buildQueryString(transformedPayload)
+ val separator = if (url.query != null) "&" else "?"
+ URL("$resolvedEndpoint$separator$query")
+ } else url
+
+ var connection: HttpURLConnection? = null
+ try {
+ connection = RequestBuilder.open(targetUrl, isGet, extraHeaders) { clientCertProvider.get() }
+ RequestBuilder.logRequest(connection, isGet, resolvedEndpoint, targetUrl, transformedPayload)
+ if (!isGet) RequestBuilder.writeBody(connection, transformedPayload)
+ ResponseReader.readResponse(connection)
+ } catch (e: SSLHandshakeException) {
+ TestEndpointResult(false, errorMessage = tlsFailureMessage(e))
+ } catch (e: UnrecoverableKeyException) {
+ TestEndpointResult(false, errorMessage = "Client certificate password is incorrect - re-import the .p12")
+ } catch (e: java.net.SocketException) {
+ val msg = if (UrlSafety.isPrivateHost(url.host ?: "") && e.message?.contains("EPERM") == true) {
+ "Local network access denied - grant Local Network Access permission"
+ } else "Network error: ${e.message}"
+ TestEndpointResult(false, errorMessage = msg)
+ } catch (e: java.net.SocketTimeoutException) {
+ TestEndpointResult(false, errorMessage = "Connection timed out")
+ } catch (e: Exception) {
+ TestEndpointResult(false, errorMessage = "Connection failed: ${e.message ?: e.javaClass.simpleName}")
+ } finally {
+ connection?.disconnect()
+ }
+ }
+}
diff --git a/apps/mobile/android/app/src/main/java/com/colota/sync/NetworkResults.kt b/apps/mobile/android/app/src/main/java/com/colota/sync/http/NetworkResults.kt
similarity index 98%
rename from apps/mobile/android/app/src/main/java/com/colota/sync/NetworkResults.kt
rename to apps/mobile/android/app/src/main/java/com/colota/sync/http/NetworkResults.kt
index 2046c1c1..eebd8097 100644
--- a/apps/mobile/android/app/src/main/java/com/colota/sync/NetworkResults.kt
+++ b/apps/mobile/android/app/src/main/java/com/colota/sync/http/NetworkResults.kt
@@ -3,7 +3,7 @@
* Licensed under the GNU AGPLv3. See LICENSE in the project root for details.
*/
-package com.Colota.sync
+package com.Colota.sync.http
import java.time.ZonedDateTime
import java.time.format.DateTimeFormatter
diff --git a/apps/mobile/android/app/src/main/java/com/colota/sync/http/RequestBuilder.kt b/apps/mobile/android/app/src/main/java/com/colota/sync/http/RequestBuilder.kt
new file mode 100644
index 00000000..bf4d0f07
--- /dev/null
+++ b/apps/mobile/android/app/src/main/java/com/colota/sync/http/RequestBuilder.kt
@@ -0,0 +1,73 @@
+/**
+ * Copyright (C) 2026 Max Dietrich
+ * Licensed under the GNU AGPLv3. See LICENSE in the project root for details.
+ */
+
+package com.Colota.sync.http
+
+import com.Colota.BuildConfig
+import com.Colota.util.AppLogger
+import org.json.JSONObject
+import java.net.HttpURLConnection
+import java.net.URL
+import java.nio.charset.StandardCharsets
+import javax.net.ssl.HttpsURLConnection
+import javax.net.ssl.SSLSocketFactory
+
+/** Opens the connection for one request, sets its headers and writes its body. */
+internal object RequestBuilder {
+
+ private const val TAG = "NetworkManager"
+ private const val CONNECTION_TIMEOUT = 10000
+ private const val READ_TIMEOUT = 10000
+
+ fun open(
+ targetUrl: URL,
+ isGet: Boolean,
+ extraHeaders: Map<String, String>,
+ clientCertFactory: () -> SSLSocketFactory?,
+ ): HttpURLConnection = (targetUrl.openConnection() as HttpURLConnection).apply {
+ requestMethod = if (isGet) "GET" else "POST"
+ if (!isGet) {
+ setRequestProperty("Content-Type", "application/json; charset=UTF-8")
+ setRequestProperty("Accept", "application/json")
+ doOutput = true
+ }
+ extraHeaders.forEach { (key, value) -> setRequestProperty(key, value) }
+ setRequestProperty("Connection", "close")
+ connectTimeout = CONNECTION_TIMEOUT
+ readTimeout = READ_TIMEOUT
+ useCaches = false
+ if (this is HttpsURLConnection) {
+ clientCertFactory()?.let { sslSocketFactory = it }
+ }
+ }
+
+ fun writeBody(connection: HttpURLConnection, payload: JSONObject) {
+ val bodyBytes = payload.toString().toByteArray(StandardCharsets.UTF_8)
+ connection.setFixedLengthStreamingMode(bodyBytes.size)
+ connection.outputStream.use { it.write(bodyBytes) }
+ }
+
+ fun logRequest(
+ connection: HttpURLConnection,
+ isGet: Boolean,
+ resolvedEndpoint: String,
+ targetUrl: URL,
+ payload: JSONObject,
+ ) {
+ if (!BuildConfig.DEBUG) return
+ AppLogger.d(TAG, "=== HTTP REQUEST ===")
+ AppLogger.d(TAG, "Endpoint: ${AppLogger.maskSensitiveUrlValues(if (isGet) targetUrl.toString() else resolvedEndpoint)}")
+ AppLogger.d(TAG, "Method: ${connection.requestMethod}")
+ AppLogger.d(TAG, "Headers:")
+ connection.requestProperties.forEach { (key, values) ->
+ val masked = values.map { AppLogger.maskSensitiveHeaderValue(key, it) }
+ AppLogger.d(TAG, "$key: ${masked.joinToString()}")
+ }
+ if (!isGet) {
+ AppLogger.d(TAG, "Body: ${payload.toString(2)}")
+ }
+ AppLogger.d(TAG, "===================")
+ }
+}
diff --git a/apps/mobile/android/app/src/main/java/com/colota/sync/http/ResponseReader.kt b/apps/mobile/android/app/src/main/java/com/colota/sync/http/ResponseReader.kt
new file mode 100644
index 00000000..33056c77
--- /dev/null
+++ b/apps/mobile/android/app/src/main/java/com/colota/sync/http/ResponseReader.kt
@@ -0,0 +1,89 @@
+/**
+ * Copyright (C) 2026 Max Dietrich
+ * Licensed under the GNU AGPLv3. See LICENSE in the project root for details.
+ */
+
+package com.Colota.sync.http
+
+import com.Colota.util.AppLogger
+import java.net.HttpURLConnection
+
+/** Turns the reply on a connection into a result, then closes it. */
+internal object ResponseReader {
+
+ private const val TAG = "NetworkManager"
+ private const val ERROR_BODY_MAX_CHARS = 200
+ private val WHITESPACE = Regex("\\s+")
+
+ fun readResponse(connection: HttpURLConnection): TestEndpointResult {
+ val responseCode = connection.responseCode
+ try {
+ if (responseCode in 200..299) return TestEndpointResult(true, httpStatus = responseCode)
+ val errorBody = readErrorBody(connection)
+ return TestEndpointResult(
+ false,
+ httpStatus = responseCode,
+ errorMessage = "Server returned $responseCode: $errorBody",
+ retryAfterSeconds = if (responseCode == 429) retryAfterOf(connection) else null
+ )
+ } finally {
+ discardBody(connection)
+ }
+ }
+
+ fun readBatchResponse(connection: HttpURLConnection, batchSize: Int): BatchResult {
+ val responseCode = connection.responseCode
+ try {
+ return batchVerdict(connection, responseCode, batchSize)
+ } finally {
+ discardBody(connection)
+ }
+ }
+
+ private fun batchVerdict(connection: HttpURLConnection, responseCode: Int, batchSize: Int): BatchResult =
+ when (responseCode) {
+ in 200..299 -> {
+ AppLogger.d(TAG, "Batch of $batchSize sent successfully")
+ BatchResult.Success
+ }
+ 429 -> {
+ val retryAfter = retryAfterOf(connection)
+ AppLogger.w(TAG, "Batch rate limited (429)" + (retryAfter?.let { ", retry after ${it}s" } ?: ""))
+ BatchResult.RateLimited(retryAfter)
+ }
+ in 400..499 -> {
+ val errorBody = readErrorBody(connection)
+ AppLogger.w(TAG, "Batch rejected (4xx): $responseCode - $errorBody")
+ BatchResult.ClientError(responseCode)
+ }
+ in 500..599 -> {
+ val errorBody = readErrorBody(connection)
+ AppLogger.e(TAG, "Batch failed (5xx): $responseCode - $errorBody")
+ BatchResult.ServerError(responseCode)
+ }
+ else -> {
+ AppLogger.e(TAG, "Batch failed with unexpected code: $responseCode")
+ BatchResult.ServerError(responseCode)
+ }
+ }
+
+ // disconnect() alone leaves a connection whose reply was never closed in the platform's pool for minutes.
+ fun discardBody(connection: HttpURLConnection) {
+ try {
+ (connection.errorStream ?: connection.inputStream)?.close()
+ } catch (_: Exception) {
+ }
+ }
+
+ private fun retryAfterOf(connection: HttpURLConnection): Long? =
+ parseRetryAfter(connection.getHeaderField("Retry-After"), System.currentTimeMillis())
+
+ /**
+ * Bounded and single-line. A rate-limited flush logs one of these per rejected point, and an
+ * nginx error page is 7 lines each - enough to push real events out of the rolling log file.
+ */
+ fun readErrorBody(connection: HttpURLConnection): String = try {
+ connection.errorStream?.bufferedReader()?.use { it.readText() }
+ ?.replace(WHITESPACE, " ")?.trim()?.take(ERROR_BODY_MAX_CHARS) ?: "No error body"
+ } catch (_: Exception) { "Could not read error body" }
+}
diff --git a/apps/mobile/android/app/src/main/java/com/colota/sync/UrlSafety.kt b/apps/mobile/android/app/src/main/java/com/colota/sync/http/UrlSafety.kt
similarity index 98%
rename from apps/mobile/android/app/src/main/java/com/colota/sync/UrlSafety.kt
rename to apps/mobile/android/app/src/main/java/com/colota/sync/http/UrlSafety.kt
index 0b0d3992..23d76a41 100644
--- a/apps/mobile/android/app/src/main/java/com/colota/sync/UrlSafety.kt
+++ b/apps/mobile/android/app/src/main/java/com/colota/sync/http/UrlSafety.kt
@@ -3,7 +3,7 @@
* Licensed under the GNU AGPLv3. See LICENSE in the project root for details.
*/
-package com.Colota.sync
+package com.Colota.sync.http
import androidx.annotation.VisibleForTesting
import java.net.InetAddress
diff --git a/apps/mobile/android/app/src/main/java/com/colota/sync/tls/ClientCertSslContextProvider.kt b/apps/mobile/android/app/src/main/java/com/colota/sync/http/tls/ClientCertSslContextProvider.kt
similarity index 99%
rename from apps/mobile/android/app/src/main/java/com/colota/sync/tls/ClientCertSslContextProvider.kt
rename to apps/mobile/android/app/src/main/java/com/colota/sync/http/tls/ClientCertSslContextProvider.kt
index 1c812a4a..657b08f0 100644
--- a/apps/mobile/android/app/src/main/java/com/colota/sync/tls/ClientCertSslContextProvider.kt
+++ b/apps/mobile/android/app/src/main/java/com/colota/sync/http/tls/ClientCertSslContextProvider.kt
@@ -3,7 +3,7 @@
* Licensed under the GNU AGPLv3. See LICENSE in the project root for details.
*/
-package com.Colota.sync.tls
+package com.Colota.sync.http.tls
import android.content.Context
import com.Colota.util.AppLogger
diff --git a/apps/mobile/android/app/src/main/java/com/colota/sync/tls/CompositeX509TrustManager.kt b/apps/mobile/android/app/src/main/java/com/colota/sync/http/tls/CompositeX509TrustManager.kt
similarity index 97%
rename from apps/mobile/android/app/src/main/java/com/colota/sync/tls/CompositeX509TrustManager.kt
rename to apps/mobile/android/app/src/main/java/com/colota/sync/http/tls/CompositeX509TrustManager.kt
index 9acb21fe..04bb1c9c 100644
--- a/apps/mobile/android/app/src/main/java/com/colota/sync/tls/CompositeX509TrustManager.kt
+++ b/apps/mobile/android/app/src/main/java/com/colota/sync/http/tls/CompositeX509TrustManager.kt
@@ -3,7 +3,7 @@
* Licensed under the GNU AGPLv3. See LICENSE in the project root for details.
*/
-package com.Colota.sync.tls
+package com.Colota.sync.http.tls
import java.security.cert.CertificateException
import java.security.cert.X509Certificate
diff --git a/apps/mobile/android/app/src/main/java/com/colota/sync/tls/DynamicKeyManager.kt b/apps/mobile/android/app/src/main/java/com/colota/sync/http/tls/DynamicKeyManager.kt
similarity index 99%
rename from apps/mobile/android/app/src/main/java/com/colota/sync/tls/DynamicKeyManager.kt
rename to apps/mobile/android/app/src/main/java/com/colota/sync/http/tls/DynamicKeyManager.kt
index c818fae0..0614ab44 100644
--- a/apps/mobile/android/app/src/main/java/com/colota/sync/tls/DynamicKeyManager.kt
+++ b/apps/mobile/android/app/src/main/java/com/colota/sync/http/tls/DynamicKeyManager.kt
@@ -3,7 +3,7 @@
* Licensed under the GNU AGPLv3. See LICENSE in the project root for details.
*/
-package com.Colota.sync.tls
+package com.Colota.sync.http.tls
import android.content.Context
import android.security.KeyChain
diff --git a/apps/mobile/android/app/src/main/java/com/colota/sync/http/tls/TlsFailure.kt b/apps/mobile/android/app/src/main/java/com/colota/sync/http/tls/TlsFailure.kt
new file mode 100644
index 00000000..15cb034b
--- /dev/null
+++ b/apps/mobile/android/app/src/main/java/com/colota/sync/http/tls/TlsFailure.kt
@@ -0,0 +1,33 @@
+/**
+ * Copyright (C) 2026 Max Dietrich
+ * Licensed under the GNU AGPLv3. See LICENSE in the project root for details.
+ */
+
+package com.Colota.sync.http.tls
+
+import javax.net.ssl.SSLHandshakeException
+
+/** Tells apart an untrusted server certificate, a missing client certificate and a rejected one. */
+internal object TlsFailure {
+
+ fun describe(e: SSLHandshakeException, hasClientCert: Boolean): String {
+ val detail = (e.message ?: "") + " " + (e.cause?.message ?: "")
+ val isServerNotTrusted = detail.contains("Trust anchor", ignoreCase = true) ||
+ detail.contains("CertPathValidator", ignoreCase = true) ||
+ detail.contains("unable to find valid certification path", ignoreCase = true)
+ val isClientRejected = detail.contains("certificate_required", ignoreCase = true) ||
+ detail.contains("bad_certificate", ignoreCase = true) ||
+ detail.contains("handshake_failure", ignoreCase = true)
+
+ return when {
+ isServerNotTrusted ->
+ "Server certificate is not trusted (self-signed or unknown CA). Import the server's CA under Connection > Client certificate, or use a publicly trusted certificate."
+ isClientRejected && hasClientCert ->
+ "Server rejected the client certificate. Common causes: cert signed by wrong CA, cert expired, or cert revoked."
+ isClientRejected && !hasClientCert ->
+ "Server requires a client certificate (mutual TLS) but none is configured. Add one under Connection > Client certificate."
+ else ->
+ "TLS handshake failed: ${e.message ?: e.javaClass.simpleName}"
+ }
+ }
+}
diff --git a/apps/mobile/android/app/src/test/java/com/Colota/bridge/LocationServiceModuleTest.kt b/apps/mobile/android/app/src/test/java/com/Colota/bridge/LocationServiceModuleTest.kt
index 2d1dac61..ca207491 100644
--- a/apps/mobile/android/app/src/test/java/com/Colota/bridge/LocationServiceModuleTest.kt
+++ b/apps/mobile/android/app/src/test/java/com/Colota/bridge/LocationServiceModuleTest.kt
@@ -68,7 +68,7 @@ class LocationServiceModuleTest {
// an assertion about what one event carries silently reads what a later one wrote.
every { Arguments.createMap() } answers { JavaOnlyMap() }
- // NetworkManager casts this in a field initialiser, and a relaxed mock hands back an Object.
+ // NetworkMonitor casts this in a field initialiser, and a relaxed mock hands back an Object.
every { mockContext.getSystemService(Context.CONNECTIVITY_SERVICE) } returns mockk<ConnectivityManager>(relaxed = true)
mockkObject(DatabaseHelper.Companion)
diff --git a/apps/mobile/android/app/src/test/java/com/Colota/network/NetworkMonitorTest.kt b/apps/mobile/android/app/src/test/java/com/Colota/network/NetworkMonitorTest.kt
new file mode 100644
index 00000000..a78df71a
--- /dev/null
+++ b/apps/mobile/android/app/src/test/java/com/Colota/network/NetworkMonitorTest.kt
@@ -0,0 +1,241 @@
+package com.Colota.network
+
+import android.content.Context
+import android.net.ConnectivityManager
+import android.net.NetworkCapabilities
+import android.net.NetworkRequest
+import android.net.wifi.WifiInfo
+import android.net.wifi.WifiManager
+import org.junit.Assert.*
+import org.junit.Test
+import com.Colota.util.AppLogger
+import io.mockk.*
+import org.junit.After
+import org.junit.Before
+
+/** Callback registration and state of NetworkMonitor against a mocked ConnectivityManager. */
+class NetworkMonitorTest {
+
+ @Before
+ fun setUp() {
+ mockkObject(AppLogger)
+ every { AppLogger.d(any(), any()) } just Runs
+ every { AppLogger.i(any(), any()) } just Runs
+ every { AppLogger.w(any(), any()) } just Runs
+ every { AppLogger.e(any(), any(), any()) } just Runs
+
+ // With returnDefaultValues the mocked Builder chain returns null and every NetworkMonitor
+ // construction would NPE. The real request is irrelevant to these tests.
+ mockkConstructor(NetworkRequest.Builder::class)
+ every { anyConstructed<NetworkRequest.Builder>().addTransportType(any()) } returns mockk(relaxed = true)
+ every { anyConstructed<NetworkRequest.Builder>().build() } returns mockk(relaxed = true)
+ }
+
+ @After
+ fun tearDown() {
+ unmockkConstructor(NetworkRequest.Builder::class)
+ unmockkObject(AppLogger)
+ }
+
+ // --- network callback registration ---
+
+ private fun newMonitorWith(cm: ConnectivityManager): NetworkMonitor {
+ val ctx = mockk<Context>(relaxed = true)
+ every { ctx.getSystemService(Context.CONNECTIVITY_SERVICE) } returns cm
+ every { ctx.getSystemService(Context.WIFI_SERVICE) } returns null
+ return NetworkMonitor(ctx)
+ }
+
+ @Test
+ fun `setSsidTracking swaps the callback in both directions`() {
+ val cm = mockk<ConnectivityManager>(relaxed = true)
+ val monitor = newMonitorWith(cm)
+
+ verify(exactly = 1) { cm.registerDefaultNetworkCallback(any<ConnectivityManager.NetworkCallback>()) }
+ verify(exactly = 0) { cm.unregisterNetworkCallback(any<ConnectivityManager.NetworkCallback>()) }
+
+ monitor.setSsidTracking(true)
+ verify(exactly = 1) { cm.unregisterNetworkCallback(any<ConnectivityManager.NetworkCallback>()) }
+ verify(exactly = 2) { cm.registerDefaultNetworkCallback(any<ConnectivityManager.NetworkCallback>()) }
+
+ monitor.setSsidTracking(false)
+ verify(exactly = 2) { cm.unregisterNetworkCallback(any<ConnectivityManager.NetworkCallback>()) }
+ verify(exactly = 3) { cm.registerDefaultNetworkCallback(any<ConnectivityManager.NetworkCallback>()) }
+ }
+
+ @Test
+ fun `setSsidTracking with an unchanged value does not churn the callback`() {
+ val cm = mockk<ConnectivityManager>(relaxed = true)
+ val monitor = newMonitorWith(cm)
+
+ monitor.setSsidTracking(false)
+ monitor.setSsidTracking(false)
+ verify(exactly = 1) { cm.registerDefaultNetworkCallback(any<ConnectivityManager.NetworkCallback>()) }
+
+ monitor.setSsidTracking(true)
+ monitor.setSsidTracking(true)
+ verify(exactly = 2) { cm.registerDefaultNetworkCallback(any<ConnectivityManager.NetworkCallback>()) }
+ }
+
+ @Test
+ fun `the SSID is only read while tracking is on`() {
+ val cm = mockk<ConnectivityManager>(relaxed = true)
+ val slot = slot<ConnectivityManager.NetworkCallback>()
+ every { cm.registerDefaultNetworkCallback(capture(slot)) } just Runs
+ val info = mockk<WifiInfo>(relaxed = true)
+ every { info.ssid } returns "\"HomeNet\""
+ val wifi = mockk<WifiManager>(relaxed = true)
+ every { wifi.connectionInfo } returns info
+ val ctx = mockk<Context>(relaxed = true)
+ every { ctx.getSystemService(Context.CONNECTIVITY_SERVICE) } returns cm
+ every { ctx.getSystemService(Context.WIFI_SERVICE) } returns wifi
+ val monitor = NetworkMonitor(ctx)
+
+ slot.captured.onCapabilitiesChanged(mockk(relaxed = true), mockk(relaxed = true))
+ assertFalse(monitor.isConnectedToSsid("HomeNet"))
+ assertEquals("", monitor.currentSsid)
+
+ monitor.setSsidTracking(true)
+ slot.captured.onCapabilitiesChanged(mockk(relaxed = true), mockk(relaxed = true))
+ assertTrue(monitor.isConnectedToSsid("HomeNet"))
+ assertEquals("HomeNet", monitor.currentSsid)
+ }
+
+ @Test
+ fun `the plain callback still tracks VPN state`() {
+ val cm = mockk<ConnectivityManager>(relaxed = true)
+ val slot = slot<ConnectivityManager.NetworkCallback>()
+ every { cm.registerDefaultNetworkCallback(capture(slot)) } just Runs
+ val monitor = newMonitorWith(cm)
+
+ val caps = mockk<NetworkCapabilities>(relaxed = true)
+ every { caps.hasTransport(NetworkCapabilities.TRANSPORT_VPN) } returns true
+ slot.captured.onCapabilitiesChanged(mockk(relaxed = true), caps)
+
+ assertTrue(monitor.isVpnConnected())
+ }
+
+ @Test
+ fun `the wifi transport callback notifies the listener on availability and loss`() {
+ val cm = mockk<ConnectivityManager>(relaxed = true)
+ val slot = slot<ConnectivityManager.NetworkCallback>()
+ every { cm.registerNetworkCallback(any<NetworkRequest>(), capture(slot)) } just Runs
+ val monitor = newMonitorWith(cm)
+ var changes = 0
+ monitor.setWifiStateListener { changes++ }
+
+ slot.captured.onAvailable(mockk(relaxed = true))
+
+ assertTrue(monitor.isWifiConnected())
+ assertEquals(1, changes)
+
+ slot.captured.onLost(mockk(relaxed = true))
+
+ assertFalse(monitor.isWifiConnected())
+ assertEquals(2, changes)
+ }
+
+ /** An automatic switch connects the new network before the old one goes. */
+ @Test
+ fun `a switch between two Wi-Fi networks still notifies`() {
+ val cm = mockk<ConnectivityManager>(relaxed = true)
+ val slot = slot<ConnectivityManager.NetworkCallback>()
+ every { cm.registerNetworkCallback(any<NetworkRequest>(), capture(slot)) } just Runs
+ val monitor = newMonitorWith(cm)
+ var changes = 0
+ monitor.setWifiStateListener { changes++ }
+
+ slot.captured.onAvailable(mockk(relaxed = true))
+ slot.captured.onAvailable(mockk(relaxed = true))
+ slot.captured.onLost(mockk(relaxed = true))
+
+ assertTrue(monitor.isWifiConnected())
+ assertEquals(3, changes)
+ }
+
+ @Test
+ fun `identical capability deliveries do not notify twice`() {
+ // Bandwidth and validation updates arrive without any transport or SSID change; each one
+ // used to run a full profile evaluation.
+ val cm = mockk<ConnectivityManager>(relaxed = true)
+ val slot = slot<ConnectivityManager.NetworkCallback>()
+ every { cm.registerDefaultNetworkCallback(capture(slot)) } just Runs
+ val monitor = newMonitorWith(cm)
+ var changes = 0
+ monitor.setWifiStateListener { changes++ }
+
+ val caps = mockk<NetworkCapabilities>(relaxed = true)
+ every { caps.hasTransport(NetworkCapabilities.TRANSPORT_VPN) } returns true
+ slot.captured.onCapabilitiesChanged(mockk(relaxed = true), caps)
+ slot.captured.onCapabilitiesChanged(mockk(relaxed = true), caps)
+ slot.captured.onCapabilitiesChanged(mockk(relaxed = true), caps)
+
+ assertEquals(1, changes)
+ }
+
+ @Test
+ fun `a VPN default network does not hide an available Wi-Fi network`() {
+ // The VPN network reports the underlying transports on Android 14+, but the app's Wi-Fi
+ // transport callback sees the Wi-Fi network regardless of which network is the default.
+ val cm = mockk<ConnectivityManager>(relaxed = true)
+ val defaultSlot = slot<ConnectivityManager.NetworkCallback>()
+ every { cm.registerDefaultNetworkCallback(capture(defaultSlot)) } just Runs
+ val wifiSlot = slot<ConnectivityManager.NetworkCallback>()
+ every { cm.registerNetworkCallback(any<NetworkRequest>(), capture(wifiSlot)) } just Runs
+ val monitor = newMonitorWith(cm)
+ var changes = 0
+ monitor.setWifiStateListener { changes++ }
+
+ wifiSlot.captured.onAvailable(mockk(relaxed = true))
+
+ assertTrue(monitor.isWifiConnected())
+ assertEquals(1, changes)
+
+ val vpnCaps = mockk<NetworkCapabilities>(relaxed = true)
+ every { vpnCaps.hasTransport(NetworkCapabilities.TRANSPORT_VPN) } returns true
+ every { vpnCaps.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) } returns true
+ defaultSlot.captured.onCapabilitiesChanged(mockk(relaxed = true), vpnCaps)
+
+ assertTrue(monitor.isVpnConnected())
+ assertTrue(monitor.isWifiConnected())
+ assertEquals(2, changes)
+ }
+
+ @Test
+ fun `the unknown SSID placeholder reads as no name`() {
+ // Android returns "<unknown ssid>" without location permission or with Location off; that
+ // must not be saved as a network name or matched against one.
+ val cm = mockk<ConnectivityManager>(relaxed = true)
+ val slot = slot<ConnectivityManager.NetworkCallback>()
+ every { cm.registerDefaultNetworkCallback(capture(slot)) } just Runs
+ val info = mockk<WifiInfo>(relaxed = true)
+ every { info.ssid } returns "\"<unknown ssid>\""
+ val wifi = mockk<WifiManager>(relaxed = true)
+ every { wifi.connectionInfo } returns info
+ val ctx = mockk<Context>(relaxed = true)
+ every { ctx.getSystemService(Context.CONNECTIVITY_SERVICE) } returns cm
+ every { ctx.getSystemService(Context.WIFI_SERVICE) } returns wifi
+ val monitor = NetworkMonitor(ctx)
+
+ monitor.setSsidTracking(true)
+ slot.captured.onCapabilitiesChanged(mockk(relaxed = true), mockk(relaxed = true))
+
+ assertEquals("", monitor.currentSsid)
+ assertFalse(monitor.isConnectedToSsid("<unknown ssid>"))
+ }
+
+ @Test
+ fun `clearing the listener stops notifications`() {
+ val cm = mockk<ConnectivityManager>(relaxed = true)
+ val slot = slot<ConnectivityManager.NetworkCallback>()
+ every { cm.registerNetworkCallback(any<NetworkRequest>(), capture(slot)) } just Runs
+ val monitor = newMonitorWith(cm)
+ var changes = 0
+ monitor.setWifiStateListener { changes++ }
+ monitor.setWifiStateListener(null)
+
+ slot.captured.onAvailable(mockk(relaxed = true))
+
+ assertEquals(0, changes)
+ }
+}
diff --git a/apps/mobile/android/app/src/test/java/com/Colota/service/ConditionMonitorTest.kt b/apps/mobile/android/app/src/test/java/com/Colota/service/ConditionMonitorTest.kt
index 1cfb73f8..e427099e 100644
--- a/apps/mobile/android/app/src/test/java/com/Colota/service/ConditionMonitorTest.kt
+++ b/apps/mobile/android/app/src/test/java/com/Colota/service/ConditionMonitorTest.kt
@@ -22,7 +22,7 @@ import io.mockk.*
import org.junit.Assert.*
import org.junit.Before
import org.junit.Test
-import com.Colota.sync.NetworkManager
+import com.Colota.network.NetworkMonitor
import com.Colota.util.AppLogger
import org.junit.After
@@ -37,7 +37,7 @@ import org.junit.After
class ConditionMonitorTest {
private lateinit var mockContext: Context
- private lateinit var mockNetworkManager: NetworkManager
+ private lateinit var mockNetworkMonitor: NetworkMonitor
private lateinit var mockProfileManager: ProfileManager
private lateinit var mockHandler: Handler
private lateinit var monitor: ConditionMonitor
@@ -45,7 +45,7 @@ class ConditionMonitorTest {
@Before
fun setUp() {
mockContext = mockk(relaxed = true)
- mockNetworkManager = mockk(relaxed = true)
+ mockNetworkMonitor = mockk(relaxed = true)
mockProfileManager = mockk(relaxed = true)
mockHandler = mockk(relaxed = true)
@@ -166,15 +166,15 @@ class ConditionMonitorTest {
fun `start probes the SSID once when a profile watches the network`() {
mockBatteryStatus(BatteryManager.BATTERY_STATUS_DISCHARGING)
every { mockProfileManager.getNeededConditionTypes() } returns setOf(ProfileConstants.CONDITION_WIFI_SSID)
- every { mockNetworkManager.isWifiConnected() } returns true
- every { mockNetworkManager.readSsidOnce(any()) } answers {
+ every { mockNetworkMonitor.isWifiConnected() } returns true
+ every { mockNetworkMonitor.readSsidOnce(any()) } answers {
firstArg<(String) -> Unit>().invoke("HomeNet")
}
monitor.start()
- verify { mockNetworkManager.setWifiStateListener(any()) }
- verify { mockNetworkManager.readSsidOnce(any()) }
+ verify { mockNetworkMonitor.setWifiStateListener(any()) }
+ verify { mockNetworkMonitor.readSsidOnce(any()) }
verify { mockProfileManager.onWifiStateChanged(true, "HomeNet") }
}
@@ -184,15 +184,15 @@ class ConditionMonitorTest {
every { mockProfileManager.getNeededConditionTypes() } returns setOf(ProfileConstants.CONDITION_WIFI_SSID)
// start() stops first (clearing the listener with null), so keep the last registration.
var listener: (() -> Unit)? = null
- every { mockNetworkManager.setWifiStateListener(any()) } answers { listener = firstArg() }
- every { mockNetworkManager.isWifiConnected() } returns false
+ every { mockNetworkMonitor.setWifiStateListener(any()) } answers { listener = firstArg() }
+ every { mockNetworkMonitor.isWifiConnected() } returns false
monitor.start()
verify { mockProfileManager.onWifiStateChanged(false, "") }
assertNotNull(listener)
- every { mockNetworkManager.isWifiConnected() } returns true
- every { mockNetworkManager.readSsidOnce(any()) } answers {
+ every { mockNetworkMonitor.isWifiConnected() } returns true
+ every { mockNetworkMonitor.readSsidOnce(any()) } answers {
firstArg<(String) -> Unit>().invoke("HomeNet")
}
listener!!.invoke()
@@ -204,21 +204,21 @@ class ConditionMonitorTest {
fun `the any-wifi condition is pushed without touching the SSID`() {
mockBatteryStatus(BatteryManager.BATTERY_STATUS_DISCHARGING)
every { mockProfileManager.getNeededConditionTypes() } returns setOf(ProfileConstants.CONDITION_WIFI_ANY)
- every { mockNetworkManager.isWifiConnected() } returns true
+ every { mockNetworkMonitor.isWifiConnected() } returns true
monitor.start()
verify { mockProfileManager.onWifiStateChanged(true, "") }
- verify(exactly = 0) { mockNetworkManager.readSsidOnce(any()) }
+ verify(exactly = 0) { mockNetworkMonitor.readSsidOnce(any()) }
}
@Test
fun `Location coming back re-reads the network name`() {
mockBatteryStatus(BatteryManager.BATTERY_STATUS_DISCHARGING)
every { mockProfileManager.getNeededConditionTypes() } returns setOf(ProfileConstants.CONDITION_WIFI_SSID)
- every { mockNetworkManager.isWifiConnected() } returns true
+ every { mockNetworkMonitor.isWifiConnected() } returns true
var name = ""
- every { mockNetworkManager.readSsidOnce(any()) } answers { firstArg<(String) -> Unit>().invoke(name) }
+ every { mockNetworkMonitor.readSsidOnce(any()) } answers { firstArg<(String) -> Unit>().invoke(name) }
monitor.start()
verify { mockProfileManager.onWifiStateChanged(true, "") }
@@ -236,7 +236,7 @@ class ConditionMonitorTest {
monitor.start()
monitor.onLocationEnabled()
- verify(exactly = 0) { mockNetworkManager.readSsidOnce(any()) }
+ verify(exactly = 0) { mockNetworkMonitor.readSsidOnce(any()) }
verify(exactly = 0) { mockProfileManager.onWifiStateChanged(any(), any()) }
}
@@ -245,11 +245,11 @@ class ConditionMonitorTest {
fun `a probe result superseded by a newer network change is dropped`() {
mockBatteryStatus(BatteryManager.BATTERY_STATUS_DISCHARGING)
every { mockProfileManager.getNeededConditionTypes() } returns setOf(ProfileConstants.CONDITION_WIFI_SSID)
- every { mockNetworkManager.isWifiConnected() } returns true
+ every { mockNetworkMonitor.isWifiConnected() } returns true
var listener: (() -> Unit)? = null
- every { mockNetworkManager.setWifiStateListener(any()) } answers { listener = firstArg() }
+ every { mockNetworkMonitor.setWifiStateListener(any()) } answers { listener = firstArg() }
val pending = mutableListOf<(String) -> Unit>()
- every { mockNetworkManager.readSsidOnce(any()) } answers { pending.add(firstArg()) }
+ every { mockNetworkMonitor.readSsidOnce(any()) } answers { pending.add(firstArg()) }
monitor.start()
listener!!.invoke()
@@ -267,8 +267,8 @@ class ConditionMonitorTest {
monitor.start()
// stop() clears the listener first, so one call total and it is a clear, not a registration.
- verify(exactly = 1) { mockNetworkManager.setWifiStateListener(isNull()) }
- verify(exactly = 0) { mockNetworkManager.setWifiStateListener(isNull(inverse = true)) }
+ verify(exactly = 1) { mockNetworkMonitor.setWifiStateListener(isNull()) }
+ verify(exactly = 0) { mockNetworkMonitor.setWifiStateListener(isNull(inverse = true)) }
}
@Test
@@ -280,7 +280,7 @@ class ConditionMonitorTest {
monitor.stop()
// Once from start()'s stop-first and once from the explicit stop().
- verify(exactly = 2) { mockNetworkManager.setWifiStateListener(isNull()) }
+ verify(exactly = 2) { mockNetworkMonitor.setWifiStateListener(isNull()) }
}
// ========================================================================
@@ -553,7 +553,7 @@ class ConditionMonitorTest {
val spy = spyk(raw, recordPrivateCalls = true)
setField(spy, "context", mockContext)
- setField(spy, "networkManager", mockNetworkManager)
+ setField(spy, "networkMonitor", mockNetworkMonitor)
setField(spy, "profileManager", mockProfileManager)
setField(spy, "mainHandler", mockHandler)
setField(spy, "connectedBluetoothAddresses", mutableSetOf<String>())
diff --git a/apps/mobile/android/app/src/test/java/com/Colota/service/LocationForegroundServiceTest.kt b/apps/mobile/android/app/src/test/java/com/Colota/service/LocationForegroundServiceTest.kt
index f4ef2de6..cb8364fa 100644
--- a/apps/mobile/android/app/src/test/java/com/Colota/service/LocationForegroundServiceTest.kt
+++ b/apps/mobile/android/app/src/test/java/com/Colota/service/LocationForegroundServiceTest.kt
@@ -12,7 +12,8 @@ import com.Colota.location.LocationAccuracy
import com.Colota.location.LocationProvider
import com.Colota.location.LocationUpdateCallback
import com.Colota.sync.PayloadBuilder
-import com.Colota.sync.NetworkManager
+import com.Colota.sync.http.NetworkManager
+import com.Colota.network.NetworkMonitor
import com.Colota.sync.SyncManager
import com.Colota.util.AppLogger
import com.Colota.util.DeviceInfoHelper
@@ -50,6 +51,7 @@ class LocationForegroundServiceTest {
private lateinit var batteryMonitor: BatteryMonitor
private lateinit var secureStorage: SecureStorageHelper
private lateinit var networkManager: NetworkManager
+ private lateinit var networkMonitor: NetworkMonitor
private lateinit var androidNotificationManager: NotificationManager
private lateinit var testDispatcher: TestDispatcher
@@ -70,6 +72,7 @@ class LocationForegroundServiceTest {
batteryMonitor = mockk(relaxed = true)
secureStorage = mockk(relaxed = true)
networkManager = mockk(relaxed = true)
+ networkMonitor = mockk(relaxed = true)
androidNotificationManager = mockk(relaxed = true)
testDispatcher = UnconfinedTestDispatcher()
@@ -160,6 +163,7 @@ class LocationForegroundServiceTest {
setField("batteryMonitor", batteryMonitor)
setField("secureStorage", secureStorage)
setField("networkManager", networkManager)
+ setField("networkMonitor", networkMonitor)
setField("notificationManager", androidNotificationManager)
setField("serviceScope", defaultServiceScope)
setField("config", ServiceConfig(
@@ -820,15 +824,15 @@ class LocationForegroundServiceTest {
// Reading the SSID is attributed as location access, so it must follow the condition needing it.
setField("config", ServiceConfig(endpoint = "https://example.com", syncCondition = "wifi_ssid"))
invokePushConfigToSyncManager()
- verify(exactly = 1) { networkManager.setSsidTracking(true) }
+ verify(exactly = 1) { networkMonitor.setSsidTracking(true) }
setField("config", ServiceConfig(endpoint = "https://example.com", syncCondition = "any"))
invokePushConfigToSyncManager()
- verify(exactly = 1) { networkManager.setSsidTracking(false) }
+ verify(exactly = 1) { networkMonitor.setSsidTracking(false) }
setField("config", ServiceConfig(endpoint = "https://example.com", syncCondition = "wifi_ssid"))
invokePushConfigToSyncManager()
- verify(exactly = 2) { networkManager.setSsidTracking(true) }
+ verify(exactly = 2) { networkMonitor.setSsidTracking(true) }
}
/** Holding the flagged callback would keep the location indicator lit. */
@@ -839,7 +843,7 @@ class LocationForegroundServiceTest {
invokePushConfigToSyncManager()
- verify(exactly = 0) { networkManager.setSsidTracking(true) }
+ verify(exactly = 0) { networkMonitor.setSsidTracking(true) }
}
@Test
diff --git a/apps/mobile/android/app/src/test/java/com/Colota/sync/NetworkManagerTest.kt b/apps/mobile/android/app/src/test/java/com/Colota/sync/NetworkManagerTest.kt
deleted file mode 100644
index 5d983770..00000000
--- a/apps/mobile/android/app/src/test/java/com/Colota/sync/NetworkManagerTest.kt
+++ /dev/null
@@ -1,589 +0,0 @@
-package com.Colota.sync
-
-import android.content.Context
-import android.net.ConnectivityManager
-import android.net.NetworkCapabilities
-import android.net.NetworkRequest
-import android.net.wifi.WifiInfo
-import android.net.wifi.WifiManager
-import org.json.JSONObject
-import org.junit.Assert.*
-import org.junit.Test
-import com.Colota.util.AppLogger
-import io.mockk.*
-import org.junit.After
-import org.junit.Before
-
-/**
- * Tests for NetworkManager's pure-logic methods, plus callback registration against a mocked
- * ConnectivityManager. Network I/O still needs instrumented tests.
- */
-class NetworkManagerTest {
-
- @Before
- fun setUp() {
- mockkObject(AppLogger)
- every { AppLogger.d(any(), any()) } just Runs
- every { AppLogger.i(any(), any()) } just Runs
- every { AppLogger.w(any(), any()) } just Runs
- every { AppLogger.e(any(), any(), any()) } just Runs
-
- // With returnDefaultValues the mocked Builder chain returns null and every NetworkManager
- // construction would NPE. The real request is irrelevant to these tests.
- mockkConstructor(NetworkRequest.Builder::class)
- every { anyConstructed<NetworkRequest.Builder>().addTransportType(any()) } returns mockk(relaxed = true)
- every { anyConstructed<NetworkRequest.Builder>().build() } returns mockk(relaxed = true)
- }
-
- @After
- fun tearDown() {
- unmockkConstructor(NetworkRequest.Builder::class)
- unmockkObject(AppLogger)
- }
-
- // --- network callback registration ---
-
- private fun newManagerWith(cm: ConnectivityManager): NetworkManager {
- val ctx = mockk<Context>(relaxed = true)
- every { ctx.getSystemService(Context.CONNECTIVITY_SERVICE) } returns cm
- every { ctx.getSystemService(Context.WIFI_SERVICE) } returns null
- return NetworkManager(ctx)
- }
-
- @Test
- fun `setSsidTracking swaps the callback in both directions`() {
- val cm = mockk<ConnectivityManager>(relaxed = true)
- val manager = newManagerWith(cm)
-
- verify(exactly = 1) { cm.registerDefaultNetworkCallback(any<ConnectivityManager.NetworkCallback>()) }
- verify(exactly = 0) { cm.unregisterNetworkCallback(any<ConnectivityManager.NetworkCallback>()) }
-
- manager.setSsidTracking(true)
- verify(exactly = 1) { cm.unregisterNetworkCallback(any<ConnectivityManager.NetworkCallback>()) }
- verify(exactly = 2) { cm.registerDefaultNetworkCallback(any<ConnectivityManager.NetworkCallback>()) }
-
- manager.setSsidTracking(false)
- verify(exactly = 2) { cm.unregisterNetworkCallback(any<ConnectivityManager.NetworkCallback>()) }
- verify(exactly = 3) { cm.registerDefaultNetworkCallback(any<ConnectivityManager.NetworkCallback>()) }
- }
-
- @Test
- fun `setSsidTracking with an unchanged value does not churn the callback`() {
- val cm = mockk<ConnectivityManager>(relaxed = true)
- val manager = newManagerWith(cm)
-
- manager.setSsidTracking(false)
- manager.setSsidTracking(false)
- verify(exactly = 1) { cm.registerDefaultNetworkCallback(any<ConnectivityManager.NetworkCallback>()) }
-
- manager.setSsidTracking(true)
- manager.setSsidTracking(true)
- verify(exactly = 2) { cm.registerDefaultNetworkCallback(any<ConnectivityManager.NetworkCallback>()) }
- }
-
- @Test
- fun `the SSID is only read while tracking is on`() {
- val cm = mockk<ConnectivityManager>(relaxed = true)
- val slot = slot<ConnectivityManager.NetworkCallback>()
- every { cm.registerDefaultNetworkCallback(capture(slot)) } just Runs
- val info = mockk<WifiInfo>(relaxed = true)
- every { info.ssid } returns "\"HomeNet\""
- val wifi = mockk<WifiManager>(relaxed = true)
- every { wifi.connectionInfo } returns info
- val ctx = mockk<Context>(relaxed = true)
- every { ctx.getSystemService(Context.CONNECTIVITY_SERVICE) } returns cm
- every { ctx.getSystemService(Context.WIFI_SERVICE) } returns wifi
- val manager = NetworkManager(ctx)
-
- slot.captured.onCapabilitiesChanged(mockk(relaxed = true), mockk(relaxed = true))
- assertFalse(manager.isConnectedToSsid("HomeNet"))
- assertEquals("", manager.currentSsid)
-
- manager.setSsidTracking(true)
- slot.captured.onCapabilitiesChanged(mockk(relaxed = true), mockk(relaxed = true))
- assertTrue(manager.isConnectedToSsid("HomeNet"))
- assertEquals("HomeNet", manager.currentSsid)
- }
-
- @Test
- fun `the plain callback still tracks VPN state`() {
- val cm = mockk<ConnectivityManager>(relaxed = true)
- val slot = slot<ConnectivityManager.NetworkCallback>()
- every { cm.registerDefaultNetworkCallback(capture(slot)) } just Runs
- val manager = newManagerWith(cm)
-
- val caps = mockk<NetworkCapabilities>(relaxed = true)
- every { caps.hasTransport(NetworkCapabilities.TRANSPORT_VPN) } returns true
- slot.captured.onCapabilitiesChanged(mockk(relaxed = true), caps)
-
- assertTrue(manager.isVpnConnected())
- }
-
- @Test
- fun `the wifi transport callback notifies the listener on availability and loss`() {
- val cm = mockk<ConnectivityManager>(relaxed = true)
- val slot = slot<ConnectivityManager.NetworkCallback>()
- every { cm.registerNetworkCallback(any<NetworkRequest>(), capture(slot)) } just Runs
- val manager = newManagerWith(cm)
- var changes = 0
- manager.setWifiStateListener { changes++ }
-
- slot.captured.onAvailable(mockk(relaxed = true))
-
- assertTrue(manager.isWifiConnected())
- assertEquals(1, changes)
-
- slot.captured.onLost(mockk(relaxed = true))
-
- assertFalse(manager.isWifiConnected())
- assertEquals(2, changes)
- }
-
- /** An automatic switch connects the new network before the old one goes. */
- @Test
- fun `a switch between two Wi-Fi networks still notifies`() {
- val cm = mockk<ConnectivityManager>(relaxed = true)
- val slot = slot<ConnectivityManager.NetworkCallback>()
- every { cm.registerNetworkCallback(any<NetworkRequest>(), capture(slot)) } just Runs
- val manager = newManagerWith(cm)
- var changes = 0
- manager.setWifiStateListener { changes++ }
-
- slot.captured.onAvailable(mockk(relaxed = true))
- slot.captured.onAvailable(mockk(relaxed = true))
- slot.captured.onLost(mockk(relaxed = true))
-
- assertTrue(manager.isWifiConnected())
- assertEquals(3, changes)
- }
-
- @Test
- fun `identical capability deliveries do not notify twice`() {
- // Bandwidth and validation updates arrive without any transport or SSID change; each one
- // used to run a full profile evaluation.
- val cm = mockk<ConnectivityManager>(relaxed = true)
- val slot = slot<ConnectivityManager.NetworkCallback>()
- every { cm.registerDefaultNetworkCallback(capture(slot)) } just Runs
- val manager = newManagerWith(cm)
- var changes = 0
- manager.setWifiStateListener { changes++ }
-
- val caps = mockk<NetworkCapabilities>(relaxed = true)
- every { caps.hasTransport(NetworkCapabilities.TRANSPORT_VPN) } returns true
- slot.captured.onCapabilitiesChanged(mockk(relaxed = true), caps)
- slot.captured.onCapabilitiesChanged(mockk(relaxed = true), caps)
- slot.captured.onCapabilitiesChanged(mockk(relaxed = true), caps)
-
- assertEquals(1, changes)
- }
-
- @Test
- fun `a VPN default network does not hide an available Wi-Fi network`() {
- // The VPN network reports the underlying transports on Android 14+, but the app's Wi-Fi
- // transport callback sees the Wi-Fi network regardless of which network is the default.
- val cm = mockk<ConnectivityManager>(relaxed = true)
- val defaultSlot = slot<ConnectivityManager.NetworkCallback>()
- every { cm.registerDefaultNetworkCallback(capture(defaultSlot)) } just Runs
- val wifiSlot = slot<ConnectivityManager.NetworkCallback>()
- every { cm.registerNetworkCallback(any<NetworkRequest>(), capture(wifiSlot)) } just Runs
- val manager = newManagerWith(cm)
- var changes = 0
- manager.setWifiStateListener { changes++ }
-
- wifiSlot.captured.onAvailable(mockk(relaxed = true))
-
- assertTrue(manager.isWifiConnected())
- assertEquals(1, changes)
-
- val vpnCaps = mockk<NetworkCapabilities>(relaxed = true)
- every { vpnCaps.hasTransport(NetworkCapabilities.TRANSPORT_VPN) } returns true
- every { vpnCaps.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) } returns true
- defaultSlot.captured.onCapabilitiesChanged(mockk(relaxed = true), vpnCaps)
-
- assertTrue(manager.isVpnConnected())
- assertTrue(manager.isWifiConnected())
- assertEquals(2, changes)
- }
-
- @Test
- fun `the unknown SSID placeholder reads as no name`() {
- // Android returns "<unknown ssid>" without location permission or with Location off; that
- // must not be saved as a network name or matched against one.
- val cm = mockk<ConnectivityManager>(relaxed = true)
- val slot = slot<ConnectivityManager.NetworkCallback>()
- every { cm.registerDefaultNetworkCallback(capture(slot)) } just Runs
- val info = mockk<WifiInfo>(relaxed = true)
- every { info.ssid } returns "\"<unknown ssid>\""
- val wifi = mockk<WifiManager>(relaxed = true)
- every { wifi.connectionInfo } returns info
- val ctx = mockk<Context>(relaxed = true)
- every { ctx.getSystemService(Context.CONNECTIVITY_SERVICE) } returns cm
- every { ctx.getSystemService(Context.WIFI_SERVICE) } returns wifi
- val manager = NetworkManager(ctx)
-
- manager.setSsidTracking(true)
- slot.captured.onCapabilitiesChanged(mockk(relaxed = true), mockk(relaxed = true))
-
- assertEquals("", manager.currentSsid)
- assertFalse(manager.isConnectedToSsid("<unknown ssid>"))
- }
-
- @Test
- fun `clearing the listener stops notifications`() {
- val cm = mockk<ConnectivityManager>(relaxed = true)
- val slot = slot<ConnectivityManager.NetworkCallback>()
- every { cm.registerNetworkCallback(any<NetworkRequest>(), capture(slot)) } just Runs
- val manager = newManagerWith(cm)
- var changes = 0
- manager.setWifiStateListener { changes++ }
- manager.setWifiStateListener(null)
-
- slot.captured.onAvailable(mockk(relaxed = true))
-
- assertEquals(0, changes)
- }
-
- // --- buildQueryString ---
-
- @Test
- fun `buildQueryString builds correct query for simple payload`() {
- val payload = JSONObject().apply {
- put("lat", 52.52)
- put("lon", 13.405)
- put("tst", 1700000000)
- }
-
- val result = invokeBuildQueryString(payload)
-
- // Verify each key=value pair is present (order may vary)
- assertTrue(result.contains("lat=52.52"))
- assertTrue(result.contains("lon=13.405"))
- assertTrue(result.contains("tst=1700000000"))
- assertEquals(2, result.count { it == '&' }) // 3 params = 2 ampersands
- }
-
- @Test
- fun `buildQueryString renders whole-number doubles as integers`() {
- // JS numbers cross the RN bridge as doubles, so a Test Connection unix
- // timestamp serializes as 1.780257432E9. Traccar's OsmAnd endpoint rejects
- // a scientific-notation timestamp and drops the connection without
- // replying (okhttp surfaces this as "unexpected end of stream").
- val payload = JSONObject().apply {
- put("tst", 1780257432.0)
- put("acc", 5.0)
- put("lat", 48.0685105)
- }
-
- val result = invokeBuildQueryString(payload)
-
- assertTrue(result.contains("tst=1780257432"))
- assertFalse("scientific notation breaks Traccar's parser", result.contains("1.780257432E9"))
- assertFalse("whole-number doubles must drop the .0", result.contains("acc=5.0"))
- assertTrue("fractional values keep their decimals", result.contains("lat=48.0685105"))
- }
-
- @Test
- fun `buildQueryString URL-encodes special characters`() {
- val payload = JSONObject().put("name", "hello world&more")
-
- val result = invokeBuildQueryString(payload)
-
- assertTrue(result.contains("name=hello+world%26more") || result.contains("name=hello%20world%26more"))
- }
-
- @Test
- fun `buildQueryString returns empty string for empty payload`() {
- val payload = JSONObject()
- val result = invokeBuildQueryString(payload)
- assertEquals("", result)
- }
-
- // --- resolveUrlVariables ---
-
- @Test
- fun `resolveUrlVariables substitutes DATE and TIMESTAMP`() {
- val payload = JSONObject().apply { put("tst", 1775308740L) }
- val manager = createNetworkManagerViaReflection()
- val result = manager.resolveUrlVariables("https://server.com/%DATE/%TIMESTAMP.json", payload)
- assertEquals("https://server.com/2026-04-04/1775308740.json", result)
- }
-
- @Test
- fun `resolveUrlVariables substitutes YEAR MONTH DAY`() {
- val payload = JSONObject().apply { put("tst", 1775308740L) }
- val manager = createNetworkManagerViaReflection()
- val result = manager.resolveUrlVariables("https://s.com/%YEAR/%MONTH/%DAY/data", payload)
- assertEquals("https://s.com/2026/04/04/data", result)
- }
-
- @Test
- fun `resolveUrlVariables returns endpoint unchanged when no percent`() {
- val payload = JSONObject().apply { put("tst", 1775308740L) }
- val manager = createNetworkManagerViaReflection()
- val result = manager.resolveUrlVariables("https://server.com/api", payload)
- assertEquals("https://server.com/api", result)
- }
-
- // --- readErrorBody ---
-
- /**
- * A rate-limited flush logs one error body per rejected point. Field logs showed ~110 nginx
- * 429 pages in two seconds, 7 lines each, crowding real events out of the rolling log file.
- */
- @Test
- fun `an html error page is logged as a single bounded line`() {
- val nginx429 = """
- <html>
- <head><title>429 Too Many Requests</title></head>
- <body>
- <center><h1>429 Too Many Requests</h1></center>
- <hr><center>nginx</center>
- </body>
- </html>
- """.trimIndent()
-
- val logged = invokeReadErrorBody(nginx429)
-
- assertFalse("must not span lines", logged.contains("\n"))
- assertTrue("must stay bounded", logged.length <= 200)
- assertTrue("must keep the useful part", logged.contains("429 Too Many Requests"))
- }
-
- @Test
- fun `a body longer than the cap is truncated`() {
- val logged = invokeReadErrorBody("x".repeat(5000))
-
- assertEquals(200, logged.length)
- }
-
- @Test
- fun `a missing body reports that rather than throwing`() {
- assertEquals("No error body", invokeReadErrorBody(null))
- }
-
- // --- Reflection helpers to access private methods ---
-
- // --- testEndpoint ---
-
- @Test
- fun `testEndpoint invalid URL message goes through the URL mask`() {
- // Plain JUnit has no android.net.Uri, so the mask itself is covered in AppLoggerTest
- every { AppLogger.maskSensitiveUrlValues(any()) } answers { "masked(${firstArg<String>()})" }
-
- val result = kotlinx.coroutines.runBlocking {
- createNetworkManagerViaReflection().testEndpoint(JSONObject(), "htps://ha.example.com/api/webhook/abc")
- }
-
- assertFalse(result.ok)
- assertEquals("Invalid URL: masked(htps://ha.example.com/api/webhook/abc)", result.errorMessage)
- }
-
- // --- verdicts ---
-
- @Test
- fun `a status maps to the verdict the sync pass acts on`() {
- assertEquals(BatchResult.Success, verdictFor(204, null))
- assertEquals(BatchResult.RateLimited(30), verdictFor(429, 30))
- assertEquals(BatchResult.ClientError(400), verdictFor(400, null))
- assertEquals(BatchResult.ServerError(503), verdictFor(503, null))
- }
-
- @Test
- fun `a send that never got a response is a network error`() {
- val result = kotlinx.coroutines.runBlocking { createNetworkManagerViaReflection().sendToEndpoint(JSONObject(), "") }
-
- assertEquals(BatchResult.NetworkError, result)
- }
-
- @Test
- fun `Retry-After is read as seconds or as an HTTP date`() {
- val now = java.time.ZonedDateTime.parse(
- "Sat, 19 Sep 2026 12:00:00 GMT", java.time.format.DateTimeFormatter.RFC_1123_DATE_TIME
- ).toInstant().toEpochMilli()
-
- assertEquals(120L, parseRetryAfter("120", now))
- assertEquals(90L, parseRetryAfter("Sat, 19 Sep 2026 12:01:30 GMT", now))
- assertEquals("a date in the past means now", 0L, parseRetryAfter("Sat, 19 Sep 2026 11:00:00 GMT", now))
- assertNull(parseRetryAfter("soon", now))
- assertNull(parseRetryAfter(null, now))
- }
-
- @Test
- fun `a rate-limited batch carries the server's Retry-After`() {
- val connection = io.mockk.mockk<java.net.HttpURLConnection>(relaxed = true)
- io.mockk.every { connection.responseCode } returns 429
- io.mockk.every { connection.getHeaderField("Retry-After") } returns "30"
- val method = NetworkManager::class.java.getDeclaredMethod(
- "readBatchResponse", java.net.HttpURLConnection::class.java, Int::class.javaPrimitiveType
- )
- method.isAccessible = true
-
- assertEquals(BatchResult.RateLimited(30), method.invoke(createNetworkManagerViaReflection(), connection, 50))
- }
-
- // --- releasing the connection ---
-
- private fun readBatchResponse(connection: java.net.HttpURLConnection): Any? {
- val method = NetworkManager::class.java.getDeclaredMethod(
- "readBatchResponse", java.net.HttpURLConnection::class.java, Int::class.javaPrimitiveType
- )
- method.isAccessible = true
- return method.invoke(createNetworkManagerViaReflection(), connection, 50)
- }
-
- // Android keeps a connection whose reply was never closed pooled for minutes, TLS buffers included.
- @Test
- fun `an accepted batch closes the reply it does not read`() {
- val reply = mockk<java.io.InputStream>(relaxed = true)
- val connection = mockk<java.net.HttpURLConnection>(relaxed = true)
- every { connection.responseCode } returns 200
- every { connection.errorStream } returns null
- every { connection.inputStream } returns reply
-
- assertEquals(BatchResult.Success, readBatchResponse(connection))
-
- verify(exactly = 1) { reply.close() }
- }
-
- @Test
- fun `a rate-limited batch closes the error page it does not read`() {
- val page = mockk<java.io.InputStream>(relaxed = true)
- val connection = mockk<java.net.HttpURLConnection>(relaxed = true)
- every { connection.responseCode } returns 429
- every { connection.errorStream } returns page
-
- readBatchResponse(connection)
-
- verify(exactly = 1) { page.close() }
- }
-
- @Test
- fun `a reply that fails to open does not turn an accepted batch into a failure`() {
- val connection = mockk<java.net.HttpURLConnection>(relaxed = true)
- every { connection.responseCode } returns 204
- every { connection.errorStream } returns null
- every { connection.inputStream } throws java.io.IOException("stream closed")
-
- assertEquals(BatchResult.Success, readBatchResponse(connection))
- }
-
- private fun readResponse(connection: java.net.HttpURLConnection): TestEndpointResult {
- val method = NetworkManager::class.java.getDeclaredMethod("readResponse", java.net.HttpURLConnection::class.java)
- method.isAccessible = true
- return method.invoke(createNetworkManagerViaReflection(), connection) as TestEndpointResult
- }
-
- @Test
- fun `an accepted upload closes the reply it does not read`() {
- val reply = mockk<java.io.InputStream>(relaxed = true)
- val connection = mockk<java.net.HttpURLConnection>(relaxed = true)
- every { connection.responseCode } returns 200
- every { connection.errorStream } returns null
- every { connection.inputStream } returns reply
-
- assertTrue(readResponse(connection).ok)
-
- verify(exactly = 1) { reply.close() }
- }
-
- // Android offers no error stream below 400, so a redirect it does not follow has only the plain one.
- @Test
- fun `a redirect that is not followed is a failure whose reply is still closed`() {
- val reply = mockk<java.io.InputStream>(relaxed = true)
- val connection = mockk<java.net.HttpURLConnection>(relaxed = true)
- every { connection.responseCode } returns 307
- every { connection.errorStream } returns null
- every { connection.inputStream } returns reply
-
- val result = readResponse(connection)
-
- assertFalse(result.ok)
- assertEquals(307, result.httpStatus)
- verify(exactly = 1) { reply.close() }
- }
-
- @Test
- fun `a custom Connection header cannot switch connection reuse back on`() {
- val method = NetworkManager::class.java.getDeclaredMethod(
- "buildConnection", java.net.URL::class.java, Boolean::class.javaPrimitiveType, Map::class.java
- )
- method.isAccessible = true
-
- for (isGet in listOf(false, true)) {
- val connection = method.invoke(
- createNetworkManagerViaReflection(), java.net.URL("http://127.0.0.1:9/"), isGet, mapOf("Connection" to "keep-alive")
- ) as java.net.HttpURLConnection
-
- assertEquals("close", connection.getRequestProperty("Connection"))
- }
- }
-
- // Without the header a closed reply is pooled for reuse, and a stale pooled connection fails a streamed POST.
- @Test
- fun `an upload asks the server to close the connection and still counts as sent`() {
- val server = java.net.ServerSocket(0, 1, java.net.InetAddress.getByName("127.0.0.1"))
- val headers = java.util.concurrent.CompletableFuture<List<String>>()
- val serving = Thread {
- try {
- server.accept().use { socket ->
- val input = socket.getInputStream().bufferedReader(Charsets.ISO_8859_1)
- val lines = generateSequence { input.readLine() }.takeWhile { it.isNotEmpty() }.toList()
- val length = lines.first { it.startsWith("Content-Length", ignoreCase = true) }.substringAfter(":").trim().toInt()
- repeat(length) { input.read() }
- headers.complete(lines)
- val body = """{"ok":true}"""
- socket.getOutputStream().write(
- "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: ${body.length}\r\n\r\n$body".toByteArray()
- )
- }
- } catch (e: Exception) {
- headers.completeExceptionally(e)
- }
- }.apply { start() }
- try {
- val caps = mockk<NetworkCapabilities>(relaxed = true)
- every { caps.hasCapability(any()) } returns true
- val cm = mockk<ConnectivityManager>(relaxed = true)
- every { cm.getNetworkCapabilities(any()) } returns caps
-
- val result = kotlinx.coroutines.runBlocking {
- newManagerWith(cm).sendToEndpoint(JSONObject().put("lat", 1.0), "http://127.0.0.1:${server.localPort}/")
- }
-
- assertEquals(BatchResult.Success, result)
- val sent = headers.get(5, java.util.concurrent.TimeUnit.SECONDS)
- assertTrue("request headers were $sent", sent.any { it.equals("Connection: close", ignoreCase = true) })
- } finally {
- serving.join(5000)
- server.close()
- }
- }
-
- private fun invokeReadErrorBody(body: String?): String {
- val connection = io.mockk.mockk<java.net.HttpURLConnection>(relaxed = true)
- io.mockk.every { connection.errorStream } returns body?.byteInputStream()
- val method = NetworkManager::class.java
- .getDeclaredMethod("readErrorBody", java.net.HttpURLConnection::class.java)
- method.isAccessible = true
- return method.invoke(createNetworkManagerViaReflection(), connection) as String
- }
-
-
- private fun invokeBuildQueryString(payload: JSONObject): String {
- val method = NetworkManager::class.java.getDeclaredMethod("buildQueryString", JSONObject::class.java)
- method.isAccessible = true
- val manager = createNetworkManagerViaReflection()
- return method.invoke(manager, payload) as String
- }
-
- private fun createNetworkManagerViaReflection(): NetworkManager {
- val constructor = NetworkManager::class.java.getDeclaredConstructors().first()
- constructor.isAccessible = true
- val context = io.mockk.mockk<android.content.Context>(relaxed = true)
- val connectivityManager = io.mockk.mockk<android.net.ConnectivityManager>(relaxed = true)
- io.mockk.every {
- context.getSystemService(android.content.Context.CONNECTIVITY_SERVICE)
- } returns connectivityManager
- return constructor.newInstance(context) as NetworkManager
- }
-}
diff --git a/apps/mobile/android/app/src/test/java/com/Colota/sync/PayloadBuilderTest.kt b/apps/mobile/android/app/src/test/java/com/Colota/sync/PayloadBuilderTest.kt
index be0596da..7d0a8de3 100644
--- a/apps/mobile/android/app/src/test/java/com/Colota/sync/PayloadBuilderTest.kt
+++ b/apps/mobile/android/app/src/test/java/com/Colota/sync/PayloadBuilderTest.kt
@@ -856,4 +856,59 @@ class PayloadBuilderTest {
every { hasBearing() } returns hasBearing
every { [email protected] } returns bearing
}
+
+ // --- buildQueryString ---
+
+ @Test
+ fun `buildQueryString builds correct query for simple payload`() {
+ val payload = JSONObject().apply {
+ put("lat", 52.52)
+ put("lon", 13.405)
+ put("tst", 1700000000)
+ }
+
+ val result = PayloadBuilder.buildQueryString(payload)
+
+ // Verify each key=value pair is present (order may vary)
+ assertTrue(result.contains("lat=52.52"))
+ assertTrue(result.contains("lon=13.405"))
+ assertTrue(result.contains("tst=1700000000"))
+ assertEquals(2, result.count { it == '&' }) // 3 params = 2 ampersands
+ }
+
+ @Test
+ fun `buildQueryString renders whole-number doubles as integers`() {
+ // JS numbers cross the RN bridge as doubles, so a Test Connection unix
+ // timestamp serializes as 1.780257432E9. Traccar's OsmAnd endpoint rejects
+ // a scientific-notation timestamp and drops the connection without
+ // replying (okhttp surfaces this as "unexpected end of stream").
+ val payload = JSONObject().apply {
+ put("tst", 1780257432.0)
+ put("acc", 5.0)
+ put("lat", 48.0685105)
+ }
+
+ val result = PayloadBuilder.buildQueryString(payload)
+
+ assertTrue(result.contains("tst=1780257432"))
+ assertFalse("scientific notation breaks Traccar's parser", result.contains("1.780257432E9"))
+ assertFalse("whole-number doubles must drop the .0", result.contains("acc=5.0"))
+ assertTrue("fractional values keep their decimals", result.contains("lat=48.0685105"))
+ }
+
+ @Test
+ fun `buildQueryString URL-encodes special characters`() {
+ val payload = JSONObject().put("name", "hello world&more")
+
+ val result = PayloadBuilder.buildQueryString(payload)
+
+ assertTrue(result.contains("name=hello+world%26more") || result.contains("name=hello%20world%26more"))
+ }
+
+ @Test
+ fun `buildQueryString returns empty string for empty payload`() {
+ val payload = JSONObject()
+ val result = PayloadBuilder.buildQueryString(payload)
+ assertEquals("", result)
+ }
}
diff --git a/apps/mobile/android/app/src/test/java/com/Colota/sync/SyncManagerTest.kt b/apps/mobile/android/app/src/test/java/com/Colota/sync/SyncManagerTest.kt
index bff1e9e2..5c545fac 100644
--- a/apps/mobile/android/app/src/test/java/com/Colota/sync/SyncManagerTest.kt
+++ b/apps/mobile/android/app/src/test/java/com/Colota/sync/SyncManagerTest.kt
@@ -14,12 +14,16 @@ import org.junit.Assert.*
import org.junit.Before
import org.junit.Test
import kotlin.coroutines.Continuation
+import com.Colota.sync.http.NetworkManager
+import com.Colota.sync.http.BatchResult
+import com.Colota.network.NetworkMonitor
@OptIn(ExperimentalCoroutinesApi::class)
class SyncManagerTest {
private lateinit var dbHelper: DatabaseHelper
private lateinit var networkManager: NetworkManager
+ private lateinit var networkMonitor: NetworkMonitor
private lateinit var scope: TestScope
private lateinit var syncManager: SyncManager
@@ -27,9 +31,10 @@ class SyncManagerTest {
fun setUp() {
dbHelper = mockk(relaxed = true)
networkManager = mockk(relaxed = true)
+ networkMonitor = mockk(relaxed = true)
scope = TestScope(UnconfinedTestDispatcher())
SyncState.reset()
- syncManager = SyncManager(dbHelper, networkManager, scope)
+ syncManager = SyncManager(dbHelper, networkManager, networkMonitor, scope)
coEvery { networkManager.sendToEndpoint(any(), any(), any(), any(), any()) } returns BatchResult.NetworkError
mockkObject(AppLogger)
@@ -100,7 +105,7 @@ class SyncManagerTest {
authHeaders = emptyMap()
)
- coEvery { networkManager.isNetworkAvailable() } returns true
+ coEvery { networkMonitor.isNetworkAvailable() } returns true
coEvery { networkManager.sendToEndpoint(any(), any(), any(), any()) } returns BatchResult.Success
val payload = JSONObject().put("lat", 52.0)
@@ -124,7 +129,7 @@ class SyncManagerTest {
authHeaders = emptyMap()
)
- coEvery { networkManager.isNetworkAvailable() } returns true
+ coEvery { networkMonitor.isNetworkAvailable() } returns true
coEvery { networkManager.sendToEndpoint(any(), any(), any(), any()) } returns BatchResult.ServerError(500)
val payload = JSONObject().put("lat", 52.0)
@@ -146,7 +151,7 @@ class SyncManagerTest {
authHeaders = emptyMap()
)
- coEvery { networkManager.isNetworkAvailable() } returns false
+ coEvery { networkMonitor.isNetworkAvailable() } returns false
val payload = JSONObject().put("lat", 52.0)
syncManager.queueAndSend(1L, payload)
@@ -169,8 +174,8 @@ class SyncManagerTest {
authHeaders = emptyMap()
)
- coEvery { networkManager.isNetworkAvailable() } returns true
- every { networkManager.isUnmeteredConnection() } returns false
+ coEvery { networkMonitor.isNetworkAvailable() } returns true
+ every { networkMonitor.isUnmeteredConnection() } returns false
val payload = JSONObject().put("lat", 52.0)
syncManager.queueAndSend(1L, payload)
@@ -190,8 +195,8 @@ class SyncManagerTest {
authHeaders = emptyMap()
)
- coEvery { networkManager.isNetworkAvailable() } returns true
- every { networkManager.isUnmeteredConnection() } returns true
+ coEvery { networkMonitor.isNetworkAvailable() } returns true
+ every { networkMonitor.isUnmeteredConnection() } returns true
coEvery { networkManager.sendToEndpoint(any(), any(), any(), any()) } returns BatchResult.Success
val payload = JSONObject().put("lat", 52.0)
@@ -214,8 +219,8 @@ class SyncManagerTest {
authHeaders = emptyMap()
)
- coEvery { networkManager.isNetworkAvailable() } returns true
- every { networkManager.isConnectedToSsid("HomeNetwork") } returns false
+ coEvery { networkMonitor.isNetworkAvailable() } returns true
+ every { networkMonitor.isConnectedToSsid("HomeNetwork") } returns false
val payload = JSONObject().put("lat", 52.0)
syncManager.queueAndSend(1L, payload)
@@ -235,8 +240,8 @@ class SyncManagerTest {
authHeaders = emptyMap()
)
- coEvery { networkManager.isNetworkAvailable() } returns true
- every { networkManager.isConnectedToSsid("HomeNetwork") } returns true
+ coEvery { networkMonitor.isNetworkAvailable() } returns true
+ every { networkMonitor.isConnectedToSsid("HomeNetwork") } returns true
coEvery { networkManager.sendToEndpoint(any(), any(), any(), any()) } returns BatchResult.Success
val payload = JSONObject().put("lat", 52.0)
@@ -259,8 +264,8 @@ class SyncManagerTest {
authHeaders = emptyMap()
)
- coEvery { networkManager.isNetworkAvailable() } returns true
- every { networkManager.isVpnConnected() } returns false
+ coEvery { networkMonitor.isNetworkAvailable() } returns true
+ every { networkMonitor.isVpnConnected() } returns false
val payload = JSONObject().put("lat", 52.0)
syncManager.queueAndSend(1L, payload)
@@ -280,8 +285,8 @@ class SyncManagerTest {
authHeaders = emptyMap()
)
- coEvery { networkManager.isNetworkAvailable() } returns true
- every { networkManager.isVpnConnected() } returns true
+ coEvery { networkMonitor.isNetworkAvailable() } returns true
+ every { networkMonitor.isVpnConnected() } returns true
coEvery { networkManager.sendToEndpoint(any(), any(), any(), any()) } returns BatchResult.Success
val payload = JSONObject().put("lat", 52.0)
@@ -304,7 +309,7 @@ class SyncManagerTest {
authHeaders = emptyMap()
)
- coEvery { networkManager.isNetworkAvailable() } returns true
+ coEvery { networkMonitor.isNetworkAvailable() } returns true
val payload = JSONObject().put("lat", 52.0)
syncManager.queueAndSend(1L, payload)
@@ -328,7 +333,7 @@ class SyncManagerTest {
authHeaders = emptyMap()
)
- coEvery { networkManager.isNetworkAvailable() } returns true
+ coEvery { networkMonitor.isNetworkAvailable() } returns true
coEvery { networkManager.sendToEndpoint(any(), any(), any(), any()) } returns BatchResult.Success
val payload = JSONObject().put("lat", 52.0)
@@ -351,8 +356,8 @@ class SyncManagerTest {
authHeaders = emptyMap()
)
- coEvery { networkManager.isNetworkAvailable() } returns true
- every { networkManager.isConnectedToSsid("HomeNetwork") } returns false
+ coEvery { networkMonitor.isNetworkAvailable() } returns true
+ every { networkMonitor.isConnectedToSsid("HomeNetwork") } returns false
val payload = JSONObject().put("lat", 52.0)
syncManager.queueAndSend(1L, payload, bypassInterval = true)
@@ -375,7 +380,7 @@ class SyncManagerTest {
authHeaders = emptyMap()
)
- coEvery { networkManager.isNetworkAvailable() } returns true
+ coEvery { networkMonitor.isNetworkAvailable() } returns true
coEvery { networkManager.sendToEndpoint(any(), any(), any(), any()) } returns BatchResult.ClientError(400)
val payload = JSONObject().put("lat", 52.0)
@@ -401,7 +406,7 @@ class SyncManagerTest {
httpMethod = "GET"
)
- coEvery { networkManager.isNetworkAvailable() } returns true
+ coEvery { networkMonitor.isNetworkAvailable() } returns true
coEvery { networkManager.sendToEndpoint(any(), any(), any(), any()) } returns BatchResult.Success
syncManager.queueAndSend(1L, JSONObject().put("lat", 52.0))
@@ -423,7 +428,7 @@ class SyncManagerTest {
authHeaders = emptyMap()
)
- coEvery { networkManager.isNetworkAvailable() } returns true
+ coEvery { networkMonitor.isNetworkAvailable() } returns true
coEvery { networkManager.sendToEndpoint(any(), any(), any(), any()) } returns BatchResult.Success
assertEquals(0L, syncManager.lastSuccessfulSyncTime)
@@ -446,7 +451,7 @@ class SyncManagerTest {
syncSsid = "",
authHeaders = emptyMap()
)
- coEvery { networkManager.isNetworkAvailable() } returns true
+ coEvery { networkMonitor.isNetworkAvailable() } returns true
coEvery { networkManager.sendToEndpoint(any(), any(), any(), any()) } returns BatchResult.Success
syncManager.queueAndSend(1L, JSONObject().put("lat", 52.0))
@@ -646,7 +651,7 @@ class SyncManagerTest {
authHeaders = emptyMap()
)
- coEvery { networkManager.isNetworkAvailable() } returns true
+ coEvery { networkMonitor.isNetworkAvailable() } returns true
every { dbHelper.getQueuedCount() } returns 5
// getQueuedLocations returns empty → performSyncAndCheckSuccess sees
// countBefore=5, countAfter=5 → failure
@@ -679,7 +684,7 @@ class SyncManagerTest {
authHeaders = emptyMap()
)
- coEvery { networkManager.isNetworkAvailable() } returns true
+ coEvery { networkMonitor.isNetworkAvailable() } returns true
every { dbHelper.getQueuedCount() } returns 5
every { dbHelper.getQueuedLocations(50) } returns emptyList()
@@ -714,7 +719,7 @@ class SyncManagerTest {
authHeaders = emptyMap()
)
- coEvery { networkManager.isNetworkAvailable() } returns true
+ coEvery { networkMonitor.isNetworkAvailable() } returns true
every { dbHelper.getQueuedCount() } returns 5
every { dbHelper.getQueuedLocations(50) } returns emptyList()
@@ -742,7 +747,7 @@ class SyncManagerTest {
authHeaders = emptyMap()
)
- coEvery { networkManager.isNetworkAvailable() } returns true
+ coEvery { networkMonitor.isNetworkAvailable() } returns true
// Simulate successful sync: queue count drops to 0 after processing
var queuedCount = 3
every { dbHelper.getQueuedCount() } answers { queuedCount }
@@ -776,7 +781,7 @@ class SyncManagerTest {
authHeaders = emptyMap()
)
- coEvery { networkManager.isNetworkAvailable() } returns true
+ coEvery { networkMonitor.isNetworkAvailable() } returns true
var queuedCount = 3
every { dbHelper.getQueuedCount() } answers { queuedCount }
every { dbHelper.getQueuedLocations(50) } returnsMany listOf(
@@ -831,7 +836,7 @@ class SyncManagerTest {
authHeaders = emptyMap()
)
- coEvery { networkManager.isNetworkAvailable() } returns false
+ coEvery { networkMonitor.isNetworkAvailable() } returns false
every { dbHelper.getQueuedCount() } returns 5
syncManager.startPeriodicSync()
@@ -853,7 +858,7 @@ class SyncManagerTest {
authHeaders = emptyMap()
)
- coEvery { networkManager.isNetworkAvailable() } returns false
+ coEvery { networkMonitor.isNetworkAvailable() } returns false
every { dbHelper.getQueuedCount() } returns 5
syncManager.startPeriodicSync()
@@ -875,7 +880,7 @@ class SyncManagerTest {
authHeaders = emptyMap()
)
- coEvery { networkManager.isNetworkAvailable() } returns true
+ coEvery { networkMonitor.isNetworkAvailable() } returns true
every { dbHelper.getQueuedCount() } returns 0
syncManager.startPeriodicSync()
@@ -897,7 +902,7 @@ class SyncManagerTest {
authHeaders = emptyMap()
)
- coEvery { networkManager.isNetworkAvailable() } returns true
+ coEvery { networkMonitor.isNetworkAvailable() } returns true
every { dbHelper.getQueuedCount() } returns 0
syncManager.startPeriodicSync()
@@ -919,7 +924,7 @@ class SyncManagerTest {
authHeaders = emptyMap()
)
- coEvery { networkManager.isNetworkAvailable() } returns true
+ coEvery { networkMonitor.isNetworkAvailable() } returns true
every { dbHelper.getQueuedCount() } returns 5
every { dbHelper.getQueuedLocations(50) } returns emptyList()
@@ -939,9 +944,9 @@ class SyncManagerTest {
private var ticks = 0
private fun startPeriodicSyncOnVirtualClock(intervalSeconds: Int, queuedCount: Int = 0): SyncManager {
- val manager = SyncManager(dbHelper, networkManager, scope, clock = { scope.testScheduler.currentTime })
+ val manager = SyncManager(dbHelper, networkManager, networkMonitor, scope, clock = { scope.testScheduler.currentTime })
manager.switchInterval(intervalSeconds)
- coEvery { networkManager.isNetworkAvailable() } returns true
+ coEvery { networkMonitor.isNetworkAvailable() } returns true
every { dbHelper.getQueuedCount() } returns queuedCount
every { dbHelper.getQueuedLocations(50) } returns emptyList()
every { AppLogger.d("SyncManager", match { it.startsWith("Sync tick:") }) } answers { ticks += 1 }
@@ -1077,7 +1082,7 @@ class SyncManagerTest {
apiFormat = ApiFormat.TRACCAR_JSON
)
- coEvery { networkManager.isNetworkAvailable() } returns true
+ coEvery { networkMonitor.isNetworkAvailable() } returns true
coEvery { networkManager.sendToEndpoint(any(), any(), any(), any(), any()) } returns BatchResult.Success
syncManager.queueAndSend(1L, JSONObject().put("lat", 52.0))
@@ -1385,7 +1390,7 @@ class SyncManagerTest {
syncSsid = "",
authHeaders = emptyMap()
)
- coEvery { networkManager.isNetworkAvailable() } returns true
+ coEvery { networkMonitor.isNetworkAvailable() } returns true
fakeQueue(20)
coEvery { networkManager.sendToEndpoint(any(), any(), any(), any(), any()) } coAnswers { delay(1_500); BatchResult.Success }
@@ -1410,7 +1415,7 @@ class SyncManagerTest {
syncSsid = "",
authHeaders = emptyMap()
)
- coEvery { networkManager.isNetworkAvailable() } returns true
+ coEvery { networkMonitor.isNetworkAvailable() } returns true
fakeQueue(10)
coEvery { networkManager.sendToEndpoint(any(), any(), any(), any(), any()) } coAnswers { delay(1_000); BatchResult.Success }
@@ -1491,7 +1496,7 @@ class SyncManagerTest {
syncSsid = "",
authHeaders = emptyMap()
)
- coEvery { networkManager.isNetworkAvailable() } returns true
+ coEvery { networkMonitor.isNetworkAvailable() } returns true
fakeQueue(20)
coEvery { networkManager.sendToEndpoint(any(), any(), any(), any(), any()) } coAnswers { delay(1_500); BatchResult.Success }
@@ -1520,7 +1525,7 @@ class SyncManagerTest {
syncSsid = "",
authHeaders = emptyMap()
)
- coEvery { networkManager.isNetworkAvailable() } returns true
+ coEvery { networkMonitor.isNetworkAvailable() } returns true
fakeQueue(0)
coEvery { networkManager.sendToEndpoint(any(), any(), any(), any(), any()) } coAnswers { delay(5_000); BatchResult.Success }
@@ -1546,7 +1551,7 @@ class SyncManagerTest {
syncSsid = "",
authHeaders = emptyMap()
)
- coEvery { networkManager.isNetworkAvailable() } returns true
+ coEvery { networkMonitor.isNetworkAvailable() } returns true
fakeQueue(0)
coEvery { networkManager.sendToEndpoint(any(), any(), any(), any(), any()) } coAnswers { delay(1_000); BatchResult.Success }
@@ -1600,7 +1605,7 @@ class SyncManagerTest {
syncSsid = "",
authHeaders = emptyMap()
)
- coEvery { networkManager.isNetworkAvailable() } returns true
+ coEvery { networkMonitor.isNetworkAvailable() } returns true
fakeQueue(0)
coEvery { networkManager.sendToEndpoint(any(), any(), any(), any(), any()) } coAnswers { delay(3_000); BatchResult.Success }
@@ -1761,7 +1766,7 @@ class SyncManagerTest {
fun `an instant send that cannot connect keeps its place in the queue`() = scope.runTest {
configurePerItem()
every { dbHelper.addToQueue(any(), any()) } returns 42L
- coEvery { networkManager.isNetworkAvailable() } returns true
+ coEvery { networkMonitor.isNetworkAvailable() } returns true
coEvery { networkManager.sendToEndpoint(any(), any(), any(), any(), any()) } returns BatchResult.NetworkError
syncManager.queueAndSend(1L, JSONObject().put("lat", 52.0))
@@ -1831,7 +1836,7 @@ class SyncManagerTest {
private var now = 0L
private fun rateLimitedManager(apiFormat: ApiFormat = ApiFormat.FIELD_MAPPED): SyncManager {
- val manager = SyncManager(dbHelper, networkManager, scope, clock = { now })
+ val manager = SyncManager(dbHelper, networkManager, networkMonitor, scope, clock = { now })
manager.updateConfig(
endpoint = "https://example.com",
syncIntervalSeconds = 0,
@@ -1842,7 +1847,7 @@ class SyncManagerTest {
authHeaders = emptyMap(),
apiFormat = apiFormat
)
- coEvery { networkManager.isNetworkAvailable() } returns true
+ coEvery { networkMonitor.isNetworkAvailable() } returns true
return manager
}
diff --git a/apps/mobile/android/app/src/test/java/com/Colota/sync/http/EndpointUrlTest.kt b/apps/mobile/android/app/src/test/java/com/Colota/sync/http/EndpointUrlTest.kt
new file mode 100644
index 00000000..e0d9aaac
--- /dev/null
+++ b/apps/mobile/android/app/src/test/java/com/Colota/sync/http/EndpointUrlTest.kt
@@ -0,0 +1,29 @@
+package com.Colota.sync.http
+
+import org.json.JSONObject
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class EndpointUrlTest {
+
+ @Test
+ fun `resolveUrlVariables substitutes DATE and TIMESTAMP`() {
+ val payload = JSONObject().apply { put("tst", 1775308740L) }
+ val result = EndpointUrl.resolveUrlVariables("https://server.com/%DATE/%TIMESTAMP.json", payload)
+ assertEquals("https://server.com/2026-04-04/1775308740.json", result)
+ }
+
+ @Test
+ fun `resolveUrlVariables substitutes YEAR MONTH DAY`() {
+ val payload = JSONObject().apply { put("tst", 1775308740L) }
+ val result = EndpointUrl.resolveUrlVariables("https://s.com/%YEAR/%MONTH/%DAY/data", payload)
+ assertEquals("https://s.com/2026/04/04/data", result)
+ }
+
+ @Test
+ fun `resolveUrlVariables returns endpoint unchanged when no percent`() {
+ val payload = JSONObject().apply { put("tst", 1775308740L) }
+ val result = EndpointUrl.resolveUrlVariables("https://server.com/api", payload)
+ assertEquals("https://server.com/api", result)
+ }
+}
diff --git a/apps/mobile/android/app/src/test/java/com/Colota/sync/http/NetworkManagerTest.kt b/apps/mobile/android/app/src/test/java/com/Colota/sync/http/NetworkManagerTest.kt
new file mode 100644
index 00000000..376da576
--- /dev/null
+++ b/apps/mobile/android/app/src/test/java/com/Colota/sync/http/NetworkManagerTest.kt
@@ -0,0 +1,117 @@
+package com.Colota.sync.http
+
+import android.content.Context
+import org.json.JSONObject
+import org.junit.Assert.*
+import org.junit.Test
+import com.Colota.util.AppLogger
+import io.mockk.*
+import org.junit.After
+import org.junit.Before
+import com.Colota.network.NetworkMonitor
+
+/** Tests for NetworkManager's request flow. Pool behaviour needs a device. */
+class NetworkManagerTest {
+
+ @Before
+ fun setUp() {
+ mockkObject(AppLogger)
+ every { AppLogger.d(any(), any()) } just Runs
+ every { AppLogger.i(any(), any()) } just Runs
+ every { AppLogger.w(any(), any()) } just Runs
+ every { AppLogger.e(any(), any(), any()) } just Runs
+ }
+
+ @After
+ fun tearDown() {
+ unmockkObject(AppLogger)
+ }
+
+ // --- testEndpoint ---
+
+ @Test
+ fun `testEndpoint invalid URL message goes through the URL mask`() {
+ // Plain JUnit has no android.net.Uri, so the mask itself is covered in AppLoggerTest
+ every { AppLogger.maskSensitiveUrlValues(any()) } answers { "masked(${firstArg<String>()})" }
+
+ val result = kotlinx.coroutines.runBlocking {
+ newManager().testEndpoint(JSONObject(), "htps://ha.example.com/api/webhook/abc")
+ }
+
+ assertFalse(result.ok)
+ assertEquals("Invalid URL: masked(htps://ha.example.com/api/webhook/abc)", result.errorMessage)
+ }
+
+ // --- verdicts ---
+
+ @Test
+ fun `a status maps to the verdict the sync pass acts on`() {
+ assertEquals(BatchResult.Success, verdictFor(204, null))
+ assertEquals(BatchResult.RateLimited(30), verdictFor(429, 30))
+ assertEquals(BatchResult.ClientError(400), verdictFor(400, null))
+ assertEquals(BatchResult.ServerError(503), verdictFor(503, null))
+ }
+
+ @Test
+ fun `a send that never got a response is a network error`() {
+ val result = kotlinx.coroutines.runBlocking { newManager().sendToEndpoint(JSONObject(), "") }
+
+ assertEquals(BatchResult.NetworkError, result)
+ }
+
+ @Test
+ fun `Retry-After is read as seconds or as an HTTP date`() {
+ val now = java.time.ZonedDateTime.parse(
+ "Sat, 19 Sep 2026 12:00:00 GMT", java.time.format.DateTimeFormatter.RFC_1123_DATE_TIME
+ ).toInstant().toEpochMilli()
+
+ assertEquals(120L, parseRetryAfter("120", now))
+ assertEquals(90L, parseRetryAfter("Sat, 19 Sep 2026 12:01:30 GMT", now))
+ assertEquals("a date in the past means now", 0L, parseRetryAfter("Sat, 19 Sep 2026 11:00:00 GMT", now))
+ assertNull(parseRetryAfter("soon", now))
+ assertNull(parseRetryAfter(null, now))
+ }
+
+ // Without the header a closed reply is pooled for reuse, and a stale pooled connection fails a streamed POST.
+ @Test
+ fun `an upload asks the server to close the connection and still counts as sent`() {
+ val server = java.net.ServerSocket(0, 1, java.net.InetAddress.getByName("127.0.0.1"))
+ val headers = java.util.concurrent.CompletableFuture<List<String>>()
+ val serving = Thread {
+ try {
+ server.accept().use { socket ->
+ val input = socket.getInputStream().bufferedReader(Charsets.ISO_8859_1)
+ val lines = generateSequence { input.readLine() }.takeWhile { it.isNotEmpty() }.toList()
+ val length = lines.first { it.startsWith("Content-Length", ignoreCase = true) }.substringAfter(":").trim().toInt()
+ repeat(length) { input.read() }
+ headers.complete(lines)
+ val body = """{"ok":true}"""
+ socket.getOutputStream().write(
+ "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: ${body.length}\r\n\r\n$body".toByteArray()
+ )
+ }
+ } catch (e: Exception) {
+ headers.completeExceptionally(e)
+ }
+ }.apply { start() }
+ try {
+ val monitor = mockk<NetworkMonitor>()
+ every { monitor.isNetworkAvailable() } returns true
+
+ val result = kotlinx.coroutines.runBlocking {
+ NetworkManager(mockk<Context>(relaxed = true), monitor).sendToEndpoint(JSONObject().put("lat", 1.0), "http://127.0.0.1:${server.localPort}/")
+ }
+
+ assertEquals(BatchResult.Success, result)
+ val sent = headers.get(5, java.util.concurrent.TimeUnit.SECONDS)
+ assertTrue("request headers were $sent", sent.any { it.equals("Connection: close", ignoreCase = true) })
+ } finally {
+ serving.join(5000)
+ server.close()
+ }
+ }
+
+ private fun newManager(): NetworkManager {
+ return NetworkManager(mockk<Context>(relaxed = true), mockk<NetworkMonitor>(relaxed = true))
+ }
+}
diff --git a/apps/mobile/android/app/src/test/java/com/Colota/sync/http/RequestBuilderTest.kt b/apps/mobile/android/app/src/test/java/com/Colota/sync/http/RequestBuilderTest.kt
new file mode 100644
index 00000000..3151b6d3
--- /dev/null
+++ b/apps/mobile/android/app/src/test/java/com/Colota/sync/http/RequestBuilderTest.kt
@@ -0,0 +1,16 @@
+package com.Colota.sync.http
+
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class RequestBuilderTest {
+
+ @Test
+ fun `a custom Connection header cannot switch connection reuse back on`() {
+ for (isGet in listOf(false, true)) {
+ val connection = RequestBuilder.open(java.net.URL("http://127.0.0.1:9/"), isGet, mapOf("Connection" to "keep-alive")) { null }
+
+ assertEquals("close", connection.getRequestProperty("Connection"))
+ }
+ }
+}
diff --git a/apps/mobile/android/app/src/test/java/com/Colota/sync/http/ResponseReaderTest.kt b/apps/mobile/android/app/src/test/java/com/Colota/sync/http/ResponseReaderTest.kt
new file mode 100644
index 00000000..73c163fc
--- /dev/null
+++ b/apps/mobile/android/app/src/test/java/com/Colota/sync/http/ResponseReaderTest.kt
@@ -0,0 +1,141 @@
+package com.Colota.sync.http
+
+import android.content.Context
+import org.json.JSONObject
+import org.junit.Assert.*
+import org.junit.Test
+import com.Colota.util.AppLogger
+import io.mockk.*
+import org.junit.After
+import org.junit.Before
+
+class ResponseReaderTest {
+
+ @Before
+ fun setUp() {
+ mockkObject(AppLogger)
+ every { AppLogger.d(any(), any()) } just Runs
+ every { AppLogger.i(any(), any()) } just Runs
+ every { AppLogger.w(any(), any()) } just Runs
+ every { AppLogger.e(any(), any(), any()) } just Runs
+ }
+
+ @After
+ fun tearDown() {
+ unmockkObject(AppLogger)
+ }
+
+ /**
+ * A rate-limited flush logs one error body per rejected point. Field logs showed ~110 nginx
+ * 429 pages in two seconds, 7 lines each, crowding real events out of the rolling log file.
+ */
+ @Test
+ fun `an html error page is logged as a single bounded line`() {
+ val nginx429 = """
+ <html>
+ <head><title>429 Too Many Requests</title></head>
+ <body>
+ <center><h1>429 Too Many Requests</h1></center>
+ <hr><center>nginx</center>
+ </body>
+ </html>
+ """.trimIndent()
+
+ val logged = readErrorBody(nginx429)
+
+ assertFalse("must not span lines", logged.contains("\n"))
+ assertTrue("must stay bounded", logged.length <= 200)
+ assertTrue("must keep the useful part", logged.contains("429 Too Many Requests"))
+ }
+
+ @Test
+ fun `a body longer than the cap is truncated`() {
+ val logged = readErrorBody("x".repeat(5000))
+
+ assertEquals(200, logged.length)
+ }
+
+ @Test
+ fun `a missing body reports that rather than throwing`() {
+ assertEquals("No error body", readErrorBody(null))
+ }
+
+ @Test
+ fun `a rate-limited batch carries the server's Retry-After`() {
+ val connection = io.mockk.mockk<java.net.HttpURLConnection>(relaxed = true)
+ io.mockk.every { connection.responseCode } returns 429
+ io.mockk.every { connection.getHeaderField("Retry-After") } returns "30"
+ assertEquals(BatchResult.RateLimited(30), ResponseReader.readBatchResponse(connection, 50))
+ }
+
+ // Android keeps a connection whose reply was never closed pooled for minutes, TLS buffers included.
+ @Test
+ fun `an accepted batch closes the reply it does not read`() {
+ val reply = mockk<java.io.InputStream>(relaxed = true)
+ val connection = mockk<java.net.HttpURLConnection>(relaxed = true)
+ every { connection.responseCode } returns 200
+ every { connection.errorStream } returns null
+ every { connection.inputStream } returns reply
+
+ assertEquals(BatchResult.Success, ResponseReader.readBatchResponse(connection, 50))
+
+ verify(exactly = 1) { reply.close() }
+ }
+
+ @Test
+ fun `a rate-limited batch closes the error page it does not read`() {
+ val page = mockk<java.io.InputStream>(relaxed = true)
+ val connection = mockk<java.net.HttpURLConnection>(relaxed = true)
+ every { connection.responseCode } returns 429
+ every { connection.errorStream } returns page
+
+ ResponseReader.readBatchResponse(connection, 50)
+
+ verify(exactly = 1) { page.close() }
+ }
+
+ @Test
+ fun `a reply that fails to open does not turn an accepted batch into a failure`() {
+ val connection = mockk<java.net.HttpURLConnection>(relaxed = true)
+ every { connection.responseCode } returns 204
+ every { connection.errorStream } returns null
+ every { connection.inputStream } throws java.io.IOException("stream closed")
+
+ assertEquals(BatchResult.Success, ResponseReader.readBatchResponse(connection, 50))
+ }
+
+ @Test
+ fun `an accepted upload closes the reply it does not read`() {
+ val reply = mockk<java.io.InputStream>(relaxed = true)
+ val connection = mockk<java.net.HttpURLConnection>(relaxed = true)
+ every { connection.responseCode } returns 200
+ every { connection.errorStream } returns null
+ every { connection.inputStream } returns reply
+
+ assertTrue(ResponseReader.readResponse(connection).ok)
+
+ verify(exactly = 1) { reply.close() }
+ }
+
+ // Android offers no error stream below 400, so a redirect it does not follow has only the plain one.
+ @Test
+ fun `a redirect that is not followed is a failure whose reply is still closed`() {
+ val reply = mockk<java.io.InputStream>(relaxed = true)
+ val connection = mockk<java.net.HttpURLConnection>(relaxed = true)
+ every { connection.responseCode } returns 307
+ every { connection.errorStream } returns null
+ every { connection.inputStream } returns reply
+
+ val result = ResponseReader.readResponse(connection)
+
+ assertFalse(result.ok)
+ assertEquals(307, result.httpStatus)
+ verify(exactly = 1) { reply.close() }
+ }
+
+ private fun readErrorBody(body: String?): String {
+ val connection = mockk<java.net.HttpURLConnection>(relaxed = true)
+ every { connection.errorStream } returns body?.byteInputStream()
+ return ResponseReader.readErrorBody(connection)
+ }
+}
diff --git a/apps/mobile/android/app/src/test/java/com/Colota/sync/UrlSafetyTest.kt b/apps/mobile/android/app/src/test/java/com/Colota/sync/http/UrlSafetyTest.kt
similarity index 99%
rename from apps/mobile/android/app/src/test/java/com/Colota/sync/UrlSafetyTest.kt
rename to apps/mobile/android/app/src/test/java/com/Colota/sync/http/UrlSafetyTest.kt
index f0cd8c42..cf65e760 100644
--- a/apps/mobile/android/app/src/test/java/com/Colota/sync/UrlSafetyTest.kt
+++ b/apps/mobile/android/app/src/test/java/com/Colota/sync/http/UrlSafetyTest.kt
@@ -1,4 +1,4 @@
-package com.Colota.sync
+package com.Colota.sync.http
import java.net.InetAddress
import java.net.UnknownHostException
diff --git a/apps/mobile/android/app/src/test/java/com/Colota/sync/tls/ClientCertSslContextProviderTest.kt b/apps/mobile/android/app/src/test/java/com/Colota/sync/http/tls/ClientCertSslContextProviderTest.kt
similarity index 99%
rename from apps/mobile/android/app/src/test/java/com/Colota/sync/tls/ClientCertSslContextProviderTest.kt
rename to apps/mobile/android/app/src/test/java/com/Colota/sync/http/tls/ClientCertSslContextProviderTest.kt
index 4e33d8c4..999bfcc4 100644
--- a/apps/mobile/android/app/src/test/java/com/Colota/sync/tls/ClientCertSslContextProviderTest.kt
+++ b/apps/mobile/android/app/src/test/java/com/Colota/sync/http/tls/ClientCertSslContextProviderTest.kt
@@ -1,4 +1,4 @@
-package com.Colota.sync.tls
+package com.Colota.sync.http.tls
import com.Colota.util.AppLogger
import io.mockk.*
diff --git a/apps/mobile/android/app/src/test/java/com/Colota/sync/tls/CompositeX509TrustManagerTest.kt b/apps/mobile/android/app/src/test/java/com/Colota/sync/http/tls/CompositeX509TrustManagerTest.kt
similarity index 99%
rename from apps/mobile/android/app/src/test/java/com/Colota/sync/tls/CompositeX509TrustManagerTest.kt
rename to apps/mobile/android/app/src/test/java/com/Colota/sync/http/tls/CompositeX509TrustManagerTest.kt
index 3f4a52ca..203a3360 100644
--- a/apps/mobile/android/app/src/test/java/com/Colota/sync/tls/CompositeX509TrustManagerTest.kt
+++ b/apps/mobile/android/app/src/test/java/com/Colota/sync/http/tls/CompositeX509TrustManagerTest.kt
@@ -1,4 +1,4 @@
-package com.Colota.sync.tls
+package com.Colota.sync.http.tls
import io.mockk.*
import org.junit.Assert.*
diff --git a/apps/mobile/android/app/src/test/java/com/Colota/util/LogExportMergerTest.kt b/apps/mobile/android/app/src/test/java/com/Colota/util/LogExportMergerTest.kt
index 04722a42..53651335 100644
--- a/apps/mobile/android/app/src/test/java/com/Colota/util/LogExportMergerTest.kt
+++ b/apps/mobile/android/app/src/test/java/com/Colota/util/LogExportMergerTest.kt
@@ -72,7 +72,7 @@ class LogExportMergerTest {
val recorded = segment(
"seg1.log",
"2026-09-09 09:00:00.000 ERROR/Sync: network error",
- "\tat com.Colota.sync.NetworkManager.run(NetworkManager.kt:88)",
+ "\tat com.Colota.sync.http.NetworkManager.run(NetworkManager.kt:88)",
"\tat com.Colota.sync.SyncManager.flush(SyncManager.kt:214)",
"2026-09-09 09:00:20.000 INFO/Service: recovered"
)
@@ -81,7 +81,7 @@ class LogExportMergerTest {
val out = merged(listOf(recorded), appLog)
assertEquals("2026-09-09 09:00:00.000 ERROR/Sync: network error", out[0])
- assertEquals("\tat com.Colota.sync.NetworkManager.run(NetworkManager.kt:88)", out[1])
+ assertEquals("\tat com.Colota.sync.http.NetworkManager.run(NetworkManager.kt:88)", out[1])
assertEquals("\tat com.Colota.sync.SyncManager.flush(SyncManager.kt:214)", out[2])
assertEquals("2026-09-09 09:00:10.000 WARN/JS: retry scheduled", out[3])
}