DEV Community

Anton Krylov
Anton Krylov

Posted on

Redroid

#devops #android #kotlin #testing

What is ReDroid?

ReDroid is a lightweight alternative to the standard Android emulator that runs as a Docker container. ReDroid provides a full Android system in a container, significantly reducing startup time and resource consumption compared to traditional emulators.

ReDroid uses the host system's Linux kernel and is based on the anbox module project, enabling Android to run without CPU virtualization. This makes it an ideal solution for automated Android app testing in CI/CD environments where speed and efficiency are critical.

Comparison with Android Studio Emulator:

ReDroid is perfect for automated UI testing in CI/CD, especially when speed and resource efficiency are important. The standard Android Studio emulator is better suited for local development, debugging, and testing requiring full device emulation.

Manual Testing

Start the ReDroid container (Docker) and wait about a minute for it to load:

docker run -d --name redroid --privileged -p 5555:5555 redroid/redroid:15.0.0_64only-latest
sleep 30
Enter fullscreen mode Exit fullscreen mode

Connect to the running container via ADB:

adb connect localhost:5555
adb devices
Enter fullscreen mode Exit fullscreen mode

Install both APK files on ReDroid:

adb -s localhost:5555 install ./app/build/outputs/apk/debug/app-debug.apk
adb -s localhost:5555 install ./app/build/outputs/apk/androidTest/debug/app-debug-androidTest.apk
Enter fullscreen mode Exit fullscreen mode

Run your Espresso/UI tests with ADB:

adb -s localhost:5555 shell am instrument -w your.package.name.test/androidx.test.runner.AndroidJUnitRunner
Enter fullscreen mode Exit fullscreen mode

Export logs after testing:

adb -s localhost:5555 logcat -d > android-log.txt
Enter fullscreen mode Exit fullscreen mode

After completing the tests, remove the container:

docker stop redroid && docker rm redroid
Enter fullscreen mode Exit fullscreen mode

Preparing an Android Project for UI Testing

Step 1: Configuring Dependencies in app/build.gradle

gradle:

android {
    defaultConfig {
        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }
}

dependencies {
    // Core components for UI testing
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.5.1'
    androidTestImplementation 'androidx.test:runner:1.5.2'
    androidTestImplementation 'androidx.test:rules:1.5.0'

    // Additional Espresso libraries for advanced testing
    androidTestImplementation 'androidx.test.espresso:espresso-contrib:3.5.1'
    androidTestImplementation 'androidx.test.espresso:espresso-intents:3.5.1'

    // JUnit for test environment integration
    androidTestImplementation 'androidx.test.ext:junit:1.1.5'
}
Enter fullscreen mode Exit fullscreen mode

Step 2: Creating an Example UI Test with Espresso

Create the file app/src/androidTest/java/com/example/app/MainActivityTest.java:

java:

package com.example.app;

import androidx.test.espresso.matcher.ViewMatchers;
import androidx.test.ext.junit.rules.ActivityScenarioRule;
import androidx.test.ext.junit.runners.AndroidJUnit4;
import androidx.test.filters.LargeTest;

import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;

import static androidx.test.espresso.Espresso.onView;
import static androidx.test.espresso.action.ViewActions.click;
import static androidx.test.espresso.assertion.ViewAssertions.matches;
import static androidx.test.espresso.matcher.ViewMatchers.isDisplayed;
import static androidx.test.espresso.matcher.ViewMatchers.withId;
import static androidx.test.espresso.matcher.ViewMatchers.withText;

@RunWith(AndroidJUnit4.class)
@LargeTest
public class MainActivityTest {

    @Rule
    public ActivityScenarioRule<MainActivity> activityRule =
        new ActivityScenarioRule<>(MainActivity.class);

    @Test
    public void welcomeTextIsDisplayed() {
        // Check that the welcome text field is displayed
        onView(withId(R.id.welcome_text))
            .check(matches(isDisplayed()))
            .check(matches(withText("Hello World!")));
    }

    @Test
    public void buttonClickChangesText() {
        // Click the button
        onView(withId(R.id.action_button))
            .perform(click());

        // Check that the text has changed
        onView(withId(R.id.welcome_text))
            .check(matches(withText("Button Clicked!")));
    }
}
Enter fullscreen mode Exit fullscreen mode

Configuring Jenkins for UI Test Automation with ReDroid

Step 1: Installing Required Jenkins Plugins

In the Jenkins interface, go to "Configure Jenkins" > "Manage Plugins" and install:

Docker Pipeline
Gradle Plugin
HTML Publisher Plugin
JUnit Plugin
Allure Jenkins Plugin (optional for enhanced reporting)
Step 2: Creating a Jenkinsfile for the Pipeline

Create a Jenkinsfile in the project root:

groovy:

