Align the Android client with the iOS and desktop clients

.github/workflows/build-debug.yml

@@ -123,7 +123,10 @@ jobs:
           disk-size: 4096M
           heap-size: 512M
           disable-animations: true
-          script: ./gradlew connectedDebugAndroidTest --no-daemon -Pandroid.testInstrumentationRunnerArguments.notClass=io.netbird.client.NetworkConnectivityStressTest
+          # The e2e package needs a setup key for a live account, which only the
+          # private mobile-e2e repo holds, so it is excluded here along with the
+          # long-running stress test.
+          script: ./gradlew connectedDebugAndroidTest --no-daemon -Pandroid.testInstrumentationRunnerArguments.notClass=io.netbird.client.NetworkConnectivityStressTest -Pandroid.testInstrumentationRunnerArguments.notPackage=io.netbird.client.e2e
 
       - name: Upload test results
         if: always()

.github/workflows/build-snapshot.yml

@@ -23,18 +23,27 @@ jobs:
       - name: Checkout repository
         uses: actions/checkout@v4
         with:
+          # git describe below needs the tags and the history down to the
+          # nearest release tag; the default shallow clone carries neither.
+          fetch-depth: 0
           submodules: recursive
 
       # Reaches the management server as the peer's ui_version and is shown on
       # the app's about screen, so it has to say at a glance that this build was
       # signed and handed out rather than released. build-debug.yml already
       # claims the ci- prefix, and sharing it would make an unsigned PR build
       # and a signed hand-out indistinguishable in the peer list.
+      # The tag is the nearest release tag in the commit's ancestry, so once a
+      # new release is tagged, later snapshots pick it up on their own. If
+      # describe finds no tag the step fails instead of minting a bare name.
       - name: Get version name
         id: version
         run: |
+          BASE_TAG=$(git describe --tags --abbrev=0)
           SHORT_GIT_SHA=$(git rev-parse --short HEAD)
-          echo "version_name=snapshot-${SHORT_GIT_SHA}" >> "$GITHUB_OUTPUT"
+          VERSION_NAME="${BASE_TAG}-snapshot-${SHORT_GIT_SHA}"
+          echo "Version name: $VERSION_NAME"
+          echo "version_name=$VERSION_NAME" >> "$GITHUB_OUTPUT"
 
       # Must stay identical to the Compute version code step in the sibling
       # workflow. build-release.yml and build-snapshot.yml feed the same Play

Readme.md

@@ -35,9 +35,9 @@ The NetBird Android client allows connections from mobile devices running Androi
 ## Screenshots
 
 <p align="center">
-  <img src="https://github.com/netbirdio/android-client/assets/7756831/31fea824-9604-4e6a-a6ed-78cb526b6066" alt="menu" width="250" style="margin-right: 10px;"/>
-  <img src="https://github.com/netbirdio/android-client/assets/7756831/97b3bf1b-6e70-4f25-b5ab-e62b3337f10d" alt="peer-overview" width="250" style="margin-right: 10px;"/>
-  <img src="https://github.com/netbirdio/android-client/assets/7756831/d3ce7c74-aa1e-4be0-ba0c-4761432171e4" alt="mainscreen" width="250"/>
+  <img src="docs/screenshots/mainscreen.png" alt="mainscreen" width="250" style="margin-right: 10px;"/>
+  <img src="docs/screenshots/peer-overview.png" alt="peer-overview" width="250" style="margin-right: 10px;"/>
+  <img src="docs/screenshots/peer-detail.png" alt="peer-detail" width="250"/>
 </p>
 
 ## Install

app/build.gradle.kts

@@ -84,7 +84,6 @@ dependencies {
     androidTestImplementation(libs.uiautomator)
     androidTestImplementation(libs.test.rules)
     implementation(libs.browser)  // Added for CustomTabsIntent
-    implementation(libs.lottie)
     implementation(libs.zxing)
 
     if (hasGoogleServicesJson) {

app/src/androidTest/java/io/netbird/client/NetworkConnectivityStressTest.java

@@ -671,15 +671,4 @@ private static class DisruptionType {
             this.restore = restore;
         }
     }
-
-    private static class StateListenerAdapter implements StateListener {
-        @Override public void onEngineStarted() {}
-        @Override public void onEngineStopped() {}
-        @Override public void onAddressChanged(String fqdn, String ip) {}
-        @Override public void onConnected() {}
-        @Override public void onConnecting() {}
-        @Override public void onDisconnected() {}
-        @Override public void onDisconnecting() {}
-        @Override public void onPeersListChanged(long count) {}
-    }
 }

app/src/androidTest/java/io/netbird/client/e2e/DnsResolutionTest.java

