如何检测集成SDK的APP是否被自动化测试工具操控（无需改应用、不查进程）

Great question—this is a top concern for SDK builders looking to shield their clients' apps from automated abuse. Let’s break down practical, SDK-side detection methods that fit your constraints:

1. Hunt for Automation-Specific System Properties #

Nearly every automation framework leaves a breadcrumb in system properties when running. You can query these directly from your SDK without touching the host app’s code:

boolean isAutomated = false;
// Check Appium-specific flags
isAutomated |= System.getProperty("appium.driver") != null;
isAutomated |= System.getProperty("appium.platform_version") != null;
// Robotium sets this during test runs
isAutomated |= System.getProperty("robotium.test") != null;
// UiAutomator2 leaves a runner property
isAutomated |= System.getProperty("uiautomator.runner") != null;
// Espresso uses the default instrumentation runner flag
isAutomated |= System.getProperty("android.testInstrumentationRunner") != null && 
               System.getProperty("android.testInstrumentationRunner").contains("espresso");

Heads up: Some tools might obscure these properties over time, so you’ll want to revisit and update checks periodically. Most SDKs have default access to read system properties, so no extra permissions are needed here.

2. Analyze Input Event Source Characteristics #

Automated input events (clicks, swipes) differ from normal user touches in their source type. You can hook into touch events from your SDK to spot these anomalies:

// Attach this listener to key views or use an activity callback in your SDK
view.setOnTouchListener((v, event) -> {
    int source = event.getSource();
    // Normal user touches come from SOURCE_TOUCHSCREEN or SOURCE_TOUCHPAD
    boolean isInjected = !(source == InputDevice.SOURCE_TOUCHSCREEN || 
                           source == InputDevice.SOURCE_TOUCHPAD);
    if (isInjected) {
        // Track the ratio of injected events—flag if most interactions are non-human
        incrementInjectedEventCount();
        if (getInjectedEventRatio() > 0.8) {
            markAsAutomated();
        }
    }
    return false;
});

Key insight: Tools like Appium and UiAutomator2 inject events via Instrumentation or InputManager, which use non-touch sources like SOURCE_INJECTED or SOURCE_MOUSE.

3. Inspect the Active Instrumentation Instance #

Frameworks like Espresso, Robotium, and UiAutomator2 rely on Android’s Instrumentation framework. You can use reflection to check the current instrumentation’s class without touching processes or services:

try {
    // Grab the current ActivityThread instance via reflection
    Class<?> activityThreadClass = Class.forName("android.app.ActivityThread");
    Method currentActivityThreadMethod = activityThreadClass.getMethod("currentActivityThread");
    Object activityThread = currentActivityThreadMethod.invoke(null);
    
    // Get the active instrumentation from ActivityThread
    Field instrumentationField = activityThreadClass.getDeclaredField("mInstrumentation");
    instrumentationField.setAccessible(true);
    Object instrumentation = instrumentationField.get(activityThread);
    
    // Check if the instrumentation belongs to an automation framework
    String instrClassName = instrumentation.getClass().getName();
    boolean isAutomated = instrClassName.contains("espresso") || 
                          instrClassName.contains("robotium") || 
                          instrClassName.contains("uiautomator");
} catch (Exception e) {
    // Handle reflection exceptions gracefully—don't crash the host app
}

Why this works: These frameworks replace the default app instrumentation with their own during runtime, so the class name will reveal their presence.

4. Detect Unnatural UI Interaction Patterns #

Automated tools often exhibit repetitive, non-human behavior. You can track interaction timing and coordinates in your SDK to spot red flags:

long lastTouchTime = 0;
view.setOnTouchListener((v, event) -> {
    if (event.getAction() == MotionEvent.ACTION_DOWN) {
        long currentTime = System.currentTimeMillis();
        // Human touches rarely happen faster than 50ms apart
        if (lastTouchTime != 0 && currentTime - lastTouchTime < 50) {
            markSuspiciousInteraction();
        }
        lastTouchTime = currentTime;
        
        // Automated tools often use exact, rounded coordinates (humans don't)
        float x = event.getX();
        float y = event.getY();
        if (x == Math.round(x) && y == Math.round(y)) {
            markSuspiciousInteraction();
        }
    }
    return false;
});

Note: This is a heuristic method—adjust thresholds to balance accuracy and avoid false positives (e.g., account for fast-tapping power users).

内容的提问来源于stack exchange，提问作者Zhou Hongbo