Revert "refactor: match iOS coexistence model for deferred purchases listener"

This reverts commit 4cf269d.

Author: NickSxti

sdk/src/main/java/com/qonversion/android/sdk/QonversionConfig.kt

@@ -7,6 +7,7 @@ import com.qonversion.android.sdk.dto.QLaunchMode
 import android.content.Context
 import androidx.annotation.RawRes
 import com.qonversion.android.sdk.dto.entitlements.QEntitlementsCacheLifetime
+import com.qonversion.android.sdk.internal.EntitlementsUpdateListenerAdapter
 import com.qonversion.android.sdk.internal.dto.config.CacheConfig
 import com.qonversion.android.sdk.internal.dto.config.PrimaryConfig
 import com.qonversion.android.sdk.internal.application
@@ -27,7 +28,6 @@ class QonversionConfig internal constructor(
     internal val application: Application,
     internal val primaryConfig: PrimaryConfig,
     internal val cacheConfig: CacheConfig,
-    internal val entitlementsUpdateListener: QEntitlementsUpdateListener? = null,
     internal val deferredPurchasesListener: QDeferredPurchasesListener? = null
 ) {
 
@@ -49,7 +49,6 @@ class QonversionConfig internal constructor(
     ) {
         internal var environment = QEnvironment.Production
         internal var entitlementsCacheLifetime = QEntitlementsCacheLifetime.Month
-        internal var entitlementsUpdateListener: QEntitlementsUpdateListener? = null
         internal var deferredPurchasesListener: QDeferredPurchasesListener? = null
         internal var proxyUrl: String? = null
         internal var isKidsMode: Boolean = false
@@ -107,7 +106,9 @@ class QonversionConfig internal constructor(
          */
         @Deprecated("Use setDeferredPurchasesListener instead", ReplaceWith("setDeferredPurchasesListener(listener)"))
         fun setEntitlementsUpdateListener(entitlementsUpdateListener: QEntitlementsUpdateListener): Builder = apply {
-            this.entitlementsUpdateListener = entitlementsUpdateListener
+            // Adapter pattern: wrap the legacy listener so the SDK internally works
+            // with a single listener type (QDeferredPurchasesListener).
+            this.deferredPurchasesListener = EntitlementsUpdateListenerAdapter(entitlementsUpdateListener)
         }
 
         /**
@@ -185,7 +186,6 @@ class QonversionConfig internal constructor(
                 context.application,
                 primaryConfig,
                 cacheConfig,
-                entitlementsUpdateListener,
                 deferredPurchasesListener
             )
         }

sdk/src/main/java/com/qonversion/android/sdk/internal/EntitlementsUpdateListenerAdapter.kt

@@ -0,0 +1,24 @@
+package com.qonversion.android.sdk.internal
+
+import com.qonversion.android.sdk.dto.QPurchaseResult
+import com.qonversion.android.sdk.listeners.QDeferredPurchasesListener
+import com.qonversion.android.sdk.listeners.QEntitlementsUpdateListener
+
+/**
+ * Adapter that wraps a deprecated [QEntitlementsUpdateListener] as a [QDeferredPurchasesListener].
+ *
+ * When the deprecated setEntitlementsUpdateListener() is called, this adapter allows
+ * QProductCenterManager to work with a single listener type internally
+ * (QDeferredPurchasesListener only), eliminating duplicate invocation logic.
+ *
+ * The adapter extracts entitlements from the [QPurchaseResult] and forwards them
+ * to the wrapped legacy listener via onEntitlementsUpdated().
+ */
+internal class EntitlementsUpdateListenerAdapter(
+    private val legacyListener: QEntitlementsUpdateListener
+) : QDeferredPurchasesListener {
+
+    override fun deferredPurchaseCompleted(purchaseResult: QPurchaseResult) {
+        legacyListener.onEntitlementsUpdated(purchaseResult.entitlements)
+    }
+}

sdk/src/main/java/com/qonversion/android/sdk/internal/InternalConfig.kt

@@ -10,12 +10,10 @@ import com.qonversion.android.sdk.internal.provider.EnvironmentProvider
 import com.qonversion.android.sdk.internal.provider.PrimaryConfigProvider
 import com.qonversion.android.sdk.internal.provider.UidProvider
 import com.qonversion.android.sdk.listeners.QDeferredPurchasesListener
-import com.qonversion.android.sdk.listeners.QEntitlementsUpdateListener
 
 internal class InternalConfig(
     override var primaryConfig: PrimaryConfig,
     override val cacheConfig: CacheConfig,
-    var entitlementsUpdateListener: QEntitlementsUpdateListener? = null,
     var deferredPurchasesListener: QDeferredPurchasesListener? = null
 ) : EnvironmentProvider,
     PrimaryConfigProvider,
@@ -35,7 +33,6 @@ internal class InternalConfig(
     constructor(qonversionConfig: QonversionConfig) : this(
         qonversionConfig.primaryConfig,
         qonversionConfig.cacheConfig,
-        qonversionConfig.entitlementsUpdateListener,
         qonversionConfig.deferredPurchasesListener
     )
 

sdk/src/main/java/com/qonversion/android/sdk/internal/QProductCenterManager.kt

@@ -467,7 +467,7 @@ internal class QProductCenterManager internal constructor(
     }
 
     fun setEntitlementsUpdateListener(entitlementsUpdateListener: QEntitlementsUpdateListener) {
-        internalConfig.entitlementsUpdateListener = entitlementsUpdateListener
+        internalConfig.deferredPurchasesListener = EntitlementsUpdateListenerAdapter(entitlementsUpdateListener)
     }
 
     fun setDeferredPurchasesListener(listener: QDeferredPurchasesListener) {
@@ -572,9 +572,6 @@ internal class QProductCenterManager internal constructor(
         if (callback != null) {
             callback.onResult(purchaseResult)
         } else {
-            // Both listeners fire independently (matching iOS behavior)
-            @Suppress("DEPRECATION")
-            internalConfig.entitlementsUpdateListener?.onEntitlementsUpdated(entitlements)
             internalConfig.deferredPurchasesListener?.deferredPurchaseCompleted(purchaseResult)
         }
     }
@@ -1071,9 +1068,6 @@ internal class QProductCenterManager internal constructor(
                         removePurchaseOptions(product?.storeId)
 
                         if (purchaseCallback == null) {
-                            // Both listeners fire independently (matching iOS behavior)
-                            @Suppress("DEPRECATION")
-                            internalConfig.entitlementsUpdateListener?.onEntitlementsUpdated(entitlements)
                             val purchaseResult = QPurchaseResult.success(entitlements, purchase)
                             internalConfig.deferredPurchasesListener?.deferredPurchaseCompleted(purchaseResult)
                         } else {

sdk/src/test/java/com/qonversion/android/sdk/QonversionConfigTest.kt

@@ -11,7 +11,6 @@ import com.qonversion.android.sdk.internal.dto.config.CacheConfig
 import com.qonversion.android.sdk.internal.dto.config.PrimaryConfig
 import com.qonversion.android.sdk.internal.isDebuggable
 import com.qonversion.android.sdk.listeners.QDeferredPurchasesListener
-import com.qonversion.android.sdk.listeners.QEntitlementsUpdateListener
 import io.mockk.every
 import io.mockk.mockk
 import io.mockk.mockkStatic
@@ -33,7 +32,6 @@ internal class QonversionConfigTest {
     private val projectKey = "some project key"
     private val mockLaunchMode = mockk<QLaunchMode>()
     private val mockEnvironment = mockk<QEnvironment>()
-    private val mockEntitlementsUpdateListener = mockk<QEntitlementsUpdateListener>()
     private val mockDeferredPurchasesListener = mockk<QDeferredPurchasesListener>()
     private val mockEntitlementsCacheLifetime = mockk<QEntitlementsCacheLifetime>()
     private val mockProxyUrl = "mock url"
@@ -55,15 +53,13 @@ internal class QonversionConfigTest {
                 mockApplication,
                 mockPrimaryConfig,
                 mockCacheConfig,
-                mockEntitlementsUpdateListener,
                 mockDeferredPurchasesListener
             )
 
             // then
             assertThat(config.application).isSameAs(mockApplication)
             assertThat(config.primaryConfig).isSameAs(mockPrimaryConfig)
             assertThat(config.cacheConfig).isSameAs(mockCacheConfig)
-            assertThat(config.entitlementsUpdateListener).isSameAs(mockEntitlementsUpdateListener)
             assertThat(config.deferredPurchasesListener).isSameAs(mockDeferredPurchasesListener)
         }
     }
@@ -168,15 +164,13 @@ internal class QonversionConfigTest {
                     .apply {
                         environment = mockEnvironment
                         entitlementsCacheLifetime = mockEntitlementsCacheLifetime
-                        entitlementsUpdateListener = mockEntitlementsUpdateListener
                         deferredPurchasesListener = mockDeferredPurchasesListener
                         proxyUrl = mockProxyUrl
                     }
             val expResult = QonversionConfig(
                 mockApplication,
                 mockPrimaryConfig,
                 mockCacheConfig,
-                mockEntitlementsUpdateListener,
                 mockDeferredPurchasesListener
             )
 

sdk/src/test/java/com/qonversion/android/sdk/internal/DeferredPurchasesListenerTest.kt

@@ -17,80 +17,81 @@ import org.robolectric.annotation.Config
 @Config(sdk = [Build.VERSION_CODES.O_MR1])
 internal class DeferredPurchasesListenerTest {
 
-    private lateinit var internalConfig: InternalConfig
+    private val mockConfig = mockk<InternalConfig>(relaxed = true)
 
     @Before
     fun setUp() {
         clearAllMocks()
-        internalConfig = InternalConfig(
-            mockk(relaxed = true),
-            mockk(relaxed = true)
-        )
     }
 
-    // -- Setter tests --
+    // -- Adapter pattern tests --
 
     @Test
-    fun `setDeferredPurchasesListener stores listener`() {
-        val listener = mockk<QDeferredPurchasesListener>()
+    fun `adapter forwards entitlements from purchaseResult to legacy listener`() {
+        // The adapter extracts entitlements from QPurchaseResult and passes them
+        // to the wrapped QEntitlementsUpdateListener - this is the core adapter behavior.
+        val legacyListener = mockk<QEntitlementsUpdateListener>()
+        every { legacyListener.onEntitlementsUpdated(any()) } just Runs
 
-        internalConfig.deferredPurchasesListener = listener
+        val adapter = EntitlementsUpdateListenerAdapter(legacyListener)
 
-        assertEquals(listener, internalConfig.deferredPurchasesListener)
-    }
+        val entitlements = mapOf("premium" to mockk<QEntitlement>())
+        val purchaseResult = mockk<QPurchaseResult>()
+        every { purchaseResult.entitlements } returns entitlements
 
-    @Test
-    fun `setDeferredPurchasesListener to null clears listener`() {
-        val listener = mockk<QDeferredPurchasesListener>()
-        internalConfig.deferredPurchasesListener = listener
-
-        internalConfig.deferredPurchasesListener = null
+        adapter.deferredPurchaseCompleted(purchaseResult)
 
-        assertNull(internalConfig.deferredPurchasesListener)
+        verify(exactly = 1) { legacyListener.onEntitlementsUpdated(entitlements) }
     }
 
     @Test
-    fun `setEntitlementsUpdateListener stores listener`() {
-        val listener = mockk<QEntitlementsUpdateListener>()
+    fun `adapter forwards empty entitlements for consumable products`() {
+        // Consumable products may have no entitlements - the adapter should still
+        // forward the empty map to the legacy listener.
+        val legacyListener = mockk<QEntitlementsUpdateListener>()
+        every { legacyListener.onEntitlementsUpdated(any()) } just Runs
 
-        internalConfig.entitlementsUpdateListener = listener
+        val adapter = EntitlementsUpdateListenerAdapter(legacyListener)
 
-        assertEquals(listener, internalConfig.entitlementsUpdateListener)
-    }
+        val purchaseResult = mockk<QPurchaseResult>()
+        every { purchaseResult.entitlements } returns emptyMap()
 
-    // -- Coexistence tests (match iOS behavior) --
+        adapter.deferredPurchaseCompleted(purchaseResult)
 
-    @Test
-    fun `both listeners can be set independently`() {
-        val deferredListener = mockk<QDeferredPurchasesListener>()
-        val entitlementsListener = mockk<QEntitlementsUpdateListener>()
+        verify(exactly = 1) { legacyListener.onEntitlementsUpdated(emptyMap()) }
+    }
 
-        internalConfig.deferredPurchasesListener = deferredListener
-        internalConfig.entitlementsUpdateListener = entitlementsListener
+    @Test
+    fun `adapter implements QDeferredPurchasesListener interface`() {
+        // The adapter must be a valid QDeferredPurchasesListener so it can replace
+        // the entitlementsUpdateListener everywhere internally.
+        val legacyListener = mockk<QEntitlementsUpdateListener>()
+        val adapter = EntitlementsUpdateListenerAdapter(legacyListener)
 
-        assertEquals(deferredListener, internalConfig.deferredPurchasesListener)
-        assertEquals(entitlementsListener, internalConfig.entitlementsUpdateListener)
+        assertTrue(adapter is QDeferredPurchasesListener)
     }
 
+    // -- Config tests --
+
     @Test
-    fun `setting deferred listener does not affect entitlements listener`() {
-        val entitlementsListener = mockk<QEntitlementsUpdateListener>()
-        internalConfig.entitlementsUpdateListener = entitlementsListener
+    fun `setDeferredPurchasesListener stores listener in config`() {
+        val listener = mockk<QDeferredPurchasesListener>()
+        every { mockConfig.deferredPurchasesListener = any() } just Runs
+        every { mockConfig.deferredPurchasesListener } returns listener
 
-        val deferredListener = mockk<QDeferredPurchasesListener>()
-        internalConfig.deferredPurchasesListener = deferredListener
+        mockConfig.deferredPurchasesListener = listener
 
-        assertEquals(entitlementsListener, internalConfig.entitlementsUpdateListener)
+        assertEquals(listener, mockConfig.deferredPurchasesListener)
+        verify { mockConfig.deferredPurchasesListener = listener }
     }
 
     @Test
-    fun `setting entitlements listener does not affect deferred listener`() {
-        val deferredListener = mockk<QDeferredPurchasesListener>()
-        internalConfig.deferredPurchasesListener = deferredListener
+    fun `setDeferredPurchasesListener to null clears listener`() {
+        every { mockConfig.deferredPurchasesListener = any() } just Runs
+        every { mockConfig.deferredPurchasesListener } returns null
 
-        val entitlementsListener = mockk<QEntitlementsUpdateListener>()
-        internalConfig.entitlementsUpdateListener = entitlementsListener
+        mockConfig.deferredPurchasesListener = null
 
-        assertEquals(deferredListener, internalConfig.deferredPurchasesListener)
+        assertNull(mockConfig.deferredPurchasesListener)
     }
 }

sdk/src/test/java/com/qonversion/android/sdk/internal/InternalConfigTest.kt

@@ -7,7 +7,6 @@ import com.qonversion.android.sdk.internal.dto.config.CacheConfig
 import com.qonversion.android.sdk.internal.dto.config.PrimaryConfig
 import com.qonversion.android.sdk.internal.provider.EnvironmentProvider
 import com.qonversion.android.sdk.listeners.QDeferredPurchasesListener
-import com.qonversion.android.sdk.listeners.QEntitlementsUpdateListener
 import io.mockk.mockk
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.BeforeEach
@@ -19,15 +18,13 @@ internal class InternalConfigTest {
 
     private val mockPrimaryConfig = mockk<PrimaryConfig>()
     private val mockCacheConfig = mockk<CacheConfig>()
-    private val mockEntitlementsUpdateListener = mockk<QEntitlementsUpdateListener>()
     private val mockDeferredPurchasesListener = mockk<QDeferredPurchasesListener>()
 
     @BeforeEach
     fun setUp() {
         internalConfig = InternalConfig(
             mockPrimaryConfig,
             mockCacheConfig,
-            mockEntitlementsUpdateListener,
             mockDeferredPurchasesListener
         )
     }
@@ -47,26 +44,23 @@ internal class InternalConfigTest {
             // then
             assertThat(internalConfig.primaryConfig).isSameAs(mockPrimaryConfig)
             assertThat(internalConfig.cacheConfig).isSameAs(mockCacheConfig)
-            assertThat(internalConfig.entitlementsUpdateListener).isNull()
             assertThat(internalConfig.deferredPurchasesListener).isNull()
         }
 
         @Test
-        fun `primary constructor with both listeners`() {
+        fun `primary constructor with deferred purchases listener`() {
             // given
 
             // when
             val internalConfig = InternalConfig(
                 mockPrimaryConfig,
                 mockCacheConfig,
-                mockEntitlementsUpdateListener,
                 mockDeferredPurchasesListener
             )
 
             // then
             assertThat(internalConfig.primaryConfig).isSameAs(mockPrimaryConfig)
             assertThat(internalConfig.cacheConfig).isSameAs(mockCacheConfig)
-            assertThat(internalConfig.entitlementsUpdateListener).isSameAs(mockEntitlementsUpdateListener)
             assertThat(internalConfig.deferredPurchasesListener).isSameAs(mockDeferredPurchasesListener)
         }
 
@@ -77,7 +71,6 @@ internal class InternalConfigTest {
                 mockk(),
                 mockPrimaryConfig,
                 mockCacheConfig,
-                mockEntitlementsUpdateListener,
                 mockDeferredPurchasesListener
             )
 
@@ -87,7 +80,6 @@ internal class InternalConfigTest {
             // then
             assertThat(internalConfig.primaryConfig).isSameAs(mockPrimaryConfig)
             assertThat(internalConfig.cacheConfig).isSameAs(mockCacheConfig)
-            assertThat(internalConfig.entitlementsUpdateListener).isSameAs(mockEntitlementsUpdateListener)
             assertThat(internalConfig.deferredPurchasesListener).isSameAs(mockDeferredPurchasesListener)
         }
     }