pipeline {
    agent any

    environment {
        // Environment variables
        ANDROID_HOME = '/opt/android-sdk'
        REDROID_IMAGE = 'redroid/redroid:15.0.0_64only-latest'
        REDROID_CONTAINER = 'android-ui-test-container'
        ADB_PORT = '5555'
        TEST_RESULTS_DIR = 'app/build/outputs/androidTest-results'
        TEST_REPORT_DIR = 'app/build/reports/androidTests'
    }

    stages {
        stage('Checkout') {
            steps {
                checkout scm
            }
        }

        stage('Build APKs') {
            steps {
                sh './gradlew clean assembleDebug assembleDebugAndroidTest'
            }
        }

        stage('Start ReDroid Container') {
            steps {
                script {
                    // Stop and remove the container if it exists
                    sh "docker stop ${REDROID_CONTAINER} || true"
                    sh "docker rm ${REDROID_CONTAINER} || true"

                    // Run ReDroid in Docker
                    sh """
                        docker run -d --name ${REDROID_CONTAINER} \
                        --privileged \
                        -p ${ADB_PORT}:${ADB_PORT} \
                        -e REDROID_PROP_ro.debuggable=1 \
                        -e REDROID_PROP_service.adb.tcp.port=${ADB_PORT} \
                        ${REDROID_IMAGE}
                    """

                    // Wait for ReDroid to start
                    sh "sleep 30"
                }
            }
        }

        stage('Connect to ReDroid and Install APKs') {
            steps {
                script {
                    // Connect to the device via ADB
                    sh "adb connect localhost:${ADB_PORT}"
                    sh "adb devices"

                    // Wait for the system to fully load
                    sh "adb wait-for-device"

                    // Install the app APK and tests
                    sh "adb -s localhost:${ADB_PORT} install -r app/build/outputs/apk/debug/app-debug.apk"
                    sh "adb -s localhost:${ADB_PORT} install -r app/build/outputs/apk/androidTest/debug/app-debug-androidTest.apk"
                }
            }
        }

        stage('Run UI Tests') {
            steps {
                script {
                    // Create directories for results
                    sh "mkdir -p ${TEST_RESULTS_DIR}"

                    // Get the app package name
                    def packageName = sh(
                        script: "aapt dump badging app/build/outputs/apk/debug/app-debug.apk | grep package | awk '{print \$2}' | sed s/name=//g | sed s/\\'//g",
                        returnStdout: true
                    ).trim()

                    // Run UI tests
                    sh """
                        adb -s localhost:${ADB_PORT} shell am instrument -w \
                        -e debug false \
                        -e junit.output.format=xml \
                        -e additionalTestOutputDir=/sdcard/test-results \
                        ${packageName}.test/androidx.test.runner.AndroidJUnitRunner
                    """

                    // Copy results from the device
                    sh "adb -s localhost:${ADB_PORT} pull /sdcard/test-results ${TEST_RESULTS_DIR}"

                    // Collect logs
                    sh "adb -s localhost:${ADB_PORT} logcat -d > ${TEST_RESULTS_DIR}/device-log.txt"

                    // Take a screenshot for diagnostics (optional)
                    sh "adb -s localhost:${ADB_PORT} shell screencap -p /sdcard/screen.png"
                    sh "adb -s localhost:${ADB_PORT} pull /sdcard/screen.png ${TEST_RESULTS_DIR}/"
                }
            }
        }
    }

    post {
        always {
            // Publish JUnit results
            junit "${TEST_RESULTS_DIR}/**/*.xml"

            // Publish test reports
            publishHTML([
                allowMissing: true,
                alwaysLinkToLastBuild: true,
                keepAll: true,
                reportDir: "${TEST_REPORT_DIR}/connected",
                reportName: 'Espresso Test Report',
                reportFiles: 'index.html'
            ])

            // Stop and remove the container
            script {
                sh "docker stop ${REDROID_CONTAINER} || true"
                sh "docker rm ${REDROID_CONTAINER} || true"
            }

            // Clean up ADB
            sh "adb disconnect localhost:${ADB_PORT} || true"

            // Archive artifacts
            archiveArtifacts artifacts: "${TEST_RESULTS_DIR}/**/*", allowEmptyArchive: true
        }
    }
}
Enter fullscreen mode Exit fullscreen mode

Scrcpy

Scrcpy is a lightweight, free, open-source utility for displaying and controlling Android device screens on a computer. It works over USB (ADB) or Wi-Fi without requiring any mobile apps on the device.

Usage Examples:

Connect and start (device connected via USB):

scrcpy
Enter fullscreen mode Exit fullscreen mode