@@ -0,0 +1,133 @@
+package io.netbird.client.e2e;
+
+import io.netbird.client.MainActivity;
+
+import android.os.Bundle;
+import android.util.Log;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.platform.app.InstrumentationRegistry;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * DNS resolution test — the Android port of the Robot
+ * {@code client-tests.robot} case "Should resolve the domain and hostname".
+ *
+ * <p>With the tunnel up, the {@code dnstest} peer's internal name must resolve
+ * to its private address {@code 172.20.3.158} through the NetBird DNS. The
+ * original runs {@code dig <name>}; here we run a real {@code nslookup} on the
+ * device (via the shell, like the ping tests), so it exercises the device
+ * resolver / VpnService DNS exactly as a user's traffic would.
+ *
+ * <p>Mirrors the two original assertions:
+ * <ul>
+ *   <li>FQDN resolves: {@code nslookup
+ *       ip-172-20-3-158.eu-central-1.compute.internal} → 172.20.3.158;</li>
+ *   <li>search-domain (unqualified) resolves: {@code nslookup ip-172-20-3-158}
+ *       → 172.20.3.158.</li>
+ * </ul>
+ *
+ * <p>The original additionally checks the main system resolver is a NetBird
+ * {@code 100.x} address via {@code /etc/resolv.conf} / {@code resolvectl}. That
+ * is Linux-specific and not portable to Android (no {@code resolv.conf} in the
+ * usual sense; the VpnService owns DNS), so it is omitted — the resolution
+ * results above already prove tunnel DNS is in effect.
+ *
+ * <p>Only the setup key is injected:
+ * <pre>
+ *   ./gradlew connectedDebugAndroidTest \
+ *     -Pandroid.testInstrumentationRunnerArguments.setupKey=&lt;UUID&gt;
+ * </pre>
+ */
+@RunWith(AndroidJUnit4.class)
+public class DnsResolutionTest {
+
+    private static final String TAG = "NBDnsTest";
+
+    /** dnstest peer's internal hostname and its expected private address. */
+    private static final String PEER_FQDN = "ip-172-20-3-158.eu-central-1.compute.internal";
+    private static final String PEER_UNQUALIFIED = "ip-172-20-3-158";
+    private static final String EXPECTED_IP = "172.20.3.158";
+
+    /**
+     * Window for the UI to report Connected. Generous against the observed
+     * few seconds; the slow part is the data plane settling afterwards, which
+     * the 90s probe windows below absorb (Robot allows ~3 min for the whole
+     * peer-ready sequence).
+     */
+    private static final long CONNECT_TIMEOUT_SEC = 20;
+    /** Time budget for DNS to start resolving once the engine is connected. */
+    private static final long RESOLVE_TIMEOUT_SEC = 90;
+    private VpnTestHarness harness;
+    private String profileName;
+
+    @Before
+
+    public void skipIfPreviousFailed() {
+
+        FailFast.skipIfAborted();
+
+    }
+
+
+    @After
+    public void tearDown() throws Exception {
+        if (profileName != null && harness != null) {
+            harness.disableTouchVisualization();
+            LoginFlow.removeProfile(E2eAppRule.activity(), harness.device(), profileName);
+        }
+    }
+
+    @Test
+    public void resolvesPeerNameThroughTunnel() throws Exception {
+        Bundle args = InstrumentationRegistry.getArguments();
+        String setupKey = args.getString("setupKey");
+
+        assertNotNull("setupKey instrumentation argument is required", setupKey);
+        assertTrue("setupKey must not be blank", !setupKey.trim().isEmpty());
+
+        MainActivity activity = E2eAppRule.activity();
+        assertNotNull("MainActivity must be available", activity);
+        harness = new VpnTestHarness(activity);
+        harness.enableTouchVisualization();
+
+        harness.grantVpnConsent();
+
+        profileName = LoginFlow.createProfileAndLogin(
+                activity, harness.device(), "dns", setupKey);
+
+        boolean connected = harness.connectAndAwait(CONNECT_TIMEOUT_SEC);
+        if (!connected) {
+            LoginFlow.dumpScreenshot(harness.device(), "vpn-connect-timeout");
+        }
+        assertTrue("VPN did not reach connected state within " + CONNECT_TIMEOUT_SEC + "s",
+                connected);
+
+        // FQDN resolves to the peer's private address through the tunnel DNS.
+        boolean fqdnResolved = harness.waitForResolve(PEER_FQDN, EXPECTED_IP, RESOLVE_TIMEOUT_SEC);
+        if (!fqdnResolved) {
+            LoginFlow.dumpScreenshot(harness.device(), "dns-fqdn-unresolved");
+        }
+        assertTrue(PEER_FQDN + " did not resolve to " + EXPECTED_IP + " within "
+                + RESOLVE_TIMEOUT_SEC + "s", fqdnResolved);
+
+        // Search-domain: the unqualified name resolves to the same address.
+        boolean searchResolved =
+                harness.waitForResolve(PEER_UNQUALIFIED, EXPECTED_IP, RESOLVE_TIMEOUT_SEC);
+        if (!searchResolved) {
+            LoginFlow.dumpScreenshot(harness.device(), "dns-search-unresolved");
+        }
+        assertTrue(PEER_UNQUALIFIED + " (search domain) did not resolve to " + EXPECTED_IP
+                + " within " + RESOLVE_TIMEOUT_SEC + "s", searchResolved);
+
+        Log.i(TAG, "DNS resolution verified: " + PEER_FQDN + " and " + PEER_UNQUALIFIED
+                + " -> " + EXPECTED_IP);
+    }
+}

