[Identity] Simplify readyForEvent by removing unnecessary configuration shared state checks

code/identity/src/main/java/com/adobe/marketing/mobile/identity/IdentityExtension.java

@@ -211,16 +211,32 @@ public boolean readyForEvent(@NonNull final Event event) {
         }
 
         if (isAppendUrlEvent(event) || isGetUrlVarsEvent(event)) {
+            SharedStateResult configState =
+                    getApi().getSharedState(
+                                    IdentityConstants.EventDataKeys.Configuration.MODULE_NAME,
+                                    event,
+                                    false,
+                                    SharedStateResolution.LAST_SET);
+            if (configState == null || configState.getStatus() != SharedStateStatus.SET) {
+                Log.trace(
+                        IdentityConstants.LOG_TAG,
+                        LOG_SOURCE,
+                        "Waiting for the Configuration shared state to be set before processing"
+                                + " [event: %s].",
+                        event.getName());
+                return false;
+            }
+
             // analytics shared state will be null if analytics extension is not registered. Wait
-            // for analytics shared only if the status is pending or none
-            SharedStateResult sharedStateResult =
+            // for analytics shared state only if the extension is registered and the status is not
+            // set.
+            SharedStateResult analyticsState =
                     getApi().getSharedState(
                                     IdentityConstants.EventDataKeys.Analytics.MODULE_NAME,
                                     event,
                                     false,
                                     SharedStateResolution.LAST_SET);
-            if (sharedStateResult != null
-                    && sharedStateResult.getStatus() != SharedStateStatus.SET) {
+            if (analyticsState != null && analyticsState.getStatus() != SharedStateStatus.SET) {
                 Log.trace(
                         IdentityConstants.LOG_TAG,
                         LOG_SOURCE,
@@ -231,18 +247,7 @@ public boolean readyForEvent(@NonNull final Event event) {
             }
         }
 
-        if (!hasValidSharedState(
-                IdentityConstants.EventDataKeys.Configuration.MODULE_NAME, event)) {
-            Log.trace(
-                    IdentityConstants.LOG_TAG,
-                    LOG_SOURCE,
-                    "Waiting for the Configuration shared state to get required configuration"
-                            + " fields before processing [event: %s].",
-                    event.getName());
-            return false;
-        } else {
-            return true;
-        }
+        return true;
     }
 
     @VisibleForTesting
@@ -307,17 +312,6 @@ boolean forceSyncIdentifiers(@NonNull final Event event) {
         return hasSynced;
     }
 
-    private boolean hasValidSharedState(final String extensionName, final Event event) {
-        SharedStateResult sharedStateResult =
-                getApi().getSharedState(
-                                extensionName, event, false, SharedStateResolution.LAST_SET);
-        if (sharedStateResult == null || sharedStateResult.getStatus() != SharedStateStatus.SET) {
-            return false;
-        }
-        Map<String, Object> sharedStateValue = sharedStateResult.getValue();
-        return !MapUtils.isNullOrEmpty(sharedStateValue);
-    }
-
     private void boot() {
         loadVariablesFromPersistentData();
         deleteDeprecatedV5HitDatabase();

code/identity/src/test/java/com/adobe/marketing/mobile/identity/IdentityExtensionTests.kt

@@ -151,6 +151,22 @@ class IdentityExtensionTests {
         )
     }
 
+    @Test
+    fun `readyForEvent() should not check for configuration shared state after forceSync for unrelated events`() {
+        val identityExtension = initializeSpiedIdentityExtension()
+        identityExtension.onRegistered()
+        identityExtension.setHasSynced(true)
+
+        val result = identityExtension.readyForEvent(
+            Event.Builder("event", "type", "source").build()
+        )
+        assertTrue(result)
+
+        // Verify that getSharedState is never called during readyForEvent()
+        Mockito.verify(mockedExtensionApi, never())
+            .getSharedState(any(), anyOrNull(), any(), any())
+    }
+
     @Test
     fun `readyForEvent() should return false if configuration is not registered`() {
         val identityExtension = initializeSpiedIdentityExtension()
@@ -194,6 +210,30 @@ class IdentityExtensionTests {
         )
     }
 
+    @Test
+    fun `readyForEvent() should return false for appendUrl and urlVars events if Configuration shared state is pending`() {
+        val identityExtension = initializeSpiedIdentityExtension()
+        identityExtension.onRegistered()
+        identityExtension.setHasSynced(true)
+        Mockito.`when`(
+            mockedExtensionApi.getSharedState(any(), anyOrNull(), any(), any())
+        ).thenAnswer { invocation ->
+            val extension = invocation.arguments[0] as? String
+            if ("com.adobe.module.configuration" === extension) {
+                return@thenAnswer SharedStateResult(
+                    SharedStateStatus.PENDING,
+                    null
+                )
+            }
+            if ("com.adobe.module.analytics" === extension) {
+                return@thenAnswer null
+            }
+            return@thenAnswer null
+        }
+        assertFalse(identityExtension.readyForEvent(appendToUrlEvent))
+        assertFalse(identityExtension.readyForEvent(urlVariablesEvent))
+    }
+
     @Test
     fun `readyForEvent() should return true for appendUrl and urlVars events if Analytics extension is not registered`() {
         val identityExtension = initializeSpiedIdentityExtension()

code/integration-tests/src/androidTest/java/com/adobe/marketing/mobile/integration/identity/IdentityIntegrationTests.kt

@@ -266,6 +266,56 @@ class IdentityIntegrationTests {
         assertTrue("Timeout waiting for force sync network request after updating configuration with valid org id.", countDownLatchSecondNetworkMonitor.await(TEST_TIMEOUT, TimeUnit.MILLISECONDS))
     }
 
+    @Test(timeout = 10_000)
+    fun testIdentityBehavior_whenInitialConfigurationSharedStateChange_isEmptyDictionary() {
+        //PLATIR-52517
+        var countDownLatchNetworkMonitor = CountDownLatch(1)
+        networkMonitor = { url ->
+            if (url.contains("https://test.com/id")) {
+                countDownLatchNetworkMonitor.countDown()
+            }
+        }
+
+        // This publishes the first configuration shared state as empty dictionary.
+        MobileCore.updateConfiguration(
+            emptyMap()
+        )
+        val configurationLatch = CountDownLatch(1)
+        configurationAwareness { configurationLatch.countDown() }
+        configurationLatch.await()
+
+        // No  sync request is sent on empty configuration
+        assertFalse(countDownLatchNetworkMonitor.await(TEST_TIMEOUT, TimeUnit.MILLISECONDS))
+
+        // Verify ECID retrieval fails when Configuration Shared State is `{}` (empty).
+        val result = getExperienceCouldId(TEST_TIMEOUT)
+        assertFalse(result.first)
+
+        countDownLatchNetworkMonitor = CountDownLatch(1)
+        networkMonitor = { url ->
+            if (url.contains("https://test.com/id")) {
+                assertTrue(url.contains("d_orgid=orgid"))
+                assertTrue(url.contains("d_mid="))
+                countDownLatchNetworkMonitor.countDown()
+            }
+        }
+
+        // Set valid configuration
+        MobileCore.updateConfiguration(
+            mapOf(
+                "experienceCloud.org" to "orgid",
+                "experienceCloud.server" to "test.com",
+                "global.privacy" to "optedin"
+            )
+        )
+
+        // Sync request should be sent now that the required configuration keys are present
+        assertTrue(countDownLatchNetworkMonitor.await(TEST_TIMEOUT, TimeUnit.MILLISECONDS))
+
+        // ECID retrieval should succeed as Identity extension has generated ECID.
+        assertEquals(Pair(true, loadStoreMid()), getExperienceCouldId(TEST_TIMEOUT))
+    }
+
     @Test(timeout = TEST_TIMEOUT)
     fun testOptedout() {
         val countDownLatch = CountDownLatch(1)
@@ -619,4 +669,29 @@ class IdentityIntegrationTests {
         MonitorExtension.configurationAwareness(callback)
     }
 
+    private fun getExperienceCouldId(timeoutMillis: Long = 1000): Pair<Boolean, String?> {
+        val latch = CountDownLatch(1)
+        var ecid: String? = null
+        var success = false
+
+        Identity.getExperienceCloudId(object : AdobeCallbackWithError<String> {
+            override fun call(value: String?) {
+                ecid = value
+                success = true
+                latch.countDown()
+            }
+
+            override fun fail(error: AdobeError?) {
+                success = false
+                latch.countDown()
+            }
+        })
+
+        return if (latch.await(timeoutMillis, TimeUnit.MILLISECONDS)) {
+            Pair(success, ecid)
+        } else {
+            Pair(false, null)
+        }
+    }
+
 }