feat(events): persist events to disk so they survive the process (tier 3)

.gitignore

@@ -1,5 +1,5 @@
 .gradle
-/local.properties
+local.properties
 .DS_Store
 build
 /captures

example/build.gradle

@@ -2,8 +2,6 @@ import java.util.Properties
 
 plugins {
     id("com.android.application")
-    // make sure this line comes *after* you apply the Android plugin
-    id("com.getkeepsafe.dexcount")
 }
 
 // local.properties is not checked in, so it is where machine-specific settings such as your mobile

example/src/main/java/com/launchdarkly/example/MainActivity.java

@@ -26,10 +26,6 @@
 
 import java.util.Date;
 import java.util.Locale;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import timber.log.Timber;
@@ -45,6 +41,9 @@ public class MainActivity extends AppCompatActivity {
 
     private static final String DEFAULT_USER_KEY = "user key";
 
+    /** How long startup blocks waiting for the first flags to arrive. */
+    private static final int INIT_WAIT_SECONDS = 10;
+
     private LDClient ldClient;
     private LDStatusListener ldStatusListener;
     private LDAllFlagsListener allFlagsListener;
@@ -142,15 +141,12 @@ public void onCreate(Bundle savedInstanceState) {
                 .set("email", "fake@example.com")
                 .build();
 
-        Future<LDClient> initFuture = LDClient.init(this.getApplication(), ldConfig, context);
-        try {
-            ldClient = initFuture.get(10, TimeUnit.SECONDS);
-            updateStatusString(ldClient.getConnectionInformation());
-            ldClient.registerStatusListener(ldStatusListener);
-            ldClient.registerAllFlagsListener(allFlagsListener);
-        } catch (InterruptedException | ExecutionException | TimeoutException e) {
-            Timber.e(e, "Exception when awaiting LaunchDarkly Client initialization");
-        }
+        // Returns the client either way: if the flags have not arrived within the wait, it is usable
+        // with whatever it has cached.
+        ldClient = LDClient.init(this.getApplication(), ldConfig, context, INIT_WAIT_SECONDS);
+        updateStatusString(ldClient.getConnectionInformation());
+        ldClient.registerStatusListener(ldStatusListener);
+        ldClient.registerAllFlagsListener(allFlagsListener);
     }
 
     private void setupListeners() {

launchdarkly-android-client-sdk/build.gradle

@@ -27,10 +27,30 @@ android {
         // that the app's state is completely cleared between tests.
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
         testInstrumentationRunnerArguments["clearPackageData"] = "true"
+        if (System.getenv("LD_EVENT_BENCH") == "1") {
+            // The device benchmark writes one results file for the class. Orchestrator's
+            // "pm clear" between methods would wipe it, and the runner does not inherit the
+            // shell environment, so the gate is passed as an instrumentation argument.
+            testInstrumentationRunnerArguments["clearPackageData"] = "false"
+            testInstrumentationRunnerArguments["LD_EVENT_BENCH"] = "1"
+        }
     }
 
     testOptions {
-        execution = "ANDROIDX_TEST_ORCHESTRATOR"
+        // EventPersistenceBenchmark on a device keeps one process for the class so its results
+        // file survives; orchestrator would "pm clear" between methods and wipe it.
+        execution = (System.getenv("LD_EVENT_BENCH") == "1") ? "HOST" : "ANDROIDX_TEST_ORCHESTRATOR"
+
+        // EventPersistenceBenchmark reports its measurements on stdout, which Gradle otherwise
+        // swallows, and it is worth re-running even when nothing has changed. Both only apply when
+        // LD_EVENT_BENCH is set, which is also what un-skips the benchmark, so an ordinary test run
+        // is unaffected.
+        unitTests.all { test ->
+            if (System.getenv("LD_EVENT_BENCH") == "1") {
+                test.testLogging.showStandardStreams = true
+                test.outputs.upToDateWhen { false }
+            }
+        }
     }
 
     buildFeatures {
@@ -79,7 +99,7 @@ ext.versions = [
     "jacksonDatabind": "2.10.5.1",
     "junit": "4.13",
     "launchdarklyJavaSdkCommon": "2.4.0",
-    "launchdarklyJavaSdkInternal": "1.9.0",
+    "launchdarklyJavaSdkInternal": "1.12.2",
     "launchdarklyLogging": "1.1.1",
     "okhttp": "4.12.0",
     "testHelpers": "2.1.0",
@@ -106,7 +126,11 @@ dependencies {
     testImplementation("junit:junit:${versions.junit}")
     testImplementation("org.easymock:easymock:4.3")
     testImplementation("com.launchdarkly:test-helpers:${versions.testHelpers}")
+    // The test-helpers class copied into src/test compiles against Guava, which test-helpers only
+    // brings in at runtime. Keep this at the version it resolves to.
+    testCompileOnly("com.google.guava:guava:32.0.1-jre")
     testImplementation(project(":shared-test-code"))
+    testImplementation("com.squareup.okhttp3:mockwebserver:${versions.okhttp}")
 
     androidTestImplementation("junit:junit:${versions.junit}")
     androidTestImplementation("com.squareup.okhttp3:mockwebserver:${versions.okhttp}")

launchdarkly-android-client-sdk/src/androidTest/java/com/launchdarkly/sdk/android/BatchLocksAndroidTest.java

@@ -0,0 +1,77 @@
+package com.launchdarkly.sdk.android;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+
+/**
+ * The way expiry opens a batch on Android before API 26, run on whatever device is attached: the JVM tests
+ * cannot reach it.
+ */
+@RunWith(AndroidJUnit4.class)
+public class BatchLocksAndroidTest {
+    private final File directory =
+            new File(ApplicationProvider.getApplicationContext().getCacheDir(), "batch-locks-test");
+
+    @Before
+    public void createDirectory() {
+        assertTrue(directory.isDirectory() || directory.mkdirs());
+    }
+
+    @After
+    public void deleteDirectory() {
+        File[] files = directory.listFiles();
+        if (files != null) {
+            for (File file : files) {
+                file.delete();
+            }
+        }
+        directory.delete();
+    }
+
+    @Test
+    public void neverCreatesABatchThatHasGone() throws IOException {
+        File gone = new File(directory, "ready-gone-1");
+        try {
+            BatchLocks.openThroughParcelFileDescriptor(gone).close();
+            fail("opened a batch that is not there");
+        } catch (FileNotFoundException expected) {
+            // What expiry takes for a batch someone else has dealt with.
+        }
+        assertFalse(gone.exists());
+    }
+
+    @Test
+    public void locksABatchExclusivelyAndLeavesItAsItWas() throws IOException {
+        File batch = new File(directory, "ready-there-1");
+        byte[] contents = { 1, 2, 3 };
+        try (FileOutputStream out = new FileOutputStream(batch)) {
+            out.write(contents);
+        }
+
+        try (FileChannel channel = BatchLocks.openThroughParcelFileDescriptor(batch);
+             FileLock exclusive = channel.tryLock()) {
+            assertNotNull(exclusive);
+            assertFalse(exclusive.isShared());
+        }
+
+        assertEquals(contents.length, batch.length());
+    }
+}