app/src/androidTest/java/io/netbird/client/e2e/E2eAppRule.java

@@ -0,0 +1,75 @@
+package io.netbird.client.e2e;
+
+import io.netbird.client.MainActivity;
+
+import android.app.Activity;
+import android.app.Instrumentation;
+import android.content.Intent;
+
+import androidx.test.platform.app.InstrumentationRegistry;
+import androidx.test.runner.lifecycle.ActivityLifecycleMonitorRegistry;
+import androidx.test.runner.lifecycle.Stage;
+
+import java.util.Collection;
+
+/**
+ * Provides the single shared {@link MainActivity} for the e2e suite WITHOUT a
+ * JUnit rule: {@link #activity()} returns the currently-resumed MainActivity,
+ * launching one if none is up. This survives the test framework finishing
+ * activities between test classes (which made a suite-level ActivityTestRule /
+ * ActivityScenario hand back a destroyed activity). Because the launch reuses
+ * the existing task, the app is not torn down and recreated between cases.
+ */
+final class E2eAppRule {
+
+    private static final long LAUNCH_TIMEOUT_MS = 10_000;
+
+    private E2eAppRule() {
+    }
+
+    /** The running MainActivity, launched on demand if not already resumed. */
+    static MainActivity activity() {
+        MainActivity existing = resumedMainActivity();
+        if (existing != null) {
+            return existing;
+        }
+
+        Instrumentation instrumentation = InstrumentationRegistry.getInstrumentation();
+        Intent intent = new Intent(instrumentation.getTargetContext(), MainActivity.class)
+                .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        instrumentation.startActivitySync(intent);
+        instrumentation.waitForIdleSync();
+
+        long deadline = System.currentTimeMillis() + LAUNCH_TIMEOUT_MS;
+        MainActivity activity = resumedMainActivity();
+        while (activity == null && System.currentTimeMillis() < deadline) {
+            try {
+                Thread.sleep(100);
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+                break;
+            }
+            activity = resumedMainActivity();
+        }
+        if (activity == null) {
+            throw new IllegalStateException("MainActivity did not reach RESUMED within "
+                    + (LAUNCH_TIMEOUT_MS / 1000) + "s");
+        }
+        return activity;
+    }
+
+    private static MainActivity resumedMainActivity() {
+        MainActivity[] found = new MainActivity[1];
+        InstrumentationRegistry.getInstrumentation().runOnMainSync(() -> {
+            Collection<Activity> resumed = ActivityLifecycleMonitorRegistry.getInstance()
+                    .getActivitiesInStage(Stage.RESUMED);
+            for (Activity a : resumed) {
+                if (a instanceof MainActivity) {
+                    found[0] = (MainActivity) a;
+                    break;
+                }
+            }
+        });
+        return found[0];
+    }
+}

app/src/androidTest/java/io/netbird/client/e2e/E2eSuite.java

@@ -0,0 +1,47 @@
+package io.netbird.client.e2e;
+
+import io.netbird.client.MainActivity;
+
+import androidx.test.platform.app.InstrumentationRegistry;
+import androidx.test.uiautomator.UiDevice;
+
+import org.junit.BeforeClass;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+
+/**
+ * Runs the on-device client e2e tests (the Android port of the Robot
+ * {@code client-tests.robot} suite). Tests obtain the shared {@link MainActivity}
+ * via {@link E2eAppRule#activity()}, which reuses the running activity (launching
+ * one only if none is up), so the app is not restarted between cases.
+ *
+ * <p>Run with:
+ * <pre>
+ *   -Pandroid.testInstrumentationRunnerArguments.class=io.netbird.client.e2e.E2eSuite
+ * </pre>
+ */
+@RunWith(Suite.class)
+@Suite.SuiteClasses({
+        SetupKeyAuthTest.class,
+        PeerConnectivityTest.class,
+        PortAclTest.class,
+        DnsResolutionTest.class,
+        ExitNodeRouteTest.class,
+        ExitNodeNetworkTransitionTest.class,
+        // Last on purpose: its final case (B2, cellular->WiFi handover speed)
+        // is expected to fail until PR #243 merges, and the FailFast listener
+        // would skip everything scheduled after that failure.
+        NetworkTransitionTest.class,
+})
+public class E2eSuite {
+
+    /**
+     * Force relay is a global setting that defaults ON and would stop the
+     * relay-less peer connecting. Turn it off ONCE, before any test runs.
+     */
+    @BeforeClass
+    public static void disableForceRelay() throws Exception {
+        UiDevice device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation());
+        LoginFlow.setForceRelay(E2eAppRule.activity(), device, false);
+    }
+}