minSdk 15环境下通知点击测试的替代方案咨询

Got it, since UIAutomator's minimum API level is 18 and your project targets down to 15, here are three practical alternatives you can use to test notification tap behavior:

1. Instrumentation + AccessibilityService 组合 #

This is a native Android approach that works for API 14+, so it fits your minSdk 15 requirement. Here's how to set it up:

Step 1: Create an AccessibilityService #

First, define an AccessibilityService that listens for notification events and can trigger clicks:

public class NotificationClickService extends AccessibilityService {
    @Override
    public void onAccessibilityEvent(AccessibilityEvent event) {
        if (event.getEventType() == AccessibilityEvent.TYPE_NOTIFICATION_STATE_CHANGED) {
            // Get the notification node info
            List<CharSequence> texts = event.getText();
            if (!texts.isEmpty()) {
                AccessibilityNodeInfo rootNode = getRootInActiveWindow();
                if (rootNode != null) {
                    // Find the notification element (adjust matching logic based on your notification content)
                    List<AccessibilityNodeInfo> notificationNodes = rootNode.findAccessibilityNodeInfosByText(texts.get(0).toString());
                    for (AccessibilityNodeInfo node : notificationNodes) {
                        // Perform click action
                        node.performAction(AccessibilityNodeInfo.ACTION_CLICK);
                        break;
                    }
                    rootNode.recycle();
                }
            }
        }
    }

    @Override
    public void onInterrupt() {}

    @Override
    protected void onServiceConnected() {
        super.onServiceConnected();
        AccessibilityServiceInfo info = new AccessibilityServiceInfo();
        info.eventTypes = AccessibilityEvent.TYPE_NOTIFICATION_STATE_CHANGED;
        info.feedbackType = AccessibilityServiceInfo.FEEDBACK_GENERIC;
        setServiceInfo(info);
    }
}

Step 2: Register the Service in AndroidManifest.xml #

Add this inside the <application> tag:

<service
    android:name=".NotificationClickService"
    android:permission="android.permission.BIND_ACCESSIBILITY_SERVICE">
    <intent-filter>
        <action android:name="android.accessibilityservice.AccessibilityService" />
    </intent-filter>
    <meta-data
        android:name="android.accessibilityservice"
        android:resource="@xml/accessibility_service_config" />
</service>

Create res/xml/accessibility_service_config.xml:

<accessibility-service xmlns:android="http://schemas.android.com/apk/res/android"
    android:accessibilityEventTypes="typeNotificationStateChanged"
    android:accessibilityFeedbackType="feedbackGeneric"
    android:accessibilityFlags="flagDefault"
    android:canRetrieveWindowContent="true" />

Step 3: Use Instrumentation in Your Test Case #

In your instrumentation test, trigger the notification, then wait for the AccessibilityService to handle the click. You'll need to manually enable the accessibility service on the test device first (since it requires user consent):

@RunWith(AndroidJUnit4.class)
public class NotificationTest {
    @Rule
    public ActivityTestRule<MainActivity> activityRule = new ActivityTestRule<>(MainActivity.class);

    @Test
    public void testNotificationClick() throws InterruptedException {
        // Trigger your app to send a notification
        activityRule.getActivity().sendTestNotification();

        // Wait for the service to process the notification (adjust timeout as needed)
        Thread.sleep(2000);

        // Verify that the expected activity was launched
        Intent expectedIntent = new Intent(activityRule.getActivity(), TargetActivity.class);
        Assert.assertNotNull(activityRule.getActivity().getPackageManager().resolveActivity(expectedIntent, 0));
    }
}

Pros: Native Android APIs, no third-party dependencies.
Cons: Requires manual enabling of accessibility service on test devices, which can be a hassle for CI/CD pipelines.

2. Robotium Framework #

Robotium is a popular UI testing framework that supports API 10+, making it perfect for your minSdk 15 project. It has built-in methods to interact with notifications easily.

Setup #

Add the dependency to your build.gradle (Module level):

androidTestImplementation 'com.jayway.android.robotium:robotium-solo:5.6.3'

Test Example #

public class NotificationTest extends ActivityInstrumentationTestCase2<MainActivity> {
    private Solo solo;

    public NotificationTest() {
        super(MainActivity.class);
    }

    @Override
    protected void setUp() throws Exception {
        super.setUp();
        solo = new Solo(getInstrumentation(), getActivity());
    }

    public void testNotificationClick() {
        // Trigger the notification
        solo.getCurrentActivity().sendTestNotification();

        // Wait for the notification to appear
        solo.waitForNotification(2000);

        // Click on the first notification (or use index to target specific ones)
        solo.clickOnNotification(0);

        // Verify the target activity is opened
        solo.waitForActivity(TargetActivity.class);
        assertTrue("Target activity should be launched", solo.getCurrentActivity() instanceof TargetActivity);
    }

    @Override
    protected void tearDown() throws Exception {
        solo.finishOpenedActivities();
        super.tearDown();
    }
}

Pros: Simple API, handles notification interactions out of the box, no need for accessibility service setup.
Cons: Robotium is no longer actively maintained, but it still works reliably for older Android versions.

3. Instrumentation + Broadcast Receiver (Simpler for Specific Cases) #

If you only need to test that tapping a notification launches the correct component, you can use a BroadcastReceiver to intercept the notification's PendingIntent and verify it, without actually clicking the notification.

Test Example #

@RunWith(AndroidJUnit4.class)
public class NotificationPendingIntentTest {
    private Intent capturedIntent;

    @Test
    public void testNotificationPendingIntent() throws InterruptedException {
        // Register a broadcast receiver to capture the intent
        BroadcastReceiver receiver = new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                capturedIntent = intent;
            }
        };
        IntentFilter filter = new IntentFilter("com.your.app.NOTIFICATION_ACTION");
        InstrumentationRegistry.getTargetContext().registerReceiver(receiver, filter);

        // Trigger the notification
        MainActivity activity = new MainActivity();
        activity.sendTestNotification();

        // Wait for the intent to be captured
        Thread.sleep(1000);

        // Verify the intent targets the correct activity
        assertEquals(TargetActivity.class.getName(), capturedIntent.getComponent().getClassName());

        // Unregister the receiver
        InstrumentationRegistry.getTargetContext().unregisterReceiver(receiver);
    }
}

Pros: No need to interact with the UI, fast tests, good for verifying intent correctness.
Cons: Doesn't actually test the physical tap action on the notification (only the intent logic).

内容的提问来源于stack exchange，提问作者Ibrahim Ali