catalyst-core 0.1.0-canary.2 → 0.1.0-canary.3

package/dist/native/androidProject/app/build.gradle.kts

@@ -114,12 +114,12 @@ android {
     }
 
     compileOptions {
-        sourceCompatibility = JavaVersion.VERSION_1_8
-        targetCompatibility = JavaVersion.VERSION_1_8
+        sourceCompatibility = JavaVersion.VERSION_11
+        targetCompatibility = JavaVersion.VERSION_11
     }
 
     kotlinOptions {
-        jvmTarget = "1.8"
+        jvmTarget = "11"
     }
 
     buildFeatures {
@@ -136,6 +136,10 @@ android {
             excludes.add("META-INF/INDEX.LIST")
             excludes.add("META-INF/io.netty.versions.properties")
         }
+        jniLibs {
+            // Enable 16KB page size alignment for all native libraries
+            useLegacyPackaging = false
+        }
     }
 
     // Configure lint options
@@ -168,13 +172,17 @@ dependencies {
     androidTestImplementation(libs.androidx.espresso.core)
     implementation(libs.androidx.webkit)
     implementation("org.json:json:20231013")
-    
+
     // Ktor Server dependencies for FrameworkServer (~200KB total)
     implementation("io.ktor:ktor-server-core:3.0.3")
     implementation("io.ktor:ktor-server-netty:3.0.3")
     implementation("io.ktor:ktor-server-content-negotiation:3.0.3")
     implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3")
 
+    // Security detection dependencies
+    implementation("com.scottyab:rootbeer-lib:0.1.1")  // Root detection
+    implementation("com.google.android.play:integrity:1.3.0")  // Play Integrity API
+
     // SLF4J simple logger for Ktor (optional, can be excluded if needed)
     implementation("org.slf4j:slf4j-simple:2.0.9")
 

package/dist/native/androidProject/app/proguard-rules.pro

@@ -59,6 +59,31 @@
 -keep class io.yourname.androidproject.WebCacheManager$CacheEntry { *; }
 -keep class io.yourname.androidproject.WebCacheManager$CacheMetadata { *; }
 
+# Keep RootBeer library for root detection
+-keep class com.scottyab.rootbeer.** { *; }
+-dontwarn com.scottyab.rootbeer.**
+
+# Security: keep only the public API surface that MainActivity wires up.
+# Detection internals (EmulatorDetector, FridaDetector) and UI classes
+# (SecurityBottomSheet, SecurityAlertUI) are intentionally obfuscated.
+-keep class io.yourname.androidproject.security.SecurityCheckScheduler {
+    public static void initialize(android.content.Context, kotlinx.coroutines.CoroutineScope, io.yourname.androidproject.security.SecurityCheckScheduler$SecurityCheckCallback);
+}
+-keep interface io.yourname.androidproject.security.SecurityCheckScheduler$SecurityCheckCallback {
+    public void onSecurityCheckComplete(org.json.JSONObject);
+}
+-keep class io.yourname.androidproject.security.SecurityCheckManager {
+    public static org.json.JSONObject getLatestSecurityResults(android.content.Context);
+    public static java.lang.String getSecurityMode(android.content.Context);
+}
+-keep class io.yourname.androidproject.security.SecurityAlertHandler {
+    public static void handleSecurityCheckResults(android.app.Activity, org.json.JSONObject);
+}
+
+# Keep Play Integrity API
+-keep class com.google.android.play.core.integrity.** { *; }
+-dontwarn com.google.android.play.core.integrity.**
+
 # Remove debug logging in release builds
 -assumenosideeffects class android.util.Log {
     public static *** d(...);

package/dist/native/androidProject/app/src/main/java/io/yourname/androidproject/MainActivity.kt

@@ -20,6 +20,7 @@ import io.yourname.androidproject.utils.NetworkUtils
 import io.yourname.androidproject.utils.NotificationConstants
 import io.yourname.androidproject.utils.SafeAreaInsets
 import io.yourname.androidproject.utils.SafeAreaUtils
+import io.yourname.androidproject.security.SecurityCheckScheduler
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.MainScope
 import kotlinx.coroutines.cancelChildren
@@ -253,6 +254,15 @@ class MainActivity : AppCompatActivity(), CoroutineScope by MainScope() {
 
         configureEdgeToEdge()
 
+        // Initialize security checks (release builds only)
+        if (!BuildConfig.DEBUG) {
+            SecurityCheckScheduler.initialize(this, this, object : SecurityCheckScheduler.SecurityCheckCallback {
+                override fun onSecurityCheckComplete(results: JSONObject) {
+                    io.yourname.androidproject.security.SecurityAlertHandler.handleSecurityCheckResults(this@MainActivity, results)
+                }
+            })
+        }
+
         // Initialize MetricsMonitor
         metricsMonitor = MetricsMonitor.getInstance(this)
 

package/dist/native/androidProject/app/src/main/java/io/yourname/androidproject/design/DesignTokens.kt

@@ -0,0 +1,307 @@
+package io.yourname.androidproject.design
+
+import android.content.Context
+import android.content.res.Configuration
+import androidx.annotation.ColorInt
+
+/**
+ * Global design tokens for the application.
+ * Follows Material Design 3 principles with support for light/dark themes.
+ *
+ * All spacing follows 8dp grid system.
+ * Color system supports dynamic theming based on system configuration.
+ */
+object DesignTokens {
+
+    // ============================================================
+    // COLORS - Light Theme
+    // ============================================================
+    object LightColors {
+        // Surface colors
+        @ColorInt const val SURFACE = 0xFFFFFFFF.toInt()           // Pure white
+        @ColorInt const val SURFACE_VARIANT = 0xFFF5F5F5.toInt()   // Light gray background
+
+        // Error colors (for alerts, warnings)
+        @ColorInt const val ERROR = 0xFFB3261E.toInt()             // Material error red
+        @ColorInt const val ERROR_CONTAINER = 0xFFF9DEDC.toInt()   // Light red background
+        @ColorInt const val ON_ERROR = 0xFFFFFFFF.toInt()          // White text on error
+        @ColorInt const val ON_ERROR_CONTAINER = 0xFF410E0B.toInt() // Dark red text
+
+        // Text colors
+        @ColorInt const val ON_SURFACE = 0xFF1C1B1F.toInt()        // Primary text (near black)
+        @ColorInt const val ON_SURFACE_VARIANT = 0xFF49454F.toInt() // Secondary text (gray)
+        @ColorInt const val OUTLINE = 0xFF79747E.toInt()           // Dividers, borders
+
+        // Accent colors
+        @ColorInt const val PRIMARY = 0xFF6750A4.toInt()           // Material purple
+        @ColorInt const val ON_PRIMARY = 0xFFFFFFFF.toInt()        // White text on primary
+        @ColorInt const val PRIMARY_CONTAINER = 0xFFEADDFF.toInt() // Light purple background
+        @ColorInt const val ON_PRIMARY_CONTAINER = 0xFF21005D.toInt() // Dark purple text
+
+        // Secondary colors
+        @ColorInt const val SECONDARY = 0xFF625B71.toInt()         // Material gray-purple
+        @ColorInt const val ON_SECONDARY = 0xFFFFFFFF.toInt()      // White text on secondary
+        @ColorInt const val SECONDARY_CONTAINER = 0xFFE8DEF8.toInt() // Light secondary background
+        @ColorInt const val ON_SECONDARY_CONTAINER = 0xFF1D192B.toInt() // Dark text
+    }
+
+    // ============================================================
+    // COLORS - Dark Theme
+    // ============================================================
+    object DarkColors {
+        // Surface colors
+        @ColorInt const val SURFACE = 0xFF1C1B1F.toInt()           // Dark surface
+        @ColorInt const val SURFACE_VARIANT = 0xFF2B2930.toInt()   // Darker variant
+
+        // Error colors (for alerts, warnings)
+        @ColorInt const val ERROR = 0xFFF2B8B5.toInt()             // Light red for dark mode
+        @ColorInt const val ERROR_CONTAINER = 0xFF8C1D18.toInt()   // Dark red background
+        @ColorInt const val ON_ERROR = 0xFF601410.toInt()          // Dark text on light error
+        @ColorInt const val ON_ERROR_CONTAINER = 0xFFF2B8B5.toInt() // Light text on dark error
+
+        // Text colors
+        @ColorInt const val ON_SURFACE = 0xFFE6E1E5.toInt()        // Light text
+        @ColorInt const val ON_SURFACE_VARIANT = 0xFFCAC4D0.toInt() // Secondary light text
+        @ColorInt const val OUTLINE = 0xFF938F99.toInt()           // Light dividers, borders
+
+        // Accent colors
+        @ColorInt const val PRIMARY = 0xFFD0BCFF.toInt()           // Light purple for dark mode
+        @ColorInt const val ON_PRIMARY = 0xFF381E72.toInt()        // Dark text on light primary
+        @ColorInt const val PRIMARY_CONTAINER = 0xFF4F378B.toInt() // Dark purple background
+        @ColorInt const val ON_PRIMARY_CONTAINER = 0xFFEADDFF.toInt() // Light text
+
+        // Secondary colors
+        @ColorInt const val SECONDARY = 0xFFCCC2DC.toInt()         // Light gray-purple for dark
+        @ColorInt const val ON_SECONDARY = 0xFF332D41.toInt()      // Dark text on light secondary
+        @ColorInt const val SECONDARY_CONTAINER = 0xFF4A4458.toInt() // Dark secondary background
+        @ColorInt const val ON_SECONDARY_CONTAINER = 0xFFE8DEF8.toInt() // Light text
+    }
+
+    // ============================================================
+    // SPACING - Following 8dp Grid System
+    // ============================================================
+    object Spacing {
+        const val SPACE_XXS = 4   // 4dp - Minimal spacing
+        const val SPACE_XS = 8    // 8dp - Tight spacing
+        const val SPACE_SM = 12   // 12dp - Small spacing
+        const val SPACE_MD = 16   // 16dp - Medium spacing (default)
+        const val SPACE_LG = 24   // 24dp - Large spacing
+        const val SPACE_XL = 32   // 32dp - Extra large spacing
+        const val SPACE_XXL = 48  // 48dp - Maximum spacing
+    }
+
+    // ============================================================
+    // DIMENSIONS
+    // ============================================================
+    object Dimensions {
+        // Corner radius
+        const val CORNER_RADIUS_SM = 8   // Small corners (buttons, chips)
+        const val CORNER_RADIUS_MD = 16  // Medium corners (cards)
+        const val CORNER_RADIUS_LG = 24  // Large corners (bottom sheet top)
+        const val CORNER_RADIUS_XL = 28  // Extra large (full rounded)
+
+        // Icon sizes
+        const val ICON_SIZE_SM = 24      // Small icons
+        const val ICON_SIZE_MD = 48      // Medium icons
+        const val ICON_SIZE_LG = 64      // Large icons (hero icon)
+        const val ICON_SIZE_XL = 96      // Extra large icons
+
+        // Minimum touch target (Material Design)
+        const val MIN_TOUCH_TARGET = 48  // 48dp minimum for accessibility
+
+        // Elevation (for shadows/depth)
+        const val ELEVATION_NONE = 0f
+        const val ELEVATION_SM = 2f      // Small elevation
+        const val ELEVATION_MD = 4f      // Medium elevation
+        const val ELEVATION_LG = 8f      // Large elevation
+    }
+
+    // ============================================================
+    // TYPOGRAPHY
+    // ============================================================
+    object Typography {
+        // Text sizes (SP - scalable pixels)
+        const val TEXT_SIZE_DISPLAY = 32f    // Large headlines
+        const val TEXT_SIZE_HEADLINE = 24f   // Section headlines
+        const val TEXT_SIZE_TITLE = 20f      // Card titles
+        const val TEXT_SIZE_BODY_LG = 16f    // Large body text
+        const val TEXT_SIZE_BODY = 14f       // Default body text
+        const val TEXT_SIZE_LABEL = 12f      // Small labels, captions
+
+        // Line height multipliers
+        const val LINE_HEIGHT_TIGHT = 1.2f   // Tight line height
+        const val LINE_HEIGHT_NORMAL = 1.5f  // Normal line height
+        const val LINE_HEIGHT_RELAXED = 1.7f // Relaxed line height
+
+        // Font weights (Android Typeface)
+        const val FONT_WEIGHT_NORMAL = android.graphics.Typeface.NORMAL
+        const val FONT_WEIGHT_BOLD = android.graphics.Typeface.BOLD
+    }
+
+    // ============================================================
+    // ANIMATION DURATIONS (milliseconds)
+    // ============================================================
+    object Animation {
+        const val DURATION_SHORT = 200L      // Quick transitions
+        const val DURATION_MEDIUM = 300L     // Standard transitions
+        const val DURATION_LONG = 500L       // Emphasized transitions
+        const val DURATION_EXTRA_LONG = 700L // Hero transitions
+    }
+
+    // ============================================================
+    // OPACITY/ALPHA VALUES
+    // ============================================================
+    object Opacity {
+        const val DISABLED = 0.38f           // Disabled state
+        const val MEDIUM = 0.60f             // Medium emphasis
+        const val HIGH = 0.87f               // High emphasis
+        const val FULL = 1.0f                // Full opacity
+    }
+
+    // ============================================================
+    // HELPER FUNCTIONS
+    // ============================================================
+
+    /**
+     * Check if the device is in dark mode.
+     *
+     * @param context Android context
+     * @return true if dark mode is enabled
+     */
+    fun isDarkMode(context: Context): Boolean {
+        val nightModeFlags = context.resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK
+        return nightModeFlags == Configuration.UI_MODE_NIGHT_YES
+    }
+
+    /**
+     * Get surface color based on current theme.
+     */
+    @ColorInt
+    fun getSurfaceColor(context: Context): Int {
+        return if (isDarkMode(context)) DarkColors.SURFACE else LightColors.SURFACE
+    }
+
+    /**
+     * Get surface variant color based on current theme.
+     */
+    @ColorInt
+    fun getSurfaceVariantColor(context: Context): Int {
+        return if (isDarkMode(context)) DarkColors.SURFACE_VARIANT else LightColors.SURFACE_VARIANT
+    }
+
+    /**
+     * Get error color based on current theme.
+     */
+    @ColorInt
+    fun getErrorColor(context: Context): Int {
+        return if (isDarkMode(context)) DarkColors.ERROR else LightColors.ERROR
+    }
+
+    /**
+     * Get error container color based on current theme.
+     */
+    @ColorInt
+    fun getErrorContainerColor(context: Context): Int {
+        return if (isDarkMode(context)) DarkColors.ERROR_CONTAINER else LightColors.ERROR_CONTAINER
+    }
+
+    /**
+     * Get on-error color (text on error background) based on current theme.
+     */
+    @ColorInt
+    fun getOnErrorColor(context: Context): Int {
+        return if (isDarkMode(context)) DarkColors.ON_ERROR else LightColors.ON_ERROR
+    }
+
+    /**
+     * Get on-error-container color based on current theme.
+     */
+    @ColorInt
+    fun getOnErrorContainerColor(context: Context): Int {
+        return if (isDarkMode(context)) DarkColors.ON_ERROR_CONTAINER else LightColors.ON_ERROR_CONTAINER
+    }
+
+    /**
+     * Get primary text color based on current theme.
+     */
+    @ColorInt
+    fun getOnSurfaceColor(context: Context): Int {
+        return if (isDarkMode(context)) DarkColors.ON_SURFACE else LightColors.ON_SURFACE
+    }
+
+    /**
+     * Get secondary text color based on current theme.
+     */
+    @ColorInt
+    fun getOnSurfaceVariantColor(context: Context): Int {
+        return if (isDarkMode(context)) DarkColors.ON_SURFACE_VARIANT else LightColors.ON_SURFACE_VARIANT
+    }
+
+    /**
+     * Get outline color (dividers, borders) based on current theme.
+     */
+    @ColorInt
+    fun getOutlineColor(context: Context): Int {
+        return if (isDarkMode(context)) DarkColors.OUTLINE else LightColors.OUTLINE
+    }
+
+    /**
+     * Get primary color based on current theme.
+     */
+    @ColorInt
+    fun getPrimaryColor(context: Context): Int {
+        return if (isDarkMode(context)) DarkColors.PRIMARY else LightColors.PRIMARY
+    }
+
+    /**
+     * Get on-primary color (text on primary background) based on current theme.
+     */
+    @ColorInt
+    fun getOnPrimaryColor(context: Context): Int {
+        return if (isDarkMode(context)) DarkColors.ON_PRIMARY else LightColors.ON_PRIMARY
+    }
+
+    /**
+     * Get primary container color based on current theme.
+     */
+    @ColorInt
+    fun getPrimaryContainerColor(context: Context): Int {
+        return if (isDarkMode(context)) DarkColors.PRIMARY_CONTAINER else LightColors.PRIMARY_CONTAINER
+    }
+
+    /**
+     * Get on-primary-container color based on current theme.
+     */
+    @ColorInt
+    fun getOnPrimaryContainerColor(context: Context): Int {
+        return if (isDarkMode(context)) DarkColors.ON_PRIMARY_CONTAINER else LightColors.ON_PRIMARY_CONTAINER
+    }
+
+    /**
+     * Get secondary color based on current theme.
+     */
+    @ColorInt
+    fun getSecondaryColor(context: Context): Int {
+        return if (isDarkMode(context)) DarkColors.SECONDARY else LightColors.SECONDARY
+    }
+
+    /**
+     * Get on-secondary color based on current theme.
+     */
+    @ColorInt
+    fun getOnSecondaryColor(context: Context): Int {
+        return if (isDarkMode(context)) DarkColors.ON_SECONDARY else LightColors.ON_SECONDARY
+    }
+
+    /**
+     * Convert DP to pixels.
+     *
+     * @param context Android context
+     * @param dp Value in density-independent pixels
+     * @return Value in pixels
+     */
+    fun dpToPx(context: Context, dp: Int): Int {
+        return (dp * context.resources.displayMetrics.density).toInt()
+    }
+
+}

package/dist/native/androidProject/app/src/main/java/io/yourname/androidproject/security/EmulatorDetector.kt

@@ -0,0 +1,203 @@
+package io.yourname.androidproject.security
+
+import android.content.Context
+import android.hardware.Sensor
+import android.hardware.SensorManager
+import android.os.Build
+import io.yourname.androidproject.utils.BridgeUtils
+
+/**
+ * Local emulator detection based on Build properties and hardware features.
+ * No external telemetry or logging to third parties.
+ */
+object EmulatorDetector {
+    private const val TAG = "EmulatorDetector"
+
+    // Known emulator indicators
+    private val EMULATOR_PROPERTIES = setOf(
+        "sdk", "google_sdk", "sdk_gphone", "sdk_google",
+        "vbox", "goldfish", "ranchu", "generic"
+    )
+
+    // Whitelist: Known legitimate patterns that contain 'sdk' but are NOT emulators
+    // These are excluded from emulator detection to prevent false positives
+    private val LEGITIMATE_SDK_PATTERNS = setOf(
+        "mt", "mediatek", "helio", "qcom", "qualcomm", "snapdragon"
+    )
+
+    private val SUSPICIOUS_MANUFACTURERS = setOf(
+        "Genymotion", "unknown", "Generic"
+    )
+
+    private val SUSPICIOUS_MODELS = setOf(
+        "sdk", "google_sdk", "Android SDK built for x86",
+        "Android SDK built for arm", "Emulator"
+    )
+
+    /**
+     * Performs multiple checks to detect if running on an emulator.
+     * Returns true if device shows emulator characteristics.
+     */
+    fun isEmulator(context: Context): Boolean {
+        try {
+            val buildCheck = checkBuildProperties()
+            val hardwareCheck = checkHardwareFeatures(context)
+            val fingerprintCheck = checkFingerprint()
+
+            val checks = mapOf("Build" to buildCheck, "Hardware" to hardwareCheck, "Fingerprint" to fingerprintCheck)
+            val isEmulator = checks.values.any { it }
+
+            val fired = checks.filter { it.value }.keys
+            BridgeUtils.logDebug(TAG, "Emulator check results: $checks — fired: $fired")
+            BridgeUtils.logDebug(TAG, "Build info: FINGERPRINT=${Build.FINGERPRINT}, MODEL=${Build.MODEL}, MANUFACTURER=${Build.MANUFACTURER}, HARDWARE=${Build.HARDWARE}, DEVICE=${Build.DEVICE}, PRODUCT=${Build.PRODUCT}")
+
+            if (isEmulator) {
+                BridgeUtils.logDebug(TAG, "EMULATOR DETECTED: $fired")
+            }
+
+            return isEmulator
+        } catch (e: Exception) {
+            BridgeUtils.logError(TAG, "Error during emulator detection: ${e.message}", e)
+            return false
+        }
+    }
+
+    /**
+     * Check Build properties for emulator indicators
+     */
+    private fun checkBuildProperties(): Boolean {
+        val fingerprint = Build.FINGERPRINT.lowercase()
+        val model = Build.MODEL.lowercase()
+        val manufacturer = Build.MANUFACTURER.lowercase()
+        val brand = Build.BRAND.lowercase()
+        val device = Build.DEVICE.lowercase()
+        val product = Build.PRODUCT.lowercase()
+        val hardware = Build.HARDWARE.lowercase()
+
+        BridgeUtils.logDebug(TAG, "Build properties - fingerprint: $fingerprint, model: $model, manufacturer: $manufacturer")
+        BridgeUtils.logDebug(TAG, "Build properties - brand: $brand, device: $device, product: $product, hardware: $hardware")
+
+        // Check for emulator-specific strings in Build properties
+        var sdkMatchFound = false
+        val hasEmulatorProperty = EMULATOR_PROPERTIES.any {
+            val found = fingerprint.contains(it) ||
+                model.contains(it) ||
+                manufacturer.contains(it) ||
+                brand.contains(it) ||
+                device.contains(it) ||
+                product.contains(it) ||
+                hardware.contains(it)
+            if (found) {
+                BridgeUtils.logDebug(TAG, "Found emulator property: '$it'")
+                // Track if 'sdk' was the match (for whitelist check)
+                if (it == "sdk") {
+                    sdkMatchFound = true
+                }
+            }
+            found
+        }
+
+        // If flagged as emulator ONLY because of 'sdk', check if it's a legitimate device
+        val isLegitimateDevice = if (sdkMatchFound && hasEmulatorProperty) {
+            val isLegit = LEGITIMATE_SDK_PATTERNS.any {
+                manufacturer.contains(it) || 
+                brand.contains(it) || 
+                hardware.contains(it) ||
+                model.contains(it)
+            }
+            if (isLegit) {
+                BridgeUtils.logDebug(TAG, "Device flagged by 'sdk' but matches legitimate pattern - likely MediaTek/Qualcomm chipset")
+            }
+            isLegit
+        } else {
+            false
+        }
+
+        // Check suspicious manufacturer/model
+        val hasSuspiciousManufacturer = SUSPICIOUS_MANUFACTURERS.any {
+            val found = manufacturer.contains(it.lowercase())
+            if (found) {
+                BridgeUtils.logDebug(TAG, "Found suspicious manufacturer: '$it' in '$manufacturer'")
+            }
+            found
+        }
+        val hasSuspiciousModel = SUSPICIOUS_MODELS.any {
+            val found = model.contains(it.lowercase())
+            if (found) {
+                BridgeUtils.logDebug(TAG, "Found suspicious model: '$it' in '$model'")
+            }
+            found
+        }
+
+        // Final result: emulator if properties match AND not whitelisted, OR suspicious manufacturer/model
+        val result = (hasEmulatorProperty && !isLegitimateDevice) || hasSuspiciousManufacturer || hasSuspiciousModel
+        BridgeUtils.logDebug(TAG, "checkBuildProperties result: $result (emulatorProp=$hasEmulatorProperty, legitimateDevice=$isLegitimateDevice, suspiciousManufacturer=$hasSuspiciousManufacturer, suspiciousModel=$hasSuspiciousModel)")
+        return result
+    }
+
+    /**
+     * Check for missing hardware sensors (common in emulators)
+     */
+    private fun checkHardwareFeatures(context: Context): Boolean {
+        try {
+            val sensorManager = context.getSystemService(Context.SENSOR_SERVICE) as? SensorManager
+                ?: return true
+
+            // Real devices typically have these sensors
+            val hasAccelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER) != null
+            val hasGyroscope = sensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE) != null
+            val hasProximity = sensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY) != null
+            val hasLight = sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT) != null
+
+            BridgeUtils.logDebug(TAG, "Sensor check - Accelerometer: $hasAccelerometer, Gyroscope: $hasGyroscope, Proximity: $hasProximity, Light: $hasLight")
+
+            // Count missing sensors
+            val missingSensors = listOf(hasAccelerometer, hasGyroscope, hasProximity, hasLight)
+                .count { !it }
+
+            // If 2 or more critical sensors missing, likely an emulator
+            val result = missingSensors >= 2
+            BridgeUtils.logDebug(TAG, "checkHardwareFeatures result: $result (missing $missingSensors/4 sensors)")
+            return result
+        } catch (e: Exception) {
+            BridgeUtils.logError(TAG, "Error checking hardware features", e)
+            return false
+        }
+    }
+
+    /**
+     * Check Build.FINGERPRINT for emulator indicators (generic/unknown prefix, test-keys)
+     */
+    private fun checkFingerprint(): Boolean {
+        return try {
+            val fingerprint = Build.FINGERPRINT
+            val hasGeneric = fingerprint.startsWith("generic")
+            val hasUnknown = fingerprint.startsWith("unknown")
+            val hasTestKeys = fingerprint.lowercase().contains("test-keys")
+
+            val result = hasGeneric || hasUnknown || hasTestKeys
+            BridgeUtils.logDebug(TAG, "checkFingerprint result: $result (generic=$hasGeneric, unknown=$hasUnknown, testKeys=$hasTestKeys)")
+            BridgeUtils.logDebug(TAG, "Full FINGERPRINT: $fingerprint")
+            result
+        } catch (e: Exception) {
+            BridgeUtils.logError(TAG, "Error checking fingerprint", e)
+            false
+        }
+    }
+
+    /**
+     * Get detailed emulator detection info for debugging
+     */
+    fun getEmulatorCheckDetails(context: Context): Map<String, Any> {
+        return mapOf(
+            "isEmulator" to isEmulator(context),
+            "buildCheck" to checkBuildProperties(),
+            "hardwareCheck" to checkHardwareFeatures(context),
+            "fingerprintCheck" to checkFingerprint(),
+            "fingerprint" to Build.FINGERPRINT,
+            "model" to Build.MODEL,
+            "manufacturer" to Build.MANUFACTURER,
+            "hardware" to Build.HARDWARE
+        )
+    }
+}