Metadata for killed flag

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

@@ -6,6 +6,8 @@
 import org.junit.Test;
 
 import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -176,6 +178,49 @@ public void testKilledSplit() throws InterruptedException {
         Assert.assertTrue(updateTask.onExecutedCalled);
     }
 
+    @Test
+    public void testKilledSplitWithMetadata() throws InterruptedException {
+        SplitClientConfig cfg = SplitClientConfig.builder().build();
+        SplitEventsManager eventManager = new SplitEventsManager(new SplitTaskExecutorImpl(), cfg.blockUntilReady());
+        eventManager.setExecutionResources(new SplitEventExecutorResourcesMock());
+
+        CountDownLatch readyLatch = new CountDownLatch(1);
+        CountDownLatch updateLatch = new CountDownLatch(1);
+        AtomicReference<EventMetadata> receivedMetadata = new AtomicReference<>();
+
+        // Wait for SDK_READY first
+        eventManager.register(SplitEvent.SDK_READY, new SplitEventTask() {
+            @Override
+            public void onPostExecutionView(SplitClient client) {
+                readyLatch.countDown();
+            }
+        });
+
+        // Register for SDK_UPDATE with metadata callback
+        eventManager.register(SplitEvent.SDK_UPDATE, new SplitEventTask() {
+            @Override
+            public void onPostExecution(SplitClient client, EventMetadata metadata) {
+                receivedMetadata.set(metadata);
+                updateLatch.countDown();
+            }
+        });
+
+        // Make SDK_READY fire
+        eventManager.notifyInternalEvent(SplitInternalEvent.TARGETING_RULES_SYNC_COMPLETE);
+        eventManager.notifyInternalEvent(SplitInternalEvent.MEMBERSHIPS_SYNC_COMPLETE);
+        Assert.assertTrue("SDK_READY should fire", readyLatch.await(5, TimeUnit.SECONDS));
+
+        EventMetadata metadata = EventMetadataHelpers.createUpdatedFlagsMetadata(
+                Collections.singletonList("killed_flag"));
+        eventManager.notifyInternalEvent(SplitInternalEvent.SPLIT_KILLED_NOTIFICATION, metadata);
+
+        Assert.assertTrue("SDK_UPDATE should fire", updateLatch.await(5, TimeUnit.SECONDS));
+        Assert.assertNotNull("Metadata should not be null", receivedMetadata.get());
+        Assert.assertTrue("Metadata should contain updatedFlags", receivedMetadata.get().containsKey("updatedFlags"));
+        List<String> metadataList = (List<String>) receivedMetadata.get().get("updatedFlags");
+        Assert.assertTrue("Metadata should contain only killed_flag", metadataList.size() == 1 && metadataList.contains("killed_flag"));
+    }
+
     @Test
     public void testKilledSplitBeforeReady() throws InterruptedException {
 

main/src/main/java/io/split/android/client/service/splits/SplitKillTask.java

@@ -4,9 +4,13 @@
 
 import androidx.annotation.NonNull;
 
+import java.util.Collections;
+
+import io.split.android.client.api.EventMetadata;
 import io.split.android.client.dtos.Split;
 import io.split.android.client.events.ISplitEventsManager;
 import io.split.android.client.events.SplitInternalEvent;
+import io.split.android.client.events.metadata.EventMetadataHelpers;
 import io.split.android.client.service.executor.SplitTask;
 import io.split.android.client.service.executor.SplitTaskExecutionInfo;
 import io.split.android.client.service.executor.SplitTaskType;
@@ -53,7 +57,9 @@ public SplitTaskExecutionInfo execute() {
             splitToKill.changeNumber = mKilledSplit.changeNumber;
 
             mSplitsStorage.updateWithoutChecks(splitToKill);
-            mEventsManager.notifyInternalEvent(SplitInternalEvent.SPLIT_KILLED_NOTIFICATION);
+            EventMetadata metadata = EventMetadataHelpers.createUpdatedFlagsMetadata(
+                    Collections.singletonList(mKilledSplit.name));
+            mEventsManager.notifyInternalEvent(SplitInternalEvent.SPLIT_KILLED_NOTIFICATION, metadata);
         } catch (Exception e) {
             logError("Unknown error while updating killed feature flag: " + e.getLocalizedMessage());
             return SplitTaskExecutionInfo.error(SplitTaskType.SPLIT_KILL);

main/src/test/java/io/split/android/client/service/SplitKillTaskTest.java

@@ -8,6 +8,9 @@
 import org.mockito.Mock;
 import org.mockito.Mockito;
 
+import java.util.List;
+
+import io.split.android.client.api.EventMetadata;
 import io.split.android.client.dtos.Split;
 import io.split.android.client.events.SplitEventsManager;
 import io.split.android.client.events.SplitInternalEvent;
@@ -20,6 +23,7 @@
 import io.split.android.helpers.FileHelper;
 
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.reset;
@@ -69,7 +73,17 @@ public void correctExecution() throws HttpFetcherException {
         Assert.assertEquals(split.defaultTreatment, splitCaptor.getValue().defaultTreatment);
         Assert.assertEquals(split.changeNumber, splitCaptor.getValue().changeNumber);
         Assert.assertEquals(true, splitCaptor.getValue().killed);
-        verify(mEventsManager, times(1)).notifyInternalEvent(SplitInternalEvent.SPLIT_KILLED_NOTIFICATION);
+
+        ArgumentCaptor<EventMetadata> metadataCaptor = ArgumentCaptor.forClass(EventMetadata.class);
+        verify(mEventsManager, times(1)).notifyInternalEvent(
+                eq(SplitInternalEvent.SPLIT_KILLED_NOTIFICATION), metadataCaptor.capture());
+        EventMetadata metadata = metadataCaptor.getValue();
+        Assert.assertNotNull(metadata);
+        @SuppressWarnings("unchecked")
+        List<String> updatedFlags = (List<String>) metadata.get("updatedFlags");
+        Assert.assertNotNull(updatedFlags);
+        Assert.assertEquals(1, updatedFlags.size());
+        Assert.assertTrue(updatedFlags.contains("split1"));
     }
 
     @Test