Connect via Wi-Fi (knowing the device's IP address):

adb connect 192.168.1.5:5555
scrcpy -s 192.168.1.5:5555
Enter fullscreen mode Exit fullscreen mode

Change video resolution:

scrcpy -m 1024
Enter fullscreen mode Exit fullscreen mode

Record device video:

scrcpy --record file.mp4
Enter fullscreen mode Exit fullscreen mode

Control the device without displaying the screen (keyboard and mouse input only):

scrcpy -N
Enter fullscreen mode Exit fullscreen mode

If you need visual monitoring of test execution, you can integrate Scrcpy into the pipeline:

stage('Visual Debug with Scrcpy') {
    when {
        expression { return params.ENABLE_VISUAL_DEBUG }
    }
    steps {
        script {
            // Install Scrcpy if not already installed
            sh '''
                if ! command -v scrcpy &> /dev/null; then
                    apt-get update && apt-get install -y scrcpy
                fi
            '''

            // Start Scrcpy to record test execution
            sh "mkdir -p ${TEST_RESULTS_DIR}/recordings"

            for (int i = 0; i < DEVICE_COUNT; i++) {
                def adbPort = BASE_ADB_PORT + i
                sh """
                    nohup scrcpy --no-display --record=${TEST_RESULTS_DIR}/recordings/device-${i}-recording.mp4 \
                    --serial=localhost:${adbPort} &
                """
            }

            // Limit recording duration
            sh "sleep 60"  // Record the first minute of testing
            sh "pkill scrcpy || true"
        }
    }
Enter fullscreen mode Exit fullscreen mode

Kubernetes

Why Use ReDroid in Kubernetes

ReDroid in Kubernetes simplifies Android app testing. Here are the key benefits:

Parallel Tests — Run multiple virtual Android devices simultaneously, saving testing time.

Lower Resource Costs — ReDroid is lightweight, and Kubernetes efficiently distributes the load across servers.

Automatic Management — The system automatically starts, restarts, and stops Android containers without manual intervention.

Easy CI/CD Integration — Seamlessly integrates with existing Jenkins or GitLab CI pipelines.

Test Isolation — Each test environment operates independently without interfering with others.

Centralized Management — Everything is controlled through a single interface.

Budget Savings — Virtual devices replace expensive physical phones.

Consistent Conditions — All tests run in the same environment, improving result reliability.

Hardware Acceleration Access — Can be configured to use GPU for better performance.

This solution is ideal for teams needing to regularly test Android apps in different configurations quickly and predictably.

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: redroid-farm
  namespace: android-testing
spec:
  serviceName: "redroid"
  replicas: 3  # Number of parallel device instances
  selector:
    matchLabels:
      app: redroid-device
  template:
    metadata:
      labels:
        app: redroid-device
    spec:
      securityContext:
        runAsUser: 0  # Run as root
      containers:
      - name: redroid
        image: redroid/redroid:15.0.0_64only-latest
        securityContext:
          privileged: true  # Required for redroid
        ports:
        - containerPort: 5555
          name: adb
        env:
        - name: REDROID_PROP_ro.debuggable
          value: "1"
        - name: REDROID_PROP_service.adb.tcp.port
          value: "5555"
        - name: ANDROID_ARCH
          value: "x86_64"
        resources:
          requests:
            cpu: 2
            memory: 3Gi
          limits:
            cpu: 4
            memory: 6Gi
        volumeMounts:
        - name: dri
          mountPath: /dev/dri
        - name: kvm
          mountPath: /dev/kvm
        lifecycle:
          preStop:
            exec:
              command: ["/system/bin/reboot", "-p"]
      volumes:
      - name: dri
        hostPath:
          path: /dev/dri
      - name: kvm
        hostPath:
          path: /dev/kvm
      nodeSelector:
        hardware-acceleration: "true"  # Select nodes with GPU/hardware acceleration
Enter fullscreen mode Exit fullscreen mode

Wireshark and ReDroid: Capturing and Analyzing Android App Network Traffic

Wireshark combined with ReDroid provides powerful tools for testing and debugging Android app network interactions. This combination is particularly useful for analyzing API requests, checking connection security, and debugging network issues.

Key Features:

  • Real Traffic Monitoring — Wireshark lets you see all network packets exchanged between the Android app in ReDroid and external services.

  • Easy Setup — Since ReDroid runs as a Docker container, its network traffic is easily captured through Docker networking without additional tools on the device itself.

  • Secure Traffic Analysis — With proper setup, you can even inspect HTTPS traffic (using tools like mitmproxy with ReDroid).

  • Performance Issue Detection — Easily identify slow requests and app performance delays from network data.

  • Automated API Testing — Record and replay network interaction scenarios for testing.

Network Setup for Testing:

Run ReDroid with special network parameters:

docker run --name redroid-test --network host redroid/redroid:11.0.0-latest
Enter fullscreen mode Exit fullscreen mode

Configure traffic capture in Wireshark, filtering for the specific ReDroid container traffic:

ip.addr == [container IP address]
Enter fullscreen mode Exit fullscreen mode

For HTTPS traffic, configure a proxy in ReDroid via ADB:

adb connect localhost:5555
adb shell settings put global http_proxy "localhost:8080"
Enter fullscreen mode Exit fullscreen mode

Start mitmproxy for HTTPS decryption:

mitmproxy --listen-port 8080
Enter fullscreen mode Exit fullscreen mode

This solution helps developers and testers better understand how their Android apps interact with the network, identify security issues, and optimize network interactions without needing physical devices or complex emulator setups.

Top comments (0)

Some comments may only be visible to logged-in visitors. Sign in to view all comments.