feat(#11281): bring up the wifi hotspot and pairing

build.gradle

@@ -488,6 +488,11 @@ android {
 }
 
 dependencies {
+  // Offline sync over WiFi hotspot: NanoHTTPD is a single-file HTTP server, ZXing does QR both ways
+  implementation 'org.nanohttpd:nanohttpd:2.3.1'
+  implementation 'com.google.zxing:core:3.5.3'
+  implementation 'com.journeyapps:zxing-android-embedded:4.3.0'
+
   implementation fileTree(dir: 'libs', include: ['*.jar'])
   implementation platform('org.jetbrains.kotlin:kotlin-bom:1.9.24')
   implementation 'androidx.browser:browser:1.8.0'

src/androidTestUnbrandedDebug/java/org/medicmobile/webapp/mobile/EmbeddedBrowserActivityTest.java

@@ -0,0 +1,81 @@
+package org.medicmobile.webapp.mobile;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertSame;
+
+import android.Manifest;
+import android.os.SystemClock;
+import android.webkit.WebView;
+
+import androidx.test.core.app.ActivityScenario;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.rule.GrantPermissionRule;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.medicmobile.webapp.mobile.offlinesync.OfflineSyncManager;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+
+import org.json.JSONTokener;
+
+@RunWith(AndroidJUnit4.class)
+public class EmbeddedBrowserActivityTest {
+
+	@Rule
+	public GrantPermissionRule permissionRule = GrantPermissionRule.grant(Manifest.permission.POST_NOTIFICATIONS);
+
+	@Test
+	public void recreating_keepsTheSameManager() {
+		AtomicReference<OfflineSyncManager> manager = new AtomicReference<>();
+		try (ActivityScenario<EmbeddedBrowserActivity> scenario = ActivityScenario.launch(EmbeddedBrowserActivity.class)) {
+			scenario.onActivity(activity -> manager.set(activity.getOfflineSyncManager()));
+
+			scenario.recreate();
+
+			assertNotNull(manager.get());
+			scenario.onActivity(activity -> assertSame(manager.get(), activity.getOfflineSyncManager()));
+		}
+	}
+
+	@Test
+	public void aHostLabel_reachesTheWebappAsText() throws Exception {
+		String label = "x%22);}}catch(e){}window.injected=true;try{if(1){(%22";
+		try (ActivityScenario<EmbeddedBrowserActivity> scenario = ActivityScenario.launch(EmbeddedBrowserActivity.class)) {
+			scenario.onActivity(activity -> activity.evaluateJavascript(
+					"window.CHTCore = { AndroidApi: { v1: { resolveOfflineSyncPairing: (ok, detail) => { window.received = detail; } } } };",
+					false));
+
+			scenario.onActivity(activity -> activity.resolveOfflineSyncPairing(true, label));
+
+			assertEquals(label, new JSONTokener(waitFor(scenario, "window.received")).nextValue());
+			assertEquals("\"undefined\"", read(scenario, "typeof window.injected"));
+		}
+	}
+
+	private static String waitFor(ActivityScenario<EmbeddedBrowserActivity> scenario, String expression) throws Exception {
+		long deadline = SystemClock.uptimeMillis() + 5000;
+		String value = read(scenario, expression);
+		while ("null".equals(value) && SystemClock.uptimeMillis() < deadline) {
+			SystemClock.sleep(100);
+			value = read(scenario, expression);
+		}
+		return value;
+	}
+
+	private static String read(ActivityScenario<EmbeddedBrowserActivity> scenario, String expression) throws Exception {
+		AtomicReference<String> value = new AtomicReference<>();
+		CountDownLatch done = new CountDownLatch(1);
+		scenario.onActivity(activity -> ((WebView) activity.findViewById(R.id.wbvMain))
+				.evaluateJavascript(expression, result -> {
+					value.set(result);
+					done.countDown();
+				}));
+		done.await(5, TimeUnit.SECONDS);
+		return value.get();
+	}
+}

src/androidTestUnbrandedDebug/java/org/medicmobile/webapp/mobile/offlinesync/QrScannerActivityTest.java

@@ -0,0 +1,39 @@
+package org.medicmobile.webapp.mobile.offlinesync;
+
+import static org.junit.Assert.assertNotNull;
+
+import android.Manifest;
+import android.app.Activity;
+import android.app.Instrumentation;
+
+import androidx.test.core.app.ActivityScenario;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.platform.app.InstrumentationRegistry;
+import androidx.test.rule.GrantPermissionRule;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(AndroidJUnit4.class)
+public class QrScannerActivityTest {
+
+	@Rule
+	public GrantPermissionRule cameraPermission = GrantPermissionRule.grant(Manifest.permission.CAMERA);
+
+	@Test
+	public void opensTheScannerScreen() {
+		Instrumentation instrumentation = InstrumentationRegistry.getInstrumentation();
+		Instrumentation.ActivityMonitor scanner = instrumentation.addMonitor(
+				PortraitCaptureActivity.class.getName(), null, false);
+
+		Activity opened;
+		try (ActivityScenario<QrScannerActivity> ignored = ActivityScenario.launch(QrScannerActivity.class)) {
+			opened = instrumentation.waitForMonitorWithTimeout(scanner, 10_000);
+			assertNotNull("the scanner screen never opened", opened);
+		} finally {
+			instrumentation.removeMonitor(scanner);
+		}
+		instrumentation.runOnMainSync(opened::finish);
+	}
+}

src/androidTestUnbrandedDebug/java/org/medicmobile/webapp/mobile/offlinesync/SessionCertificateDeviceTest.java

@@ -0,0 +1,72 @@
+package org.medicmobile.webapp.mobile.offlinesync;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertThrows;
+
+import android.security.keystore.KeyGenParameterSpec;
+import android.security.keystore.KeyProperties;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+
+import java.security.GeneralSecurityException;
+import java.security.KeyPairGenerator;
+import java.security.KeyStore;
+import java.security.PrivateKey;
+import java.security.cert.Certificate;
+import java.util.Collections;
+
+import org.junit.After;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(AndroidJUnit4.class)
+public class SessionCertificateDeviceTest {
+
+	private static final String OTHER = "session-certificate-device-test";
+
+	private SessionCertificate certificate;
+
+	@After
+	public void tearDown() throws Exception {
+		Thread.interrupted();
+		if (certificate != null) {
+			certificate.destroy();
+		}
+		keyStore().deleteEntry(OTHER);
+	}
+
+	@Test
+	public void aFailedHandshake_leavesTheCallingThreadUsable() throws Exception {
+		certificate = SessionCertificate.forDevice("test");
+		certificate.renew();
+		pairOurKeyWithAnotherCertificate();
+
+		assertThrows(GeneralSecurityException.class, certificate::assertUsableOnThisDevice);
+		assertFalse(Thread.currentThread().isInterrupted());
+	}
+
+	/** The served key no longer matches the certificate the self-test pins, so the handshake fails. */
+	private static void pairOurKeyWithAnotherCertificate() throws Exception {
+		KeyPairGenerator generator =
+				KeyPairGenerator.getInstance(KeyProperties.KEY_ALGORITHM_RSA, "AndroidKeyStore");
+		generator.initialize(new KeyGenParameterSpec.Builder(OTHER, KeyProperties.PURPOSE_SIGN)
+				.setDigests(KeyProperties.DIGEST_SHA256)
+				.build());
+		generator.generateKeyPair();
+
+		KeyStore keyStore = keyStore();
+		Certificate other = keyStore.getCertificate(OTHER);
+		for (String alias : Collections.list(keyStore.aliases())) {
+			if (!alias.equals(OTHER)) {
+				PrivateKey ours = (PrivateKey) keyStore.getKey(alias, null);
+				keyStore.setKeyEntry(alias, ours, null, new Certificate[] { other });
+			}
+		}
+	}
+
+	private static KeyStore keyStore() throws Exception {
+		KeyStore keyStore = KeyStore.getInstance("AndroidKeyStore");
+		keyStore.load(null);
+		return keyStore;
+	}
+}

src/main/AndroidManifest.xml

@@ -26,6 +26,16 @@
   <uses-permission android:name="android.permission.SEND_SMS"/>
   -->
 
+  <!-- Offline sync over WiFi hotspot. NEARBY_WIFI_DEVICES only exists from 33, and below it the
+       platform requires location permission for wifi scanning, which is already declared above. -->
+  <uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>
+  <uses-permission android:name="android.permission.CHANGE_WIFI_STATE"/>
+  <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE"/>
+  <uses-permission android:name="android.permission.CAMERA"/>
+  <uses-permission android:name="android.permission.NEARBY_WIFI_DEVICES" android:minSdkVersion="33"/>
+  <uses-feature android:name="android.hardware.wifi" android:required="false"/>
+  <uses-feature android:name="android.hardware.camera" android:required="false"/>
+
   <application android:label="@string/app_name"
       android:icon="@mipmap/ic_launcher"
       android:allowBackup="false"
@@ -99,6 +109,27 @@
         android:permission="android.permission.BIND_JOB_SERVICE"
         android:exported="true"
         tools:targetApi="23" />
+
+    <!-- Offline sync over WiFi hotspot. No cleartext config is declared and none is needed: the
+         only outbound call is the peer's probe of the host, and that is https against a pinned
+         per-session certificate. -->
+    <activity android:name="RequestOfflineSyncPermissionsActivity"
+        android:screenOrientation="portrait"
+        android:exported="false"
+        tools:ignore="DiscouragedApi"/>
+    <activity android:name=".offlinesync.QrScannerActivity"
+        android:screenOrientation="portrait"
+        android:exported="false"
+        tools:ignore="DiscouragedApi"/>
+    <activity android:name=".offlinesync.PortraitCaptureActivity"
+        android:screenOrientation="portrait"
+        android:exported="false"
+        android:clearTaskOnLaunch="true"
+        android:stateNotNeeded="true"
+        android:theme="@style/zxing_CaptureTheme"
+        android:windowSoftInputMode="stateAlwaysHidden"
+        tools:ignore="DiscouragedApi"/>
+
   </application>
 
   <queries>