[Device Manager] Parse user agents (PSG-762)

changelog.d/7247.wip

@@ -0,0 +1 @@
+[Device Manager] Parse user agents

matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/model/DeviceInfo.kt

@@ -52,9 +52,17 @@ data class DeviceInfo(
          * The last ip address.
          */
         @Json(name = "last_seen_ip")
-        val lastSeenIp: String? = null
+        val lastSeenIp: String? = null,
+
+        @Json(name = "org.matrix.msc3852.last_seen_user_agent")
+        val unstableLastSeenUserAgent: String? = null,
+
+        @Json(name = "last_seen_user_agent")
+        val lastSeenUserAgent: String? = null,
 ) : DatedObject {
 
     override val date: Long
         get() = lastSeenTs ?: 0
+
+    fun getBestLastSeenUserAgent() = lastSeenUserAgent ?: unstableLastSeenUserAgent
 }

vector/src/main/java/im/vector/app/features/settings/devices/v2/DeviceFullInfo.kt

@@ -26,4 +26,5 @@ data class DeviceFullInfo(
         val roomEncryptionTrustLevel: RoomEncryptionTrustLevel,
         val isInactive: Boolean,
         val isCurrentDevice: Boolean,
+        val deviceUserAgent: DeviceUserAgent,
 )

vector/src/main/java/im/vector/app/features/settings/devices/v2/DeviceUserAgent.kt

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2022 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.app.features.settings.devices.v2
+
+import im.vector.app.features.settings.devices.v2.list.DeviceType
+
+data class DeviceUserAgent(
+        /**
+         * One of MOBILE, WEB, DESKTOP or UNKNOWN.
+         */
+        val deviceType: DeviceType,
+        /**
+         * i.e. Google Pixel 6.
+         */
+        val deviceModel: String? = null,
+        /**
+         * i.e. Android 11.
+         */
+        val deviceOperatingSystem: String? = null,
+        /**
+         * i.e. Element Nightly.
+         */
+        val clientName: String? = null,
+        /**
+         * i.e. 1.5.0.
+         */
+        val clientVersion: String? = null,
+        /**
+         * i.e. Chrome.
+         */
+        val browser: String? = null,
+)

vector/src/main/java/im/vector/app/features/settings/devices/v2/GetDeviceFullInfoListUseCase.kt

@@ -38,6 +38,7 @@ class GetDeviceFullInfoListUseCase @Inject constructor(
         private val getEncryptionTrustLevelForDeviceUseCase: GetEncryptionTrustLevelForDeviceUseCase,
         private val getCurrentSessionCrossSigningInfoUseCase: GetCurrentSessionCrossSigningInfoUseCase,
         private val filterDevicesUseCase: FilterDevicesUseCase,
+        private val parseDeviceUserAgentUseCase: ParseDeviceUserAgentUseCase,
 ) {
 
     fun execute(filterType: DeviceManagerFilterType, excludeCurrentDevice: Boolean = false): Flow<List<DeviceFullInfo>> {
@@ -72,7 +73,8 @@ class GetDeviceFullInfoListUseCase @Inject constructor(
                     val roomEncryptionTrustLevel = getEncryptionTrustLevelForDeviceUseCase.execute(currentSessionCrossSigningInfo, cryptoDeviceInfo)
                     val isInactive = checkIfSessionIsInactiveUseCase.execute(deviceInfo.lastSeenTs ?: 0)
                     val isCurrentDevice = currentSessionCrossSigningInfo.deviceId == cryptoDeviceInfo?.deviceId
-                    DeviceFullInfo(deviceInfo, cryptoDeviceInfo, roomEncryptionTrustLevel, isInactive, isCurrentDevice)
+                    val deviceUserAgent = parseDeviceUserAgentUseCase.execute(deviceInfo.getBestLastSeenUserAgent())
+                    DeviceFullInfo(deviceInfo, cryptoDeviceInfo, roomEncryptionTrustLevel, isInactive, isCurrentDevice, deviceUserAgent)
                 }
     }
 }

vector/src/main/java/im/vector/app/features/settings/devices/v2/ParseDeviceUserAgentUseCase.kt

@@ -0,0 +1,148 @@
+/*
+ * Copyright (c) 2022 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.app.features.settings.devices.v2
+
+import im.vector.app.features.settings.devices.v2.list.DeviceType
+import org.matrix.android.sdk.api.extensions.orFalse
+import javax.inject.Inject
+
+class ParseDeviceUserAgentUseCase @Inject constructor() {
+
+    fun execute(userAgent: String?): DeviceUserAgent {
+        if (userAgent == null) return createUnknownUserAgent()
+
+        return when {
+            userAgent.contains(ANDROID_KEYWORD) -> parseAndroidUserAgent(userAgent)
+            userAgent.contains(IOS_KEYWORD) -> parseIosUserAgent(userAgent)
+            userAgent.contains(DESKTOP_KEYWORD) -> parseDesktopUserAgent(userAgent)
+            userAgent.contains(WEB_KEYWORD) -> parseWebUserAgent(userAgent)
+            else -> createUnknownUserAgent()
+        }
+    }
+
+    private fun parseAndroidUserAgent(userAgent: String): DeviceUserAgent {
+        val appName = userAgent.substringBefore("/")
+        val appVersion = userAgent.substringAfter("/").substringBefore(" (")
+        val deviceInfoSegments = userAgent.substringAfter("(").substringBeforeLast(")").split("; ")
+        val deviceModel: String?
+        val deviceOperatingSystem: String?
+        if (deviceInfoSegments.firstOrNull() == "Linux") {
+            val deviceOperatingSystemIndex = deviceInfoSegments.indexOfFirst { it.startsWith("Android") }
+            deviceOperatingSystem = deviceInfoSegments.getOrNull(deviceOperatingSystemIndex)
+            deviceModel = deviceInfoSegments.getOrNull(deviceOperatingSystemIndex + 1)
+        } else {
+            deviceModel = deviceInfoSegments.getOrNull(0)
+            deviceOperatingSystem = deviceInfoSegments.getOrNull(1)
+        }
+        return DeviceUserAgent(DeviceType.MOBILE, deviceModel, deviceOperatingSystem, appName, appVersion)
+    }
+
+    private fun parseIosUserAgent(userAgent: String): DeviceUserAgent {
+        val appName = userAgent.substringBefore("/")
+        val appVersion = userAgent.substringAfter("/").substringBefore(" (")
+        val deviceInfoSegments = userAgent.substringAfter("(").substringBeforeLast(")").split("; ")
+        val deviceModel = deviceInfoSegments.getOrNull(0)
+        val deviceOperatingSystem = deviceInfoSegments.getOrNull(1)
+        return DeviceUserAgent(DeviceType.MOBILE, deviceModel, deviceOperatingSystem, appName, appVersion)
+    }
+
+    private fun parseDesktopUserAgent(userAgent: String): DeviceUserAgent {
+        val browserSegments = userAgent.split(" ")
+        val browserName = when {
+            isFirefox(browserSegments) -> {
+                "Firefox"
+            }
+            isEdge(browserSegments) -> {
+                "Edge"
+            }
+            isMobile(browserSegments) -> {
+                getMobileBrowserName(browserSegments)
+            }
+            isSafari(browserSegments) -> {
+                "Safari"
+            }
+            else -> {
+                getRegularBrowserName(browserSegments)
+            }
+        }
+
+        val deviceOperatingSystemSegments = userAgent.substringAfter("(").substringBefore(")").split("; ")
+        val deviceOperatingSystem = if (deviceOperatingSystemSegments.getOrNull(1)?.startsWith("Android").orFalse()) {
+            deviceOperatingSystemSegments.getOrNull(1)
+        } else {
+            deviceOperatingSystemSegments.getOrNull(0)
+        }
+        return DeviceUserAgent(DeviceType.DESKTOP, browserName, deviceOperatingSystem, null, null)
+    }
+
+    private fun parseWebUserAgent(userAgent: String): DeviceUserAgent {
+        return parseDesktopUserAgent(userAgent).copy(
+                deviceType = DeviceType.WEB
+        )
+    }
+
+    private fun createUnknownUserAgent(): DeviceUserAgent {
+        return DeviceUserAgent(DeviceType.UNKNOWN)
+    }
+
+    private fun isFirefox(browserSegments: List<String>): Boolean {
+        return browserSegments.lastOrNull()?.startsWith("Firefox").orFalse()
+    }
+
+    private fun isEdge(browserSegments: List<String>): Boolean {
+        return browserSegments.lastOrNull()?.startsWith("Edge").orFalse()
+    }
+
+    private fun isSafari(browserSegments: List<String>): Boolean {
+        return browserSegments.lastOrNull()?.startsWith("Safari").orFalse() &&
+                browserSegments.getOrNull(browserSegments.size - 2)?.startsWith("Version").orFalse()
+    }
+
+    private fun isMobile(browserSegments: List<String>): Boolean {
+        return browserSegments.lastOrNull()?.startsWith("Safari").orFalse() &&
+                browserSegments.getOrNull(browserSegments.size - 2)?.startsWith("Mobile").orFalse()
+    }
+
+    private fun getMobileBrowserName(browserSegments: List<String>): String? {
+        val possibleBrowserName = browserSegments.getOrNull(browserSegments.size - 3)?.split("/")?.firstOrNull()
+        return if (possibleBrowserName == "Version") {
+            "Safari"
+        } else {
+            possibleBrowserName
+        }
+    }
+
+    private fun getRegularBrowserName(browserSegments: List<String>): String? {
+        return browserSegments.getOrNull(browserSegments.size - 2)?.split("/")?.firstOrNull()
+    }
+
+    companion object {
+        // Element dbg/1.5.0-dev (Xiaomi; Mi 9T; Android 11; RKQ1.200826.002 test-keys; Flavour GooglePlay; MatrixAndroidSdk2 1.5.0)
+        // Legacy : Element/1.0.0 (Linux; U; Android 6.0.1; SM-A510F Build/MMB29; Flavour GPlay; MatrixAndroidSdk2 1.0)
+        private const val ANDROID_KEYWORD = "; MatrixAndroidSdk2"
+
+        // Element/1.8.21 (iPhone XS Max; iOS 15.2; Scale/3.00)
+        private const val IOS_KEYWORD = "; iOS "
+
+        // Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) ElementNightly/2022091301
+        // Chrome/104.0.5112.102 Electron/20.1.1 Safari/537.36
+        private const val DESKTOP_KEYWORD = " Electron/"
+
+        // Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/105.0.0.0 Safari/537.36
+        private const val WEB_KEYWORD = "Mozilla/"
+    }
+}

vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/GetDeviceFullInfoUseCase.kt

@@ -19,6 +19,7 @@ package im.vector.app.features.settings.devices.v2.overview
 import androidx.lifecycle.asFlow
 import im.vector.app.core.di.ActiveSessionHolder
 import im.vector.app.features.settings.devices.v2.DeviceFullInfo
+import im.vector.app.features.settings.devices.v2.ParseDeviceUserAgentUseCase
 import im.vector.app.features.settings.devices.v2.list.CheckIfSessionIsInactiveUseCase
 import im.vector.app.features.settings.devices.v2.verification.GetCurrentSessionCrossSigningInfoUseCase
 import im.vector.app.features.settings.devices.v2.verification.GetEncryptionTrustLevelForDeviceUseCase
@@ -34,6 +35,7 @@ class GetDeviceFullInfoUseCase @Inject constructor(
         private val getCurrentSessionCrossSigningInfoUseCase: GetCurrentSessionCrossSigningInfoUseCase,
         private val getEncryptionTrustLevelForDeviceUseCase: GetEncryptionTrustLevelForDeviceUseCase,
         private val checkIfSessionIsInactiveUseCase: CheckIfSessionIsInactiveUseCase,
+        private val parseDeviceUserAgentUseCase: ParseDeviceUserAgentUseCase,
 ) {
 
     fun execute(deviceId: String): Flow<DeviceFullInfo> {
@@ -49,12 +51,14 @@ class GetDeviceFullInfoUseCase @Inject constructor(
                     val roomEncryptionTrustLevel = getEncryptionTrustLevelForDeviceUseCase.execute(currentSessionCrossSigningInfo, cryptoInfo)
                     val isInactive = checkIfSessionIsInactiveUseCase.execute(info.lastSeenTs ?: 0)
                     val isCurrentDevice = currentSessionCrossSigningInfo.deviceId == cryptoInfo.deviceId
+                    val deviceUserAgent = parseDeviceUserAgentUseCase.execute(info.getBestLastSeenUserAgent())
                     DeviceFullInfo(
                             deviceInfo = info,
                             cryptoDeviceInfo = cryptoInfo,
                             roomEncryptionTrustLevel = roomEncryptionTrustLevel,
                             isInactive = isInactive,
                             isCurrentDevice = isCurrentDevice,
+                            deviceUserAgent = deviceUserAgent,
                     )
                 } else {
                     null

vector/src/test/java/im/vector/app/features/settings/devices/v2/DevicesViewModelTest.kt

@@ -19,6 +19,7 @@ package im.vector.app.features.settings.devices.v2
 import android.os.SystemClock
 import com.airbnb.mvrx.Success
 import com.airbnb.mvrx.test.MvRxTestRule
+import im.vector.app.features.settings.devices.v2.list.DeviceType
 import im.vector.app.features.settings.devices.v2.verification.CheckIfCurrentSessionCanBeVerifiedUseCase
 import im.vector.app.features.settings.devices.v2.verification.CurrentSessionCrossSigningInfo
 import im.vector.app.features.settings.devices.v2.verification.GetCurrentSessionCrossSigningInfoUseCase
@@ -242,14 +243,16 @@ class DevicesViewModelTest {
                 cryptoDeviceInfo = verifiedCryptoDeviceInfo,
                 roomEncryptionTrustLevel = RoomEncryptionTrustLevel.Trusted,
                 isInactive = false,
-                isCurrentDevice = true
+                isCurrentDevice = true,
+                deviceUserAgent = DeviceUserAgent(DeviceType.MOBILE)
         )
         val deviceFullInfo2 = DeviceFullInfo(
                 deviceInfo = mockk(),
                 cryptoDeviceInfo = unverifiedCryptoDeviceInfo,
                 roomEncryptionTrustLevel = RoomEncryptionTrustLevel.Warning,
                 isInactive = true,
-                isCurrentDevice = false
+                isCurrentDevice = false,
+                deviceUserAgent = DeviceUserAgent(DeviceType.MOBILE)
         )
         val deviceFullInfoList = listOf(deviceFullInfo1, deviceFullInfo2)
         val deviceFullInfoListFlow = flowOf(deviceFullInfoList)