feat: Add telephony and font profile collection

Add two new device fingerprinting signals:

1. Telephony Context (TelephonyCollector):
   - Network operator name
   - SIM state
   - Phone type (GSM/CDMA/etc)
   - ICC card presence

2. Font Profile (FontCollector):
   - Tests for presence of standard Android fonts
   - Tests for manufacturer-specific fonts (Samsung, HTC, Sony, LG, Xiaomi, OnePlus)
   - Helps identify device manufacturers and custom ROMs

These signals were identified as missing from the original implementation plan
and provide additional device fingerprinting capabilities.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: oschwald

device-sdk/src/main/java/com/maxmind/device/collector/DeviceDataCollector.kt

@@ -44,6 +44,8 @@ internal class DeviceDataCollector(
     private val networkCollector = NetworkCollector(context)
     private val settingsCollector = SettingsCollector(context)
     private val behaviorCollector = BehaviorCollector(context)
+    private val telephonyCollector = TelephonyCollector(context)
+    private val fontCollector = FontCollector()
     private val webViewCollector = WebViewCollector(context)
 
     /**
@@ -68,6 +70,8 @@ internal class DeviceDataCollector(
             installation = collectInstallationInfo(),
             settings = settingsCollector.collect(),
             behavior = behaviorCollector.collect(),
+            telephony = telephonyCollector.collect(),
+            fonts = fontCollector.collect(),
             locale = collectLocaleInfo(),
             // Timezone offset in minutes
             timezoneOffset = TimeZone.getDefault().rawOffset / 60000,

device-sdk/src/main/java/com/maxmind/device/collector/FontCollector.kt

@@ -0,0 +1,64 @@
+package com.maxmind.device.collector
+
+import android.graphics.Typeface
+import com.maxmind.device.model.FontInfo
+
+/**
+ * Collects font profile information.
+ *
+ * Tests for the presence of various system fonts which can help identify
+ * device manufacturers and custom ROMs.
+ */
+internal class FontCollector {
+    /**
+     * Collects font availability information.
+     *
+     * @return [FontInfo] containing list of available fonts
+     */
+    fun collect(): FontInfo {
+        val defaultTypeface = Typeface.DEFAULT
+
+        val availableFonts =
+            TEST_FONTS.filter { fontFamily ->
+                val typeface = Typeface.create(fontFamily, Typeface.NORMAL)
+                // A font is considered "available" if it doesn't fall back to default
+                // Roboto is always available as it's the Android default
+                typeface != defaultTypeface || fontFamily == ROBOTO_FONT
+            }
+
+        return FontInfo(availableFonts = availableFonts)
+    }
+
+    internal companion object {
+        const val ROBOTO_FONT = "Roboto"
+
+        // Common system fonts and manufacturer-specific fonts
+        val TEST_FONTS =
+            listOf(
+                // Standard Android fonts
+                ROBOTO_FONT,
+                "Noto Sans",
+                "Droid Sans",
+                "Droid Serif",
+                "Droid Sans Mono",
+                // Samsung fonts
+                "Samsung Sans",
+                "SamsungOne",
+                // HTC fonts
+                "HTC Sense",
+                // Sony fonts
+                "Sony Sketch",
+                "Sony Mobile UD Gothic",
+                // LG fonts
+                "LG Smart",
+                // Xiaomi fonts
+                "MIUI",
+                "MiSans",
+                // OnePlus fonts
+                "OnePlus Slate",
+                // Google fonts that may be present
+                "Google Sans",
+                "Product Sans",
+            )
+    }
+}

device-sdk/src/main/java/com/maxmind/device/collector/TelephonyCollector.kt

@@ -0,0 +1,36 @@
+package com.maxmind.device.collector
+
+import android.content.Context
+import android.telephony.TelephonyManager
+import com.maxmind.device.model.TelephonyInfo
+
+/**
+ * Collects telephony context information.
+ *
+ * Collects basic telephony information that doesn't require runtime permissions.
+ */
+internal class TelephonyCollector(private val context: Context) {
+    /**
+     * Collects current telephony information.
+     *
+     * @return [TelephonyInfo] containing telephony context, or null if unavailable
+     */
+    @Suppress("SwallowedException")
+    fun collect(): TelephonyInfo? {
+        return try {
+            val telephonyManager =
+                context.getSystemService(Context.TELEPHONY_SERVICE) as? TelephonyManager
+                    ?: return null
+
+            TelephonyInfo(
+                networkOperatorName = telephonyManager.networkOperatorName?.takeIf { it.isNotBlank() },
+                simState = telephonyManager.simState,
+                phoneType = telephonyManager.phoneType,
+                hasIccCard = telephonyManager.hasIccCard(),
+            )
+        } catch (e: Exception) {
+            // Telephony info may fail on some devices
+            null
+        }
+    }
+}

device-sdk/src/main/java/com/maxmind/device/model/DeviceData.kt

@@ -34,6 +34,8 @@ public data class DeviceData(
     val installation: InstallationInfo,
     val settings: SystemSettings = SystemSettings(),
     val behavior: BehaviorInfo = BehaviorInfo(),
+    val telephony: TelephonyInfo? = null,
+    val fonts: FontInfo? = null,
     // Context
     val locale: LocaleInfo,
     @SerialName("timezone_offset")

device-sdk/src/main/java/com/maxmind/device/model/FontInfo.kt

@@ -0,0 +1,13 @@
+package com.maxmind.device.model
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+/**
+ * Font profile information based on available system fonts.
+ */
+@Serializable
+public data class FontInfo(
+    @SerialName("available_fonts")
+    val availableFonts: List<String> = emptyList(),
+)

device-sdk/src/main/java/com/maxmind/device/model/TelephonyInfo.kt

@@ -0,0 +1,19 @@
+package com.maxmind.device.model
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+/**
+ * Telephony context information from TelephonyManager.
+ */
+@Serializable
+public data class TelephonyInfo(
+    @SerialName("network_operator_name")
+    val networkOperatorName: String? = null,
+    @SerialName("sim_state")
+    val simState: Int? = null,
+    @SerialName("phone_type")
+    val phoneType: Int? = null,
+    @SerialName("has_icc_card")
+    val hasIccCard: Boolean? = null,
+)

device-sdk/src/test/java/com/maxmind/device/collector/FontCollectorTest.kt

@@ -0,0 +1,42 @@
+package com.maxmind.device.collector
+
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.Test
+
+/**
+ * Tests for FontCollector.
+ *
+ * Note: Tests that require actual font detection (Typeface.create()) must run
+ * in instrumented tests since Android framework classes cannot be mocked in unit tests.
+ */
+internal class FontCollectorTest {
+    @Test
+    internal fun `TEST_FONTS contains expected font families`() {
+        val fonts = FontCollector.TEST_FONTS
+
+        // Should contain standard Android fonts
+        assertTrue(fonts.contains("Roboto"))
+        assertTrue(fonts.contains("Noto Sans"))
+        assertTrue(fonts.contains("Droid Sans"))
+
+        // Should contain manufacturer-specific fonts
+        assertTrue(fonts.contains("Samsung Sans"))
+        assertTrue(fonts.contains("OnePlus Slate"))
+        assertTrue(fonts.contains("MIUI"))
+    }
+
+    @Test
+    internal fun `TEST_FONTS is not empty`() {
+        assertTrue(FontCollector.TEST_FONTS.isNotEmpty())
+    }
+
+    @Test
+    internal fun `ROBOTO_FONT constant is Roboto`() {
+        assertTrue(FontCollector.ROBOTO_FONT == "Roboto")
+    }
+
+    @Test
+    internal fun `TEST_FONTS contains ROBOTO_FONT`() {
+        assertTrue(FontCollector.TEST_FONTS.contains(FontCollector.ROBOTO_FONT))
+    }
+}

device-sdk/src/test/java/com/maxmind/device/collector/TelephonyCollectorTest.kt

@@ -0,0 +1,92 @@
+package com.maxmind.device.collector
+
+import android.content.Context
+import android.telephony.TelephonyManager
+import io.mockk.every
+import io.mockk.mockk
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertNotNull
+import org.junit.jupiter.api.Assertions.assertNull
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+
+internal class TelephonyCollectorTest {
+    private lateinit var mockContext: Context
+    private lateinit var mockTelephonyManager: TelephonyManager
+    private lateinit var collector: TelephonyCollector
+
+    @BeforeEach
+    internal fun setUp() {
+        mockContext = mockk(relaxed = true)
+        mockTelephonyManager = mockk(relaxed = true)
+
+        every { mockContext.getSystemService(Context.TELEPHONY_SERVICE) } returns mockTelephonyManager
+
+        collector = TelephonyCollector(mockContext)
+    }
+
+    @Test
+    internal fun `collect returns telephony info with carrier name`() {
+        every { mockTelephonyManager.networkOperatorName } returns "Test Carrier"
+        every { mockTelephonyManager.simState } returns TelephonyManager.SIM_STATE_READY
+        every { mockTelephonyManager.phoneType } returns TelephonyManager.PHONE_TYPE_GSM
+        every { mockTelephonyManager.hasIccCard() } returns true
+
+        val result = collector.collect()
+
+        assertNotNull(result)
+        assertEquals("Test Carrier", result?.networkOperatorName)
+        assertEquals(TelephonyManager.SIM_STATE_READY, result?.simState)
+        assertEquals(TelephonyManager.PHONE_TYPE_GSM, result?.phoneType)
+        assertTrue(result?.hasIccCard == true)
+    }
+
+    @Test
+    internal fun `collect returns null network operator name for blank string`() {
+        every { mockTelephonyManager.networkOperatorName } returns "   "
+        every { mockTelephonyManager.simState } returns TelephonyManager.SIM_STATE_ABSENT
+        every { mockTelephonyManager.phoneType } returns TelephonyManager.PHONE_TYPE_NONE
+        every { mockTelephonyManager.hasIccCard() } returns false
+
+        val result = collector.collect()
+
+        assertNotNull(result)
+        assertNull(result?.networkOperatorName)
+        assertEquals(TelephonyManager.SIM_STATE_ABSENT, result?.simState)
+        assertEquals(TelephonyManager.PHONE_TYPE_NONE, result?.phoneType)
+        assertEquals(false, result?.hasIccCard)
+    }
+
+    @Test
+    internal fun `collect returns null when TelephonyManager unavailable`() {
+        every { mockContext.getSystemService(Context.TELEPHONY_SERVICE) } returns null
+        val collectorWithNoTelephony = TelephonyCollector(mockContext)
+
+        val result = collectorWithNoTelephony.collect()
+
+        assertNull(result)
+    }
+
+    @Test
+    internal fun `collect handles exception gracefully`() {
+        every { mockTelephonyManager.networkOperatorName } throws RuntimeException("Test exception")
+
+        val result = collector.collect()
+
+        assertNull(result)
+    }
+
+    @Test
+    internal fun `collect returns CDMA phone type`() {
+        every { mockTelephonyManager.networkOperatorName } returns "CDMA Carrier"
+        every { mockTelephonyManager.simState } returns TelephonyManager.SIM_STATE_READY
+        every { mockTelephonyManager.phoneType } returns TelephonyManager.PHONE_TYPE_CDMA
+        every { mockTelephonyManager.hasIccCard() } returns true
+
+        val result = collector.collect()
+
+        assertNotNull(result)
+        assertEquals(TelephonyManager.PHONE_TYPE_CDMA, result?.phoneType)
+    }
+}