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.mdindex 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 forAll 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.+### UrlSafetyHTTP 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.### ProfileConstantsdiff --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.ktindex 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.getIntOrNullimport com.Colota.service.getStringOrNullimport com.Colota.service.getBooleanOrNullimport com.Colota.sync.SyncState-import com.Colota.sync.NetworkManager-import com.Colota.sync.UrlSafety+import com.Colota.network.NetworkMonitor+import com.Colota.sync.http.UrlSafetyimport com.Colota.util.DeviceInfoHelperimport com.Colota.export.AutoExportConfigimport 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) :@ReactMethodfun isNetworkAvailable(promise: Promise) {- promise.resolve(networkManager.isNetworkAvailable())+ promise.resolve(networkMonitor.isNetworkAvailable())}@ReactMethodfun isUnmeteredConnection(promise: Promise) {- promise.resolve(networkManager.isUnmeteredConnection())+ promise.resolve(networkMonitor.isUnmeteredConnection())}@ReactMethodfun getCurrentSsid(promise: Promise) {- networkManager.readSsidOnce { promise.resolve(it) }+ networkMonitor.readSsidOnce { promise.resolve(it) }}@ReactMethoddiff --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.ktindex 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.bridgeimport android.app.Activityimport android.content.Intentimport 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.ClientCertSslContextProviderimport com.Colota.util.AppLoggerimport com.Colota.util.SecureStorageHelperimport 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.ktnew file mode 100644index 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.ktindex 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.Handlerimport android.os.Looperimport androidx.car.app.connection.CarConnectionimport androidx.lifecycle.Observer-import com.Colota.sync.NetworkManager+import com.Colota.network.NetworkMonitorimport 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 = falsebluetoothReceiver = 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.ktindex 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.GeofenceHelperimport com.Colota.data.ProfileHelperimport com.Colota.data.SettingsKeysimport com.Colota.sync.ApiFormat-import com.Colota.sync.NetworkManager+import com.Colota.sync.http.NetworkManager+import com.Colota.network.NetworkMonitorimport com.Colota.sync.PayloadBuilderimport com.Colota.sync.SyncManagerimport com.Colota.util.DeviceInfoHelper@@ -51,6 +52,7 @@ class LocationForegroundService : Service() {@Volatile private var payloadCustomFields: Map<String, String> = emptyMap()private lateinit var deviceInfoHelper: DeviceInfoHelperprivate lateinit var networkManager: NetworkManager+ private lateinit var networkMonitor: NetworkMonitorprivate lateinit var geofenceHelper: GeofenceHelperprivate lateinit var secureStorage: SecureStorageHelperprivate 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.ktdeleted file mode 100644index 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 filediff --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.ktindex 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.Locationimport com.Colota.util.AppLoggerimport com.Colota.util.BatteryStatusimport org.json.JSONObject+import java.net.URLEncoderimport java.time.Instantimport 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.ktindex 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.withLockimport org.json.JSONExceptionimport org.json.JSONObjectimport 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.ConcurrentHashMapclass 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 falseval 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.ktnew file mode 100644index 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.ktnew file mode 100644index 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.ktsimilarity index 98%rename from apps/mobile/android/app/src/main/java/com/colota/sync/NetworkResults.ktrename to apps/mobile/android/app/src/main/java/com/colota/sync/http/NetworkResults.ktindex 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.httpimport java.time.ZonedDateTimeimport java.time.format.DateTimeFormatterdiff --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.ktnew file mode 100644index 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.ktnew file mode 100644index 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.ktsimilarity index 98%rename from apps/mobile/android/app/src/main/java/com/colota/sync/UrlSafety.ktrename to apps/mobile/android/app/src/main/java/com/colota/sync/http/UrlSafety.ktindex 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.httpimport androidx.annotation.VisibleForTestingimport java.net.InetAddressdiff --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.ktsimilarity index 99%rename from apps/mobile/android/app/src/main/java/com/colota/sync/tls/ClientCertSslContextProvider.ktrename to apps/mobile/android/app/src/main/java/com/colota/sync/http/tls/ClientCertSslContextProvider.ktindex 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.tlsimport android.content.Contextimport com.Colota.util.AppLoggerdiff --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.ktsimilarity index 97%rename from apps/mobile/android/app/src/main/java/com/colota/sync/tls/CompositeX509TrustManager.ktrename to apps/mobile/android/app/src/main/java/com/colota/sync/http/tls/CompositeX509TrustManager.ktindex 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.tlsimport java.security.cert.CertificateExceptionimport java.security.cert.X509Certificatediff --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.ktsimilarity index 99%rename from apps/mobile/android/app/src/main/java/com/colota/sync/tls/DynamicKeyManager.ktrename to apps/mobile/android/app/src/main/java/com/colota/sync/http/tls/DynamicKeyManager.ktindex 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.tlsimport android.content.Contextimport android.security.KeyChaindiff --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.ktnew file mode 100644index 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.ktindex 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.ktnew file mode 100644index 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.ktindex 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.Beforeimport org.junit.Test-import com.Colota.sync.NetworkManager+import com.Colota.network.NetworkMonitorimport com.Colota.util.AppLoggerimport org.junit.After@@ -37,7 +37,7 @@ import org.junit.Afterclass ConditionMonitorTest {private lateinit var mockContext: Context- private lateinit var mockNetworkManager: NetworkManager+ private lateinit var mockNetworkMonitor: NetworkMonitorprivate lateinit var mockProfileManager: ProfileManagerprivate lateinit var mockHandler: Handlerprivate lateinit var monitor: ConditionMonitor@@ -45,7 +45,7 @@ class ConditionMonitorTest {@Beforefun 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 falsemonitor.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 truemonitor.start()verify { mockProfileManager.onWifiStateChanged(true, "") }- verify(exactly = 0) { mockNetworkManager.readSsidOnce(any()) }+ verify(exactly = 0) { mockNetworkMonitor.readSsidOnce(any()) }}@Testfun `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 truevar 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 truevar 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.ktindex 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.LocationAccuracyimport com.Colota.location.LocationProviderimport com.Colota.location.LocationUpdateCallbackimport com.Colota.sync.PayloadBuilder-import com.Colota.sync.NetworkManager+import com.Colota.sync.http.NetworkManager+import com.Colota.network.NetworkMonitorimport com.Colota.sync.SyncManagerimport com.Colota.util.AppLoggerimport com.Colota.util.DeviceInfoHelper@@ -50,6 +51,7 @@ class LocationForegroundServiceTest {private lateinit var batteryMonitor: BatteryMonitorprivate lateinit var secureStorage: SecureStorageHelperprivate lateinit var networkManager: NetworkManager+ private lateinit var networkMonitor: NetworkMonitorprivate lateinit var androidNotificationManager: NotificationManagerprivate 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) }}@Testdiff --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.ktdeleted file mode 100644index 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.ktindex 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 hasBearingevery { [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.ktindex 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.Beforeimport org.junit.Testimport 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: DatabaseHelperprivate lateinit var networkManager: NetworkManager+ private lateinit var networkMonitor: NetworkMonitorprivate lateinit var scope: TestScopeprivate 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.NetworkErrormockkObject(AppLogger)@@ -100,7 +105,7 @@ class SyncManagerTest {authHeaders = emptyMap())- coEvery { networkManager.isNetworkAvailable() } returns true+ coEvery { networkMonitor.isNetworkAvailable() } returns truecoEvery { networkManager.sendToEndpoint(any(), any(), any(), any()) } returns BatchResult.Successval payload = JSONObject().put("lat", 52.0)@@ -124,7 +129,7 @@ class SyncManagerTest {authHeaders = emptyMap())- coEvery { networkManager.isNetworkAvailable() } returns true+ coEvery { networkMonitor.isNetworkAvailable() } returns truecoEvery { 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 falseval 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 falseval 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 truecoEvery { networkManager.sendToEndpoint(any(), any(), any(), any()) } returns BatchResult.Successval 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 falseval 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 truecoEvery { networkManager.sendToEndpoint(any(), any(), any(), any()) } returns BatchResult.Successval 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 falseval 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 truecoEvery { networkManager.sendToEndpoint(any(), any(), any(), any()) } returns BatchResult.Successval payload = JSONObject().put("lat", 52.0)@@ -304,7 +309,7 @@ class SyncManagerTest {authHeaders = emptyMap())- coEvery { networkManager.isNetworkAvailable() } returns true+ coEvery { networkMonitor.isNetworkAvailable() } returns trueval 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 truecoEvery { networkManager.sendToEndpoint(any(), any(), any(), any()) } returns BatchResult.Successval 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 falseval 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 truecoEvery { 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 truecoEvery { networkManager.sendToEndpoint(any(), any(), any(), any()) } returns BatchResult.SuccesssyncManager.queueAndSend(1L, JSONObject().put("lat", 52.0))@@ -423,7 +428,7 @@ class SyncManagerTest {authHeaders = emptyMap())- coEvery { networkManager.isNetworkAvailable() } returns true+ coEvery { networkMonitor.isNetworkAvailable() } returns truecoEvery { networkManager.sendToEndpoint(any(), any(), any(), any()) } returns BatchResult.SuccessassertEquals(0L, syncManager.lastSuccessfulSyncTime)@@ -446,7 +451,7 @@ class SyncManagerTest {syncSsid = "",authHeaders = emptyMap())- coEvery { networkManager.isNetworkAvailable() } returns true+ coEvery { networkMonitor.isNetworkAvailable() } returns truecoEvery { networkManager.sendToEndpoint(any(), any(), any(), any()) } returns BatchResult.SuccesssyncManager.queueAndSend(1L, JSONObject().put("lat", 52.0))@@ -646,7 +651,7 @@ class SyncManagerTest {authHeaders = emptyMap())- coEvery { networkManager.isNetworkAvailable() } returns true+ coEvery { networkMonitor.isNetworkAvailable() } returns trueevery { 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 trueevery { dbHelper.getQueuedCount() } returns 5every { dbHelper.getQueuedLocations(50) } returns emptyList()@@ -714,7 +719,7 @@ class SyncManagerTest {authHeaders = emptyMap())- coEvery { networkManager.isNetworkAvailable() } returns true+ coEvery { networkMonitor.isNetworkAvailable() } returns trueevery { dbHelper.getQueuedCount() } returns 5every { 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 processingvar queuedCount = 3every { dbHelper.getQueuedCount() } answers { queuedCount }@@ -776,7 +781,7 @@ class SyncManagerTest {authHeaders = emptyMap())- coEvery { networkManager.isNetworkAvailable() } returns true+ coEvery { networkMonitor.isNetworkAvailable() } returns truevar queuedCount = 3every { 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 falseevery { dbHelper.getQueuedCount() } returns 5syncManager.startPeriodicSync()@@ -853,7 +858,7 @@ class SyncManagerTest {authHeaders = emptyMap())- coEvery { networkManager.isNetworkAvailable() } returns false+ coEvery { networkMonitor.isNetworkAvailable() } returns falseevery { dbHelper.getQueuedCount() } returns 5syncManager.startPeriodicSync()@@ -875,7 +880,7 @@ class SyncManagerTest {authHeaders = emptyMap())- coEvery { networkManager.isNetworkAvailable() } returns true+ coEvery { networkMonitor.isNetworkAvailable() } returns trueevery { dbHelper.getQueuedCount() } returns 0syncManager.startPeriodicSync()@@ -897,7 +902,7 @@ class SyncManagerTest {authHeaders = emptyMap())- coEvery { networkManager.isNetworkAvailable() } returns true+ coEvery { networkMonitor.isNetworkAvailable() } returns trueevery { dbHelper.getQueuedCount() } returns 0syncManager.startPeriodicSync()@@ -919,7 +924,7 @@ class SyncManagerTest {authHeaders = emptyMap())- coEvery { networkManager.isNetworkAvailable() } returns true+ coEvery { networkMonitor.isNetworkAvailable() } returns trueevery { dbHelper.getQueuedCount() } returns 5every { dbHelper.getQueuedLocations(50) } returns emptyList()@@ -939,9 +944,9 @@ class SyncManagerTest {private var ticks = 0private 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 trueevery { dbHelper.getQueuedCount() } returns queuedCountevery { 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 truecoEvery { networkManager.sendToEndpoint(any(), any(), any(), any(), any()) } returns BatchResult.SuccesssyncManager.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 truefakeQueue(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 truefakeQueue(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 truefakeQueue(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 truefakeQueue(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 truefakeQueue(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 truefakeQueue(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 truecoEvery { networkManager.sendToEndpoint(any(), any(), any(), any(), any()) } returns BatchResult.NetworkErrorsyncManager.queueAndSend(1L, JSONObject().put("lat", 52.0))@@ -1831,7 +1836,7 @@ class SyncManagerTest {private var now = 0Lprivate 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 truereturn 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.ktnew file mode 100644index 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.ktnew file mode 100644index 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.ktnew file mode 100644index 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.ktnew file mode 100644index 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.ktsimilarity index 99%rename from apps/mobile/android/app/src/test/java/com/Colota/sync/UrlSafetyTest.ktrename to apps/mobile/android/app/src/test/java/com/Colota/sync/http/UrlSafetyTest.ktindex 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.httpimport java.net.InetAddressimport java.net.UnknownHostExceptiondiff --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.ktsimilarity index 99%rename from apps/mobile/android/app/src/test/java/com/Colota/sync/tls/ClientCertSslContextProviderTest.ktrename to apps/mobile/android/app/src/test/java/com/Colota/sync/http/tls/ClientCertSslContextProviderTest.ktindex 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.tlsimport com.Colota.util.AppLoggerimport 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.ktsimilarity index 99%rename from apps/mobile/android/app/src/test/java/com/Colota/sync/tls/CompositeX509TrustManagerTest.ktrename to apps/mobile/android/app/src/test/java/com/Colota/sync/http/tls/CompositeX509TrustManagerTest.ktindex 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.tlsimport 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.ktindex 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])}