Remove synthetic sync events

events-domain/src/main/java/io/split/android/client/events/EventsManagerCoordinator.java

@@ -26,7 +26,7 @@ public class EventsManagerCoordinator implements ISplitEventsManager, EventsMana
      */
     private static final Set<SplitInternalEvent> SDK_SCOPED_EVENTS = EnumSet.of(
             SplitInternalEvent.SPLITS_UPDATED,
-            SplitInternalEvent.SPLITS_FETCHED,
+            SplitInternalEvent.TARGETING_RULES_SYNC_COMPLETE,
             SplitInternalEvent.SPLITS_LOADED_FROM_STORAGE,
             SplitInternalEvent.SPLIT_KILLED_NOTIFICATION,
             SplitInternalEvent.RULE_BASED_SEGMENTS_UPDATED,

events-domain/src/main/java/io/split/android/client/events/SplitEventsManager.java

@@ -80,20 +80,7 @@ public SplitEventExecutorResources getExecutorResources() {
     @Override
     public void notifyInternalEvent(SplitInternalEvent internalEvent) {
         requireNonNull(internalEvent);
-
-        // Skip FETCHED events after SDK_READY to prevent unnecessary SDK_UPDATE triggers.
-        // TODO: This is temporary until *_FETCHED and *_UPDATED events are unified.
-        if ((internalEvent == SplitInternalEvent.SPLITS_FETCHED
-                || internalEvent == SplitInternalEvent.MY_SEGMENTS_FETCHED)
-                && eventAlreadyTriggered(SplitEvent.SDK_READY)) {
-            return;
-        }
-
-        // Notify the actual internal event
         mEventsManager.notifyInternalEvent(internalEvent, null);
-
-        // Also notify the synthetic composite events for SDK_READY evaluation
-        notifySyntheticEventsIfNeeded(internalEvent);
     }
 
     /**
@@ -104,16 +91,7 @@ && eventAlreadyTriggered(SplitEvent.SDK_READY)) {
      */
     public void notifyInternalEvent(SplitInternalEvent internalEvent, EventMetadata metadata) {
         requireNonNull(internalEvent);
-
-        // Skip FETCHED events after SDK_READY
-        if ((internalEvent == SplitInternalEvent.SPLITS_FETCHED
-                || internalEvent == SplitInternalEvent.MY_SEGMENTS_FETCHED)
-                && eventAlreadyTriggered(SplitEvent.SDK_READY)) {
-            return;
-        }
-
         mEventsManager.notifyInternalEvent(internalEvent, metadata);
-        notifySyntheticEventsIfNeeded(internalEvent);
     }
 
     @Override
@@ -143,32 +121,6 @@ public void destroy() {
         mEventsManager.destroy();
     }
 
-    /**
-     * Notifies the synthetic composite events based on the actual internal event.
-     * These synthetic events simplify the SDK_READY condition evaluation.
-     * The prerequisite configuration ensures SDK_READY_FROM_CACHE always fires before SDK_READY.
-     * <p>
-     * TODO: Remove this method once EventsManagerConfig is updated.
-     */
-    private void notifySyntheticEventsIfNeeded(SplitInternalEvent internalEvent) {
-        switch (internalEvent) {
-            case SPLITS_UPDATED:
-            case SPLITS_FETCHED:
-                mEventsManager.notifyInternalEvent(SplitInternalEvent.SPLITS_SYNC_COMPLETE, null);
-                break;
-
-            case MY_SEGMENTS_UPDATED:
-            case MY_SEGMENTS_FETCHED:
-            case MY_LARGE_SEGMENTS_UPDATED:
-                mEventsManager.notifyInternalEvent(SplitInternalEvent.SEGMENTS_SYNC_COMPLETE, null);
-                break;
-
-            default:
-                // No synthetic event needed for other internal events
-                break;
-        }
-    }
-
     private void startTimeoutThread(final int blockUntilReady) {
         Thread timeoutThread = new Thread(new Runnable() {
             @Override

events-domain/src/main/java/io/split/android/client/events/SplitEventsManagerConfigFactory.java

@@ -41,13 +41,13 @@ static EventsManagerConfig<SplitEvent, SplitInternalEvent> create() {
         cacheGroup.add(SplitInternalEvent.ENCRYPTION_MIGRATION_DONE);
 
         Set<SplitInternalEvent> syncGroup = new HashSet<>();
-        syncGroup.add(SplitInternalEvent.SPLITS_SYNC_COMPLETE);
-        syncGroup.add(SplitInternalEvent.SEGMENTS_SYNC_COMPLETE);
+        syncGroup.add(SplitInternalEvent.TARGETING_RULES_SYNC_COMPLETE);
+        syncGroup.add(SplitInternalEvent.MEMBERSHIPS_SYNC_COMPLETE);
 
         return EventsManagerConfig.<SplitEvent, SplitInternalEvent>builder()
                 .requireAll(SplitEvent.SDK_READY,
-                        SplitInternalEvent.SPLITS_SYNC_COMPLETE,
-                        SplitInternalEvent.SEGMENTS_SYNC_COMPLETE)
+                        SplitInternalEvent.TARGETING_RULES_SYNC_COMPLETE,
+                        SplitInternalEvent.MEMBERSHIPS_SYNC_COMPLETE)
 
                 // SDK_READY_FROM_CACHE: OR of ANDs
                 // Fires when (cache group all done) OR (sync group all done)

events-domain/src/main/java/io/split/android/client/events/SplitInternalEvent.java

@@ -1,33 +1,26 @@
 package io.split.android.client.events;
 
 /**
- * Created by sarrubia on 4/6/18.
+ * Internal events used to track SDK initialization and data updates.
  */
-
 public enum SplitInternalEvent {
+    // Cache loading events
     MY_SEGMENTS_LOADED_FROM_STORAGE,
     SPLITS_LOADED_FROM_STORAGE,
-    MY_SEGMENTS_FETCHED,
-    MY_SEGMENTS_UPDATED,
-    SPLITS_FETCHED,
-    SPLITS_UPDATED,
-    SDK_READY_TIMEOUT_REACHED,
-    SPLIT_KILLED_NOTIFICATION,
     ATTRIBUTES_LOADED_FROM_STORAGE,
     ENCRYPTION_MIGRATION_DONE,
+
+    // Data update events (fired only when data actually changed)
+    MY_SEGMENTS_UPDATED,
+    SPLITS_UPDATED,
     MY_LARGE_SEGMENTS_UPDATED,
     RULE_BASED_SEGMENTS_UPDATED,
+    SPLIT_KILLED_NOTIFICATION,
 
-    /**
-     * Synthetic event: fired when splits sync completes (either SPLITS_FETCHED or SPLITS_UPDATED).
-     * Used internally to simplify SDK_READY and SDK_READY_FROM_CACHE condition evaluation.
-     */
-    SPLITS_SYNC_COMPLETE,
+    // Sync completion events (fired when sync completes, regardless of data change)
+    TARGETING_RULES_SYNC_COMPLETE,
+    MEMBERSHIPS_SYNC_COMPLETE,
 
-    /**
-     * Synthetic event: fired when segments sync completes (any of MY_SEGMENTS_FETCHED,
-     * MY_SEGMENTS_UPDATED, or MY_LARGE_SEGMENTS_UPDATED).
-     * Used internally to simplify SDK_READY and SDK_READY_FROM_CACHE condition evaluation.
-     */
-    SEGMENTS_SYNC_COMPLETE,
+    // Other events
+    SDK_READY_TIMEOUT_REACHED,
 }

main/src/androidTest/java/tests/service/EventsManagerTest.java

@@ -13,7 +13,6 @@
 import io.split.android.client.events.SplitEventsManager;
 import io.split.android.client.events.SplitInternalEvent;
 import io.split.android.client.service.executor.SplitTaskExecutorImpl;
-import io.split.android.client.service.synchronizer.ThreadUtils;
 
 public class EventsManagerTest {
     @Test
@@ -37,7 +36,7 @@ public void testSdkUpdateSplits() throws InterruptedException {
     }
 
     @Test
-    public void testSdkFetchedUpdatedSplits() throws InterruptedException {
+    public void testSdkUpdateTriggersAfterReady() throws InterruptedException {
 
         SplitClientConfig cfg = SplitClientConfig.builder().build();
         SplitEventsManager eventManager = new SplitEventsManager(new SplitTaskExecutorImpl(), cfg.blockUntilReady());
@@ -47,8 +46,10 @@ public void testSdkFetchedUpdatedSplits() throws InterruptedException {
         TestingHelper.TestEventTask updateTask = TestingHelper.testTask(updateLatch);
         eventManager.register(SplitEvent.SDK_UPDATE, updateTask);
 
-        eventManager.notifyInternalEvent(SplitInternalEvent.MY_SEGMENTS_UPDATED);
-        eventManager.notifyInternalEvent(SplitInternalEvent.SPLITS_FETCHED);
+        // First make SDK_READY fire by completing sync
+        eventManager.notifyInternalEvent(SplitInternalEvent.MEMBERSHIPS_SYNC_COMPLETE);
+        eventManager.notifyInternalEvent(SplitInternalEvent.TARGETING_RULES_SYNC_COMPLETE);
+        // Then trigger SDK_UPDATE with a data change
         eventManager.notifyInternalEvent(SplitInternalEvent.SPLITS_UPDATED);
 
         updateLatch.await(5, TimeUnit.SECONDS);
@@ -57,7 +58,7 @@ public void testSdkFetchedUpdatedSplits() throws InterruptedException {
     }
 
     @Test
-    public void testSdkUpdatedFetchedSplits() throws InterruptedException {
+    public void testSdkUpdateDoesNotTriggerBeforeReady() throws InterruptedException {
 
         SplitClientConfig cfg = SplitClientConfig.builder().build();
         SplitEventsManager eventManager = new SplitEventsManager(new SplitTaskExecutorImpl(), cfg.blockUntilReady());
@@ -67,12 +68,11 @@ public void testSdkUpdatedFetchedSplits() throws InterruptedException {
         TestingHelper.TestEventTask updateTask = TestingHelper.testTask(updateLatch);
         eventManager.register(SplitEvent.SDK_UPDATE, updateTask);
 
-        eventManager.notifyInternalEvent(SplitInternalEvent.MY_SEGMENTS_UPDATED);
+        // Fire UPDATED before SDK_READY - should NOT trigger SDK_UPDATE due to prerequisite
         eventManager.notifyInternalEvent(SplitInternalEvent.SPLITS_UPDATED);
-        eventManager.notifyInternalEvent(SplitInternalEvent.SPLITS_FETCHED);
-
+        eventManager.notifyInternalEvent(SplitInternalEvent.MY_SEGMENTS_UPDATED);
 
-        updateLatch.await(5, TimeUnit.SECONDS);
+        updateLatch.await(2, TimeUnit.SECONDS);
 
         Assert.assertFalse(updateTask.onExecutedCalled);
     }
@@ -98,7 +98,7 @@ public void testSdkUpdateSegments() throws InterruptedException {
     }
 
     @Test
-    public void testSdkFetchedUpdatedSegments() throws InterruptedException {
+    public void testSdkUpdateTriggersOnSegmentChange() throws InterruptedException {
 
         SplitClientConfig cfg = SplitClientConfig.builder().build();
         SplitEventsManager eventManager = new SplitEventsManager(new SplitTaskExecutorImpl(), cfg.blockUntilReady());
@@ -108,8 +108,10 @@ public void testSdkFetchedUpdatedSegments() throws InterruptedException {
         TestingHelper.TestEventTask updateTask = TestingHelper.testTask(updateLatch);
         eventManager.register(SplitEvent.SDK_UPDATE, updateTask);
 
-        eventManager.notifyInternalEvent(SplitInternalEvent.SPLITS_UPDATED);
-        eventManager.notifyInternalEvent(SplitInternalEvent.MY_SEGMENTS_FETCHED);
+        // Make SDK_READY fire
+        eventManager.notifyInternalEvent(SplitInternalEvent.TARGETING_RULES_SYNC_COMPLETE);
+        eventManager.notifyInternalEvent(SplitInternalEvent.MEMBERSHIPS_SYNC_COMPLETE);
+        // Then trigger SDK_UPDATE with a segment change
         eventManager.notifyInternalEvent(SplitInternalEvent.MY_SEGMENTS_UPDATED);
 
         updateLatch.await(5, TimeUnit.SECONDS);
@@ -118,7 +120,7 @@ public void testSdkFetchedUpdatedSegments() throws InterruptedException {
     }
 
     @Test
-    public void testSdkUpdatedFetchedSegments() throws InterruptedException {
+    public void testSdkUpdateRequiresDataChange() throws InterruptedException {
 
         SplitClientConfig cfg = SplitClientConfig.builder().build();
         SplitEventsManager eventManager = new SplitEventsManager(new SplitTaskExecutorImpl(), cfg.blockUntilReady());
@@ -128,13 +130,14 @@ public void testSdkUpdatedFetchedSegments() throws InterruptedException {
         TestingHelper.TestEventTask updateTask = TestingHelper.testTask(updateLatch);
         eventManager.register(SplitEvent.SDK_UPDATE, updateTask);
 
-        eventManager.notifyInternalEvent(SplitInternalEvent.SPLITS_UPDATED);
-        eventManager.notifyInternalEvent(SplitInternalEvent.MY_SEGMENTS_UPDATED);
-        eventManager.notifyInternalEvent(SplitInternalEvent.MY_SEGMENTS_FETCHED);
+        // Make SDK_READY fire with only SYNC_COMPLETE events (no UPDATED)
+        eventManager.notifyInternalEvent(SplitInternalEvent.TARGETING_RULES_SYNC_COMPLETE);
+        eventManager.notifyInternalEvent(SplitInternalEvent.MEMBERSHIPS_SYNC_COMPLETE);
+        // No UPDATED events fired
 
+        updateLatch.await(2, TimeUnit.SECONDS);
 
-        updateLatch.await(5, TimeUnit.SECONDS);
-
+        // SDK_UPDATE should NOT fire because no data actually changed
         Assert.assertFalse(updateTask.onExecutedCalled);
     }
 

main/src/main/java/io/split/android/client/localhost/LocalhostSplitsStorage.java

@@ -216,7 +216,7 @@ private void loadSplits() {
             }
             if (!content.equals(mLastContentLoaded)) {
                 mEventsManager.notifyInternalEvent(SplitInternalEvent.SPLITS_LOADED_FROM_STORAGE);
-                mEventsManager.notifyInternalEvent(SplitInternalEvent.SPLITS_FETCHED);
+                mEventsManager.notifyInternalEvent(SplitInternalEvent.TARGETING_RULES_SYNC_COMPLETE);
                 mEventsManager.notifyInternalEvent(SplitInternalEvent.SPLITS_UPDATED);
             }
             mLastContentLoaded = content;

main/src/main/java/io/split/android/client/localhost/shared/LocalhostSplitClientContainerImpl.java

@@ -1,5 +1,7 @@
 package io.split.android.client.localhost.shared;
 
+import androidx.annotation.VisibleForTesting;
+
 import io.split.android.client.FlagSetsFilter;
 import io.split.android.client.SplitClient;
 import io.split.android.client.SplitClientConfig;
@@ -31,6 +33,7 @@ public class LocalhostSplitClientContainerImpl extends BaseSplitClientContainer
     private final EventsManagerCoordinator mEventsManagerCoordinator;
     private final SplitTaskExecutor mSplitTaskExecutor;
     private final FlagSetsFilter mFlagSetsFilter;
+    private final SplitEventsManagerFactory mEventsManagerFactory;
 
     public LocalhostSplitClientContainerImpl(LocalhostSplitFactory splitFactory,
                                              SplitClientConfig config,
@@ -42,6 +45,24 @@ public LocalhostSplitClientContainerImpl(LocalhostSplitFactory splitFactory,
                                              EventsManagerCoordinator eventsManagerCoordinator,
                                              SplitTaskExecutor taskExecutor,
                                              FlagSetsFilter flagSetsFilter) {
+        this(splitFactory, config, splitsStorage, splitParser, attributesManagerFactory,
+                attributesMerger, telemetryStorageProducer, eventsManagerCoordinator,
+                taskExecutor, flagSetsFilter,
+                new DefaultSplitEventsManagerFactory(taskExecutor, config));
+    }
+
+    @VisibleForTesting
+    LocalhostSplitClientContainerImpl(LocalhostSplitFactory splitFactory,
+                                      SplitClientConfig config,
+                                      SplitsStorage splitsStorage,
+                                      SplitParser splitParser,
+                                      AttributesManagerFactory attributesManagerFactory,
+                                      AttributesMerger attributesMerger,
+                                      TelemetryStorageProducer telemetryStorageProducer,
+                                      EventsManagerCoordinator eventsManagerCoordinator,
+                                      SplitTaskExecutor taskExecutor,
+                                      FlagSetsFilter flagSetsFilter,
+                                      SplitEventsManagerFactory eventsManagerFactory) {
         mSplitFactory = splitFactory;
         mConfig = config;
         mSplitStorage = splitsStorage;
@@ -52,13 +73,14 @@ public LocalhostSplitClientContainerImpl(LocalhostSplitFactory splitFactory,
         mEventsManagerCoordinator = eventsManagerCoordinator;
         mSplitTaskExecutor = taskExecutor;
         mFlagSetsFilter = flagSetsFilter;
+        mEventsManagerFactory = eventsManagerFactory;
     }
 
     @Override
     protected void createNewClient(Key key) {
-        SplitEventsManager eventsManager = new SplitEventsManager(mSplitTaskExecutor, mConfig.blockUntilReady());
+        SplitEventsManager eventsManager = mEventsManagerFactory.create();
         eventsManager.notifyInternalEvent(SplitInternalEvent.MY_SEGMENTS_LOADED_FROM_STORAGE);
-        eventsManager.notifyInternalEvent(SplitInternalEvent.MY_SEGMENTS_FETCHED);
+        eventsManager.notifyInternalEvent(SplitInternalEvent.MEMBERSHIPS_SYNC_COMPLETE);
         eventsManager.notifyInternalEvent(SplitInternalEvent.MY_SEGMENTS_UPDATED);
 
         AttributesStorageImpl attributesStorage = new AttributesStorageImpl();
@@ -88,4 +110,19 @@ protected void createNewClient(Key key) {
     public void destroy() {
         // No-op
     }
+
+    private static class DefaultSplitEventsManagerFactory implements SplitEventsManagerFactory {
+        private final SplitTaskExecutor mTaskExecutor;
+        private final int mBlockUntilReady;
+
+        DefaultSplitEventsManagerFactory(SplitTaskExecutor taskExecutor, SplitClientConfig config) {
+            mTaskExecutor = taskExecutor;
+            mBlockUntilReady = config.blockUntilReady();
+        }
+
+        @Override
+        public SplitEventsManager create() {
+            return new SplitEventsManager(mTaskExecutor, mBlockUntilReady);
+        }
+    }
 }

main/src/main/java/io/split/android/client/localhost/shared/SplitEventsManagerFactory.java

@@ -0,0 +1,17 @@
+package io.split.android.client.localhost.shared;
+
+import io.split.android.client.events.SplitEventsManager;
+
+/**
+ * Factory interface for creating SplitEventsManager instances.
+ * Package-local interface to allow testing by injecting mock implementations.
+ */
+interface SplitEventsManagerFactory {
+    /**
+     * Creates a new SplitEventsManager instance.
+     *
+     * @return a new SplitEventsManager instance
+     */
+    SplitEventsManager create();
+}
+