Release 5.1.1

.github/workflows/instrumented.yml

@@ -4,10 +4,12 @@ on:
   pull_request:
     branches:
       - 'development'
+      - 'master'
+      - '*_baseline'
 
 jobs:
   test:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-20.04
 
     strategy:
       fail-fast: false

CHANGES.txt

@@ -1,3 +1,6 @@
+5.1.1 (Feb 11, 2025)
+- Fixed issue when calling destroy() before the SDK has initialized.
+
 5.1.0 (Jan 17, 2025)
 - Added support for the new impressions tracking toggle available on feature flags, both respecting the setting and including the new field being returned on SplitView type objects. Read more in our docs.
 

build.gradle

@@ -17,7 +17,7 @@ apply plugin: 'kotlin-android'
 apply from: 'spec.gradle'
 
 ext {
-    splitVersion = '5.1.0'
+    splitVersion = '5.1.1'
 }
 
 android {

src/androidTest/java/tests/integration/init/InitializationTest.java

@@ -0,0 +1,196 @@
+package tests.integration.init;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static helper.IntegrationHelper.buildFactory;
+import static helper.IntegrationHelper.emptyAllSegments;
+import static helper.IntegrationHelper.getSinceFromUri;
+
+import android.content.Context;
+
+import androidx.test.platform.app.InstrumentationRegistry;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import helper.DatabaseHelper;
+import helper.FileHelper;
+import helper.IntegrationHelper;
+import io.split.android.client.ServiceEndpoints;
+import io.split.android.client.SplitClient;
+import io.split.android.client.SplitClientConfig;
+import io.split.android.client.SplitFactory;
+import io.split.android.client.api.Key;
+import io.split.android.client.dtos.SplitChange;
+import io.split.android.client.events.SplitEvent;
+import io.split.android.client.utils.Json;
+import io.split.android.client.utils.logger.Logger;
+import io.split.android.client.utils.logger.SplitLogLevel;
+import okhttp3.mockwebserver.Dispatcher;
+import okhttp3.mockwebserver.MockResponse;
+import okhttp3.mockwebserver.MockWebServer;
+import okhttp3.mockwebserver.RecordedRequest;
+import tests.integration.shared.TestingHelper;
+
+public class InitializationTest {
+
+    private final Context mContext = InstrumentationRegistry.getInstrumentation().getContext();
+    private CountDownLatch mRequestCountdownLatch;
+    private MockWebServer mWebServer;
+
+    private AtomicBoolean mEventSent;
+
+    @Before
+    public void setUp() {
+        setupServer();
+        mRequestCountdownLatch = new CountDownLatch(1);
+        mEventSent = new AtomicBoolean(false);
+    }
+
+    @Test
+    public void immediateClientRecreation() throws InterruptedException {
+        SplitFactory factory = getFactory(false);
+        SplitClient client = factory.client();
+        client.track("some_event");
+
+        CountDownLatch latch = new CountDownLatch(1);
+        client.on(SplitEvent.SDK_READY, new TestingHelper.TestEventTask(latch));
+
+        // Wait for the client to be ready
+        boolean readyAwait = latch.await(5, TimeUnit.SECONDS);
+
+        // Destroy it
+        client.destroy();
+
+        // Create a new client; it should be ready since it was created immediately
+        CountDownLatch secondReadyLatch = new CountDownLatch(1);
+        factory.client(new Key("new_key")).on(SplitEvent.SDK_READY, new TestingHelper.TestEventTask(secondReadyLatch));
+        boolean awaitReady2 = secondReadyLatch.await(5, TimeUnit.SECONDS);
+
+        // Wait for events to be posted
+        Thread.sleep(500);
+
+        assertTrue(readyAwait);
+        assertTrue(awaitReady2);
+        assertFalse(mEventSent.get());
+    }
+
+    @Test
+    public void destroyOnFactoryCallsDestroyWithActiveClients() throws InterruptedException {
+        SplitFactory factory = getFactory(false);
+        SplitClient client = factory.client();
+        client.track("some_event");
+
+        CountDownLatch latch = new CountDownLatch(1);
+        client.on(SplitEvent.SDK_READY, new TestingHelper.TestEventTask(latch));
+
+        // Wait for the client to be ready
+        boolean readyAwait = latch.await(5, TimeUnit.SECONDS);
+
+        CountDownLatch secondReadyLatch = new CountDownLatch(1);
+        factory.client(new Key("new_key")).on(SplitEvent.SDK_READY, new TestingHelper.TestEventTask(secondReadyLatch));
+        // Wait for second client to be ready
+        boolean awaitReady2 = secondReadyLatch.await(5, TimeUnit.SECONDS);
+
+        // Destroy the factory
+        factory.destroy();
+        // Wait for events to be posted
+        Thread.sleep(500);
+
+        // Verify event was posted to indirectly verify that the factory was destroyed
+        boolean factoryWasDestroyed = mEventSent.get();
+
+        assertTrue(readyAwait);
+        assertTrue(awaitReady2);
+        assertTrue(factoryWasDestroyed);
+    }
+
+    private SplitFactory getFactory(boolean ready) throws InterruptedException {
+        SplitFactory splitFactory = getSplitFactory();
+        CountDownLatch latch = new CountDownLatch(1);
+        mRequestCountdownLatch.countDown();
+
+        splitFactory.client().on(SplitEvent.SDK_READY, new TestingHelper.TestEventTask(latch));
+        if (ready) {
+            boolean await = latch.await(5, TimeUnit.SECONDS);
+
+            if (!await) {
+                fail("Client was not ready");
+            }
+        }
+
+        return splitFactory;
+    }
+
+    private SplitFactory getSplitFactory() {
+        final String url = mWebServer.url("/").url().toString();
+        ServiceEndpoints endpoints = ServiceEndpoints.builder()
+                .apiEndpoint(url)
+                .eventsEndpoint(url)
+                .telemetryServiceEndpoint(url)
+                .build();
+        SplitClientConfig config = new SplitClientConfig.Builder()
+                .trafficType("user")
+                .serviceEndpoints(endpoints)
+                .streamingEnabled(false)
+                .featuresRefreshRate(9999)
+                .segmentsRefreshRate(9999)
+                .impressionsRefreshRate(9999)
+                .logLevel(SplitLogLevel.VERBOSE)
+                .streamingEnabled(false)
+                .build();
+
+        return buildFactory(IntegrationHelper.dummyApiKey(), IntegrationHelper.dummyUserKey(), config,
+                mContext, null, DatabaseHelper.getTestDatabase(mContext));
+    }
+
+    private void setupServer() {
+        mWebServer = new MockWebServer();
+
+        final Dispatcher dispatcher = new Dispatcher() {
+
+            @Override
+            public MockResponse dispatch(RecordedRequest request) throws InterruptedException {
+                mRequestCountdownLatch.await();
+                Thread.sleep(200);
+                Logger.e("Path is: " + request.getPath());
+                if (request.getPath().contains("/" + IntegrationHelper.ServicePath.MEMBERSHIPS)) {
+                    return new MockResponse().setResponseCode(200).setBody(emptyAllSegments());
+                } else if (request.getPath().contains("/" + IntegrationHelper.ServicePath.SPLIT_CHANGES)) {
+                    String sinceFromUri = getSinceFromUri(request.getRequestUrl().uri());
+                    if (sinceFromUri.equals("-1")) {
+                        return new MockResponse().setResponseCode(200).setBody(loadSplitChanges());
+                    } else {
+                        return new MockResponse().setResponseCode(200)
+                                .setBody(IntegrationHelper.emptySplitChanges(1506703262916L, 1506703262916L));
+                    }
+                } else if (request.getPath().contains("/" + IntegrationHelper.ServicePath.EVENTS)) {
+                    mEventSent.set(true);
+                    return new MockResponse().setResponseCode(200);
+                } else if (request.getPath().contains("/" + IntegrationHelper.ServicePath.COUNT)) {
+                    return new MockResponse().setResponseCode(200);
+                } else if (request.getPath().contains("/" + IntegrationHelper.ServicePath.IMPRESSIONS)) {
+                    return new MockResponse().setResponseCode(200);
+                } else if (request.getPath().contains("/" + IntegrationHelper.ServicePath.UNIQUE_KEYS)) {
+                    return new MockResponse().setResponseCode(200);
+                } else {
+                    return new MockResponse().setResponseCode(404);
+                }
+            }
+        };
+        mWebServer.setDispatcher(dispatcher);
+    }
+
+    private String loadSplitChanges() {
+        FileHelper fileHelper = new FileHelper();
+        String change = fileHelper.loadFileContent(mContext, "split_changes_1.json");
+        SplitChange parsedChange = Json.fromJson(change, SplitChange.class);
+        parsedChange.since = parsedChange.till;
+        return Json.toJson(parsedChange);
+    }
+}

src/main/java/io/split/android/client/SplitClientImpl.java

@@ -77,6 +77,13 @@ public void destroy() {
             if (splitClientContainer.getAll().isEmpty()) {
                 SplitFactory splitFactory = mSplitFactory.get();
                 if (splitFactory != null) {
+                    if (splitFactory instanceof SplitFactoryImpl) {
+                        try {
+                            ((SplitFactoryImpl) splitFactory).checkClients();
+                        } catch (ClassCastException ignored) {
+
+                        }
+                    }
                     splitFactory.destroy();
                 }
             }

src/main/java/io/split/android/client/SplitFactoryHelper.java

@@ -20,6 +20,7 @@
 import java.util.concurrent.ScheduledThreadPoolExecutor;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.ReentrantLock;
 
 import io.split.android.client.common.CompressionUtilProvider;
 import io.split.android.client.events.EventsManagerCoordinator;
@@ -485,6 +486,7 @@ static class Initializer implements Runnable {
 
         private final RolloutCacheManager mRolloutCacheManager;
         private final SplitTaskExecutionListener mListener;
+        private final ReentrantLock mInitLock;
 
         Initializer(
                 String apiToken,
@@ -497,23 +499,28 @@ static class Initializer implements Runnable {
                 SplitSingleThreadTaskExecutor splitSingleThreadTaskExecutor,
                 SplitStorageContainer storageContainer,
                 SyncManager syncManager,
-                SplitLifecycleManager lifecycleManager) {
+                SplitLifecycleManager lifecycleManager,
+                ReentrantLock initLock) {
 
             this(new RolloutCacheManagerImpl(config,
                             storageContainer,
                             splitTaskFactory.createCleanUpDatabaseTask(System.currentTimeMillis() / 1000),
                             splitTaskFactory.createEncryptionMigrationTask(apiToken, splitDatabase, config.encryptionEnabled(), splitCipher)),
-                    new Listener(eventsManagerCoordinator, splitTaskExecutor, splitSingleThreadTaskExecutor, syncManager, lifecycleManager));
+                    new Listener(eventsManagerCoordinator, splitTaskExecutor, splitSingleThreadTaskExecutor, syncManager, lifecycleManager, initLock),
+                    initLock);
         }
 
         @VisibleForTesting
-        Initializer(RolloutCacheManager rolloutCacheManager, SplitTaskExecutionListener listener) {
+        Initializer(RolloutCacheManager rolloutCacheManager, SplitTaskExecutionListener listener, ReentrantLock initLock) {
             mRolloutCacheManager = rolloutCacheManager;
             mListener = listener;
+            mInitLock = initLock;
         }
 
         @Override
         public void run() {
+            Logger.v("Running SDK initializer");
+            mInitLock.lock();
             mRolloutCacheManager.validateCache(mListener);
         }
 
@@ -524,30 +531,38 @@ static class Listener implements SplitTaskExecutionListener {
             private final SplitSingleThreadTaskExecutor mSplitSingleThreadTaskExecutor;
             private final SyncManager mSyncManager;
             private final SplitLifecycleManager mLifecycleManager;
+            private final ReentrantLock mInitLock;
 
             Listener(EventsManagerCoordinator eventsManagerCoordinator,
                      SplitTaskExecutor splitTaskExecutor,
                      SplitSingleThreadTaskExecutor splitSingleThreadTaskExecutor,
                      SyncManager syncManager,
-                     SplitLifecycleManager lifecycleManager) {
+                     SplitLifecycleManager lifecycleManager,
+                     ReentrantLock initLock) {
                 mEventsManagerCoordinator = eventsManagerCoordinator;
                 mSplitTaskExecutor = splitTaskExecutor;
                 mSplitSingleThreadTaskExecutor = splitSingleThreadTaskExecutor;
                 mSyncManager = syncManager;
                 mLifecycleManager = lifecycleManager;
+                mInitLock = initLock;
             }
 
             @Override
             public void taskExecuted(@NonNull SplitTaskExecutionInfo taskInfo) {
-                mEventsManagerCoordinator.notifyInternalEvent(SplitInternalEvent.ENCRYPTION_MIGRATION_DONE);
-
-                mSplitTaskExecutor.resume();
-                mSplitSingleThreadTaskExecutor.resume();
-
-                mSyncManager.start();
-                mLifecycleManager.register(mSyncManager);
-
-                Logger.i("Android SDK initialized!");
+                try {
+                    mEventsManagerCoordinator.notifyInternalEvent(SplitInternalEvent.ENCRYPTION_MIGRATION_DONE);
+
+                    mSplitTaskExecutor.resume();
+                    mSplitSingleThreadTaskExecutor.resume();
+
+                    mSyncManager.start();
+                    mLifecycleManager.register(mSyncManager);
+                    Logger.i("Android SDK initialized!");
+                } catch (Exception e) {
+                    Logger.e("Error initializing Android SDK", e);
+                } finally {
+                    mInitLock.unlock();
+                }
             }
         }
     }