MM-71102 - notify js on network changes and resend session attributes

android/src/main/java/com/mattermost/networkclient/ApiClientModuleImpl.kt

@@ -7,12 +7,14 @@ import androidx.datastore.preferences.core.Preferences
 import androidx.datastore.preferences.core.edit
 import androidx.datastore.preferences.core.stringPreferencesKey
 import androidx.datastore.preferences.preferencesDataStore
+import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.modules.network.ForwardingCookieHandler
 import com.facebook.react.modules.network.ReactCookieJarContainer
+import com.mattermost.networkclient.enums.ApiClientEvents
 import com.mattermost.networkclient.helpers.KeyStoreHelper
 import com.mattermost.networkclient.sessionattributes.SessionAttributesEngine
 import kotlinx.coroutines.flow.first
@@ -34,6 +36,10 @@ class ApiClientModuleImpl(appContext: Context) {
         const val NAME = "ApiClient"
 
         lateinit var context: Context
+        // Events go through the React context. Native code outside React (e.g. push notification
+        // handling) creates its own instance with a plain Context, which must not replace it.
+        @Volatile
+        private var reactContext: ReactApplicationContext? = null
         private val clients = mutableMapOf<HttpUrl, NetworkClient>()
         private val calls = mutableMapOf<String, Call>()
         private lateinit var sharedPreferences: SharedPreferences
@@ -94,15 +100,16 @@ class ApiClientModuleImpl(appContext: Context) {
         }
 
         internal fun sendJSEvent(eventName: String, data: WritableMap?) {
-            val reactApplicationContext = context as? ReactApplicationContext
+            val reactApplicationContext = reactContext
             if (reactApplicationContext?.hasActiveReactInstance() == true) {
                 reactApplicationContext.emitDeviceEvent(eventName, data)
 
             }
         }
 
-        private fun setCtx(reactContext: Context) {
-            context = reactContext
+        private fun setCtx(appContext: Context) {
+            context = appContext
+            (appContext as? ReactApplicationContext)?.let { reactContext = it }
         }
 
         private fun migrateSharedPreferences(reactContext: Context) {
@@ -134,6 +141,11 @@ class ApiClientModuleImpl(appContext: Context) {
     init {
         setCtx(appContext)
         SessionAttributesEngine.init(appContext)
+        SessionAttributesEngine.setNetworkChangeListener { serverUrls ->
+            val data = Arguments.createMap()
+            data.putArray("serverUrls", Arguments.fromList(serverUrls))
+            sendJSEvent(ApiClientEvents.SESSION_ATTRIBUTES_NETWORK_CHANGED.event, data)
+        }
         migrateSharedPreferences(appContext)
         setCookieJar(appContext)
     }

android/src/main/java/com/mattermost/networkclient/enums/APIClientEvents.kt

@@ -4,6 +4,7 @@ enum class ApiClientEvents(val event: String) {
     DOWNLOAD_PROGRESS("ApiClient-DownloadProgress"),
     UPLOAD_PROGRESS("ApiClient-UploadProgress"),
     CLIENT_ERROR("ApiClient-Error"),
+    SESSION_ATTRIBUTES_NETWORK_CHANGED("ApiClient-SessionAttributesNetworkChanged"),
 }
 
 enum class SslErrors(val event: Int) {

android/src/main/java/com/mattermost/networkclient/sessionattributes/SessionAttributesConstants.kt

@@ -21,4 +21,12 @@ object SessionAttributesConstants {
         const val SERVER_FQDN = "server_fqdn"
         const val SSID = "ssid"
     }
+
+    // Attributes read from the device network, resent as soon as the network changes.
+    val NETWORK_KEYS = setOf(
+        AttributeKey.CLIENT_IP_ADDRESS,
+        AttributeKey.NETWORK_INTERFACE_TYPE,
+        AttributeKey.SSID,
+        AttributeKey.VPN_ACTIVE,
+    )
 }

android/src/main/java/com/mattermost/networkclient/sessionattributes/SessionAttributesEngine.kt

@@ -12,18 +12,60 @@ object SessionAttributesEngine {
     private val store: SessionAttributesStore by lazy { SessionAttributesStore(context) }
     private val collector: SessionAttributesCollector by lazy { SessionAttributesCollector(context, store) }
 
+    private var networkMonitor: SessionAttributesNetworkMonitor? = null
+    @Volatile
+    private var networkChangeListener: ((List<String>) -> Unit)? = null
+
     fun init(appContext: Context) {
         if (!::context.isInitialized) {
             context = appContext.applicationContext
         }
     }
 
+    /**
+     * Sets the function called with the URLs of the servers whose network attributes
+     * were reset because the device network changed.
+     */
+    fun setNetworkChangeListener(listener: (List<String>) -> Unit) {
+        networkChangeListener = listener
+    }
+
+    /**
+     * Watches the device network only while a server sends session attributes, so apps
+     * whose servers do not use them never register a network callback. The app sets the
+     * manifest again on every connection, which also resets what was sent, so changes
+     * missed while the monitor was stopped do not matter.
+     */
+    @Synchronized
+    private fun updateNetworkMonitor() {
+        val shouldRun = store.hasServersSendingAttributes()
+        if (shouldRun && networkMonitor == null) {
+            networkMonitor = SessionAttributesNetworkMonitor(
+                context,
+                snapshotProvider = { collector.currentNetworkSnapshot() },
+                onChange = ::onNetworkChanged,
+            ).also { it.start() }
+        } else if (!shouldRun) {
+            networkMonitor?.stop()
+            networkMonitor = null
+        }
+    }
+
+    private fun onNetworkChanged() {
+        val serverUrls = store.resetNetworkFields()
+        if (serverUrls.isNotEmpty()) {
+            networkChangeListener?.invoke(serverUrls)
+        }
+    }
+
     fun setEnabled(serverUrl: String, enabled: Boolean) {
         store.setEnabled(serverUrl, enabled)
+        updateNetworkMonitor()
     }
 
     fun removeServer(serverUrl: String) {
         store.removeState(serverUrl)
+        updateNetworkMonitor()
     }
 
     fun setManifest(serverUrl: String, manifestJson: String) {
@@ -44,6 +86,7 @@ object SessionAttributesEngine {
             return
         }
         store.setManifest(serverUrl, fields)
+        updateNetworkMonitor()
     }
 
     fun upsertManifestField(serverUrl: String, fieldJson: String) {
@@ -54,10 +97,12 @@ object SessionAttributesEngine {
             return
         }
         SAField.fromJson(field)?.let { store.upsertField(serverUrl, it) }
+        updateNetworkMonitor()
     }
 
     fun removeManifestField(serverUrl: String, name: String) {
         store.removeField(serverUrl, name)
+        updateNetworkMonitor()
     }
 
     fun setStableValues(valuesJson: String) {
@@ -80,13 +125,16 @@ object SessionAttributesEngine {
             return null
         }
 
+        // Read before collecting, so a network change during collection is detected in markSent.
+        val generation = store.currentNetworkGeneration()
         val state = store.loadState(serverUrl) ?: return null
         if (!state.enabled || state.manifest.isEmpty()) {
             return null
         }
 
         val now = System.currentTimeMillis()
         val payload = JSONObject()
+        val sent = mutableListOf<String>()
 
         for (field in state.manifest) {
             val lastSent = state.lastSentAt[field.name]
@@ -102,14 +150,14 @@ object SessionAttributesEngine {
             }
 
             payload.put(field.name, value)
-            state.lastSentAt[field.name] = now
+            sent.add(field.name)
         }
 
-        if (payload.length() == 0) {
+        if (sent.isEmpty()) {
             return null
         }
 
-        store.saveState(serverUrl, state)
+        store.markSent(serverUrl, sent, now, generation)
 
         return Base64.encodeToString(payload.toString().toByteArray(), Base64.NO_WRAP)
     }

android/src/main/java/com/mattermost/networkclient/sessionattributes/SessionAttributesNetworkMonitor.kt

@@ -0,0 +1,103 @@
+package com.mattermost.networkclient.sessionattributes
+
+import android.content.Context
+import android.net.ConnectivityManager
+import android.net.LinkProperties
+import android.net.Network
+import android.net.NetworkCapabilities
+import android.os.Handler
+import android.os.HandlerThread
+import android.util.Log
+
+/**
+ * Tells whether the device network changed between two snapshots. The first
+ * snapshot is only a baseline, and a snapshot without a network is ignored so a
+ * drop and reconnect to the same network does not count as a change.
+ */
+class NetworkChangeDetector {
+    private var last: NetworkSnapshot? = null
+
+    fun update(snapshot: NetworkSnapshot): Boolean {
+        if (snapshot.interfaceType.isEmpty()) {
+            return false
+        }
+        val previous = last
+        last = snapshot
+        return previous != null && previous != snapshot
+    }
+}
+
+/**
+ * Listens to the default network and calls [onChange] once the network attributes
+ * (interface type, SSID, VPN state or IP address) differ from the last ones seen.
+ * The OS sends several callbacks for a single switch, so they are debounced and the
+ * snapshot is taken once the network has settled.
+ */
+class SessionAttributesNetworkMonitor(
+    private val context: Context,
+    private val snapshotProvider: () -> NetworkSnapshot,
+    private val onChange: () -> Unit,
+) {
+    private val detector = NetworkChangeDetector()
+    private val thread = HandlerThread("SessionAttributesNetworkMonitor").apply { start() }
+    private val handler = Handler(thread.looper)
+    private val evaluate = Runnable {
+        try {
+            if (detector.update(snapshotProvider())) {
+                onChange()
+            }
+        } catch (e: Exception) {
+            Log.w("NetworkClient", "Failed to evaluate network change: ${e.message}")
+        }
+    }
+
+    // Separate from [evaluate], which the first callback would otherwise cancel before it runs.
+    private val baseline = Runnable {
+        try {
+            detector.update(snapshotProvider())
+        } catch (e: Exception) {
+            Log.w("NetworkClient", "Failed to read the starting network: ${e.message}")
+        }
+    }
+
+    private val callback = object : ConnectivityManager.NetworkCallback() {
+        override fun onAvailable(network: Network) = schedule()
+        override fun onLost(network: Network) = schedule()
+        override fun onCapabilitiesChanged(network: Network, networkCapabilities: NetworkCapabilities) = schedule()
+        override fun onLinkPropertiesChanged(network: Network, linkProperties: LinkProperties) = schedule()
+    }
+
+    fun start() {
+        // Takes the baseline right away instead of after the first debounce, so a change
+        // just after starting is still compared against the network attributes were sent on.
+        handler.post(baseline)
+        try {
+            val connectivityManager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+            // The callback only reschedules on [handler], so it can run on the system thread.
+            connectivityManager.registerDefaultNetworkCallback(callback)
+        } catch (e: Exception) {
+            Log.w("NetworkClient", "Failed to watch network changes: ${e.message}")
+        }
+    }
+
+    /** Stops listening and ends the thread. A stopped monitor cannot be started again. */
+    fun stop() {
+        try {
+            val connectivityManager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+            connectivityManager.unregisterNetworkCallback(callback)
+        } catch (e: Exception) {
+            Log.w("NetworkClient", "Failed to stop watching network changes: ${e.message}")
+        }
+        handler.removeCallbacksAndMessages(null)
+        thread.quitSafely()
+    }
+
+    private fun schedule() {
+        handler.removeCallbacks(evaluate)
+        handler.postDelayed(evaluate, DEBOUNCE_MS)
+    }
+
+    companion object {
+        private const val DEBOUNCE_MS = 1000L
+    }
+}

android/src/main/java/com/mattermost/networkclient/sessionattributes/SessionAttributesStore.kt

@@ -108,6 +108,8 @@ class SessionAttributesStore(context: Context) {
     private val cacheLock = Any()
     private val stateCache = mutableMapOf<String, ServerSessionAttributesState>()
     private var stableValues: Map<String, String>? = null
+    // Bumped on every network change, see markSent.
+    private var networkGeneration = 0L
 
     // Serializes persistence so cache updates reach disk in the order they were made.
     // Only taken by persist()/delete(), which never re-enter it, so the blocking
@@ -125,15 +127,60 @@ class SessionAttributesStore(context: Context) {
         return synchronized(cacheLock) { state.snapshot() }
     }
 
-    fun saveState(serverUrl: String, state: ServerSessionAttributesState) {
+    /**
+     * Records [names] as sent at [sentAt]. A header built before the network changed
+     * ([generation] is stale) carried the old network values, so those keys stay
+     * unsent and go out again on the next request.
+     */
+    fun markSent(serverUrl: String, names: Collection<String>, sentAt: Long, generation: Long) {
+        val state = cachedState(serverUrl) ?: return
         val json = synchronized(cacheLock) {
-            val stored = state.snapshot()
-            stateCache[serverUrl] = stored
-            stored.toJson().toString()
+            // The server was disabled or removed while the header was being built.
+            if (stateCache[serverUrl] !== state || !state.enabled) {
+                return
+            }
+            val staleNetwork = generation != networkGeneration
+            names.forEach { name ->
+                if (!staleNetwork || name !in SessionAttributesConstants.NETWORK_KEYS) {
+                    state.lastSentAt[name] = sentAt
+                }
+            }
+            state.toJson().toString()
         }
         persist(stateAlias(serverUrl), json)
     }
 
+    fun currentNetworkGeneration(): Long {
+        synchronized(cacheLock) {
+            return networkGeneration
+        }
+    }
+
+    /**
+     * Clears the network attributes' sent time on every enabled server, so the next
+     * request carries the new network values whatever their ttl. Only servers loaded
+     * in this process are covered, which includes every server the app enabled.
+     * Returns the URLs of those servers.
+     */
+    fun resetNetworkFields(): List<String> {
+        val updates = synchronized(cacheLock) {
+            networkGeneration++
+            stateCache.filterValues { it.enabled }.map { (serverUrl, state) ->
+                SessionAttributesConstants.NETWORK_KEYS.forEach { state.lastSentAt.remove(it) }
+                serverUrl to state.toJson().toString()
+            }
+        }
+        updates.forEach { (serverUrl, json) -> persist(stateAlias(serverUrl), json) }
+        return updates.map { it.first }
+    }
+
+    /** Whether any server loaded in this process sends attributes (enabled with a manifest). */
+    fun hasServersSendingAttributes(): Boolean {
+        synchronized(cacheLock) {
+            return stateCache.values.any { it.enabled && it.manifest.isNotEmpty() }
+        }
+    }
+
     fun removeState(serverUrl: String) {
         synchronized(cacheLock) {
             stateCache.remove(serverUrl)

ios/ApiClient/ApiClientEvents.swift

@@ -8,6 +8,8 @@ enum ApiEvents: String, CaseIterable {
     case UPLOAD_PROGRESS = "ApiClient-UploadProgress"
     case DOWNLOAD_PROGRESS = "ApiClient-DownloadProgress"
     case CLIENT_ERROR = "ApiClient-Error"
+    // Matches SessionAttributesConstants.networkChangedNotification.
+    case SESSION_ATTRIBUTES_NETWORK_CHANGED = "ApiClient-SessionAttributesNetworkChanged"
 }
 
 extension ApiClientWrapper {