feat: Allow Client to Manually Call Appsflyer Start

BrandonStalnaker · BrandonStalnaker · commit 3acfe267c691 · 2026-03-18T13:26:47.000-04:00
diff --git a/src/main/kotlin/com/mparticle/kits/AppsFlyerKit.kt b/src/main/kotlin/com/mparticle/kits/AppsFlyerKit.kt
@@ -62,12 +62,12 @@ class AppsFlyerKit :
                 MParticle.getInstance()?.environment == MParticle.Environment.Development,
             )
         settings[DEV_KEY]?.let { AppsFlyerLib.getInstance().init(it, this, context) }
-        setting?.get(SHARING_FILTER_FOR_PARTNERS)?.let {
-            applySharingFilterForPartners(it)
-        }
         val userConsentState = currentUser?.consentState
         setConsent(userConsentState)
-        AppsFlyerLib.getInstance().start(context.applicationContext)
+        updateCustomerUserIdFromMpid()
+        if (!isManualStart()) {
+            AppsFlyerLib.getInstance().start(context.applicationContext)
+        }
         AppsFlyerLib.getInstance().setCollectAndroidID(MParticle.isAndroidIdEnabled())
         val integrationAttributes = HashMap<String, String?>(1)
         integrationAttributes[APPSFLYERID_INTEGRATION_KEY] =
@@ -307,7 +307,9 @@ class AppsFlyerKit :
 
     override fun removeUserIdentity(identityType: MParticle.IdentityType) {
         with(instance) {
-            if (MParticle.IdentityType.CustomerId == identityType) {
+            if (isUserIdentificationMpid()) {
+                updateCustomerUserIdFromMpid()
+            } else if (MParticle.IdentityType.CustomerId == identityType) {
                 setCustomerUserId("")
             } else if (MParticle.IdentityType.Email == identityType) {
                 setUserEmails(AppsFlyerProperties.EmailsCryptType.NONE, "")
@@ -320,7 +322,9 @@ class AppsFlyerKit :
         identity: String,
     ) {
         with(instance) {
-            if (MParticle.IdentityType.CustomerId == identityType) {
+            if (isUserIdentificationMpid()) {
+                updateCustomerUserIdFromMpid()
+            } else if (MParticle.IdentityType.CustomerId == identityType) {
                 setCustomerUserId(identity)
             } else if (MParticle.IdentityType.Email == identityType) {
                 setUserEmails(AppsFlyerProperties.EmailsCryptType.NONE, identity)
@@ -559,7 +563,9 @@ class AppsFlyerKit :
         activity: Activity,
         bundle: Bundle?,
     ): List<ReportingMessage> {
-        instance.start(activity)
+        if (!isManualStart()) {
+            instance.start(activity)
+        }
         return emptyList()
     }
 
@@ -578,30 +584,16 @@ class AppsFlyerKit :
 
     override fun onActivityDestroyed(activity: Activity): List<ReportingMessage> = emptyList()
 
-    override fun onSettingsUpdated(settings: Map<String, String>) {
-        settings[SHARING_FILTER_FOR_PARTNERS]?.let { applySharingFilterForPartners(it) }
-    }
+    private fun isManualStart(): Boolean =
+        settings[MANUAL_START]?.lowercase() == "true"
 
-    private fun applySharingFilterForPartners(jsonValue: String) {
-        val partners = parseSharingFilterForPartners(jsonValue)
-        if (!partners.isNullOrEmpty()) {
-            instance.setSharingFilterForPartners(*partners.toTypedArray())
-        }
-    }
+    private fun isUserIdentificationMpid(): Boolean =
+        settings[USER_IDENTIFICATION_TYPE] == USER_IDENTIFICATION_MPID
 
-    private fun parseSharingFilterForPartners(json: String?): List<String>? {
-        if (json.isNullOrEmpty()) return null
-        return try {
-            val jsonWithFormat = json.replace("\\", "")
-            val array = JSONArray(jsonWithFormat)
-            List(array.length()) { i -> array.getString(i) }
-        } catch (e: JSONException) {
-            Logger.warning(
-                "AppsFlyer kit: failed to parse sharingFilterForPartners, " +
-                    "consent filter for partners will not be applied. Error: ${e.message}",
-            )
-            null
-        }
+    private fun updateCustomerUserIdFromMpid() {
+        if (!isUserIdentificationMpid()) return
+        val mpid = currentUser?.id ?: return
+        instance.setCustomerUserId(mpid.toString())
     }
 
     companion object {
@@ -630,7 +622,9 @@ class AppsFlyerKit :
                 }
             }
 
-        private const val SHARING_FILTER_FOR_PARTNERS = "sharingFilterForPartners"
+        const val MANUAL_START = "manualStart"
+        const val USER_IDENTIFICATION_TYPE = "userIdentificationType"
+        const val USER_IDENTIFICATION_MPID = "MPID"
         private const val CONSENT_MAPPING = "consentMapping"
 
         @Suppress("ktlint:standard:property-naming")
diff --git a/src/test/kotlin/com/appsflyer/AppsFlyerLib.kt b/src/test/kotlin/com/appsflyer/AppsFlyerLib.kt
@@ -5,12 +5,36 @@ import android.content.Context
 class AppsFlyerLib {
     private var consentData: AppsFlyerConsent? = null
 
+    var startCallCount = 0
+        private set
+
+    var customerUserId: String? = null
+        private set
+
     fun setConsentData(consent: AppsFlyerConsent) {
         consentData = consent
     }
 
     fun getConsentData(): AppsFlyerConsent? = consentData
 
+    fun start(context: Context) {
+        startCallCount++
+    }
+
+    fun setCustomerUserId(id: String?) {
+        customerUserId = id
+    }
+
+    fun init(devKey: String, conversionListener: Any?, context: Context) {}
+
+    fun setCollectAndroidID(collect: Boolean) {}
+
+    fun getAppsFlyerUID(context: Context): String = "test-appsflyer-uid"
+
+    fun subscribeForDeepLink(listener: Any?) {}
+
+    fun setDebugLog(debug: Boolean) {}
+
     fun getConsentState(): MutableMap<Any, Any> {
         val stateMap = mutableMapOf<Any, Any>()
         consentData?.let { consent ->
diff --git a/src/test/kotlin/com/mparticle/kits/AppsflyerKitTests.kt b/src/test/kotlin/com/mparticle/kits/AppsflyerKitTests.kt
@@ -76,57 +76,6 @@ class AppsflyerKitTests {
         Assert.assertTrue(name.isNotEmpty())
     }
 
-    @Test
-    @Throws(Exception::class)
-    fun testParseSharingFilterForPartners_returnsListForValidJson() {
-        val method =
-            AppsFlyerKit::class.java.getDeclaredMethod(
-                "parseSharingFilterForPartners",
-                String::class.java,
-            )
-        method.isAccessible = true
-        val result = method.invoke(kit, """["partner_1", "partner_2"]""")
-        Assert.assertEquals(listOf("partner_1", "partner_2"), result)
-    }
-
-    @Test
-    @Throws(Exception::class)
-    fun testParseSharingFilterForPartners_returnsNullForEmptyInput() {
-        val method =
-            AppsFlyerKit::class.java.getDeclaredMethod(
-                "parseSharingFilterForPartners",
-                String::class.java,
-            )
-        method.isAccessible = true
-        Assert.assertNull(method.invoke(kit, ""))
-        Assert.assertNull(method.invoke(kit, null))
-    }
-
-    @Test
-    @Throws(Exception::class)
-    fun testParseSharingFilterForPartners_returnsNullForInvalidJson() {
-        val method =
-            AppsFlyerKit::class.java.getDeclaredMethod(
-                "parseSharingFilterForPartners",
-                String::class.java,
-            )
-        method.isAccessible = true
-        Assert.assertNull(method.invoke(kit, "not a json array"))
-    }
-
-    @Test
-    @Throws(Exception::class)
-    fun testParseSharingFilterForPartners_stripsBackslashes() {
-        val method =
-            AppsFlyerKit::class.java.getDeclaredMethod(
-                "parseSharingFilterForPartners",
-                String::class.java,
-            )
-        method.isAccessible = true
-        val result = method.invoke(kit, """[\"test_1\", \"test_2\"]""")
-        Assert.assertEquals(listOf("test_1", "test_2"), result)
-    }
-
     /**
      * Kit *should* throw an exception when they're initialized with the wrong settings.
      *
@@ -776,6 +725,187 @@ class AppsflyerKitTests {
         Assert.assertEquals(emptyMap<String, String>(), result)
     }
 
+    // region manualStart and userIdentificationType (MPID) tests
+
+    @Test
+    @Throws(Exception::class)
+    fun testIsManualStart_returnsTrueWhenSettingIsTrue() {
+        setKitSettings(mapOf(AppsFlyerKit.MANUAL_START to "true"))
+        val method = AppsFlyerKit::class.java.getDeclaredMethod("isManualStart")
+        method.isAccessible = true
+        Assert.assertTrue(method.invoke(kit) as Boolean)
+    }
+
+    @Test
+    @Throws(Exception::class)
+    fun testIsManualStart_returnsFalseWhenSettingIsFalse() {
+        setKitSettings(mapOf(AppsFlyerKit.MANUAL_START to "false"))
+        val method = AppsFlyerKit::class.java.getDeclaredMethod("isManualStart")
+        method.isAccessible = true
+        Assert.assertFalse(method.invoke(kit) as Boolean)
+    }
+
+    @Test
+    @Throws(Exception::class)
+    fun testIsManualStart_returnsFalseWhenSettingIsAbsent() {
+        setKitSettings(emptyMap())
+        val method = AppsFlyerKit::class.java.getDeclaredMethod("isManualStart")
+        method.isAccessible = true
+        Assert.assertFalse(method.invoke(kit) as Boolean)
+    }
+
+    @Test
+    @Throws(Exception::class)
+    fun testIsUserIdentificationMpid_returnsTrueWhenSettingIsMPID() {
+        setKitSettings(
+            mapOf(
+                AppsFlyerKit.USER_IDENTIFICATION_TYPE to AppsFlyerKit.USER_IDENTIFICATION_MPID,
+            ),
+        )
+        val method =
+            AppsFlyerKit::class.java.getDeclaredMethod("isUserIdentificationMpid")
+        method.isAccessible = true
+        Assert.assertTrue(method.invoke(kit) as Boolean)
+    }
+
+    @Test
+    @Throws(Exception::class)
+    fun testIsUserIdentificationMpid_returnsFalseWhenSettingIsAbsent() {
+        setKitSettings(emptyMap())
+        val method =
+            AppsFlyerKit::class.java.getDeclaredMethod("isUserIdentificationMpid")
+        method.isAccessible = true
+        Assert.assertFalse(method.invoke(kit) as Boolean)
+    }
+
+    @Test
+    @Throws(Exception::class)
+    fun testIsUserIdentificationMpid_returnsFalseWhenSettingIsOther() {
+        setKitSettings(mapOf(AppsFlyerKit.USER_IDENTIFICATION_TYPE to "CustomerId"))
+        val method =
+            AppsFlyerKit::class.java.getDeclaredMethod("isUserIdentificationMpid")
+        method.isAccessible = true
+        Assert.assertFalse(method.invoke(kit) as Boolean)
+    }
+
+    @Test
+    @Throws(Exception::class)
+    fun testOnKitCreate_withManualStartTrue_doesNotCallStart() {
+        val settings = hashMapOf<String?, String?>()
+        settings[AppsFlyerKit.DEV_KEY] = "testDevKey"
+        settings[AppsFlyerKit.MANUAL_START] = "true"
+        MParticle.setInstance(mock(MParticle::class.java))
+        Mockito.`when`(MParticle.getInstance()?.environment)
+            .thenReturn(MParticle.Environment.Production)
+        Mockito.`when`(MParticle.isAndroidIdEnabled()).thenReturn(false)
+
+        kit.onKitCreate(settings, mock(Context::class.java))
+
+        Assert.assertEquals(0, appsflyer.startCallCount)
+    }
+
+    @Test
+    @Throws(Exception::class)
+    fun testOnKitCreate_withManualStartFalse_callsStart() {
+        val settings = hashMapOf<String?, String?>()
+        settings[AppsFlyerKit.DEV_KEY] = "testDevKey"
+        settings[AppsFlyerKit.MANUAL_START] = "false"
+        MParticle.setInstance(mock(MParticle::class.java))
+        Mockito.`when`(MParticle.getInstance()?.environment)
+            .thenReturn(MParticle.Environment.Production)
+        Mockito.`when`(MParticle.isAndroidIdEnabled()).thenReturn(false)
+
+        kit.onKitCreate(settings, mock(Context::class.java))
+
+        Assert.assertEquals(1, appsflyer.startCallCount)
+    }
+
+    @Test
+    @Throws(Exception::class)
+    fun testOnKitCreate_withManualStartUnset_callsStart() {
+        val settings = hashMapOf<String?, String?>()
+        settings[AppsFlyerKit.DEV_KEY] = "testDevKey"
+        MParticle.setInstance(mock(MParticle::class.java))
+        Mockito.`when`(MParticle.getInstance()?.environment)
+            .thenReturn(MParticle.Environment.Production)
+        Mockito.`when`(MParticle.isAndroidIdEnabled()).thenReturn(false)
+
+        kit.onKitCreate(settings, mock(Context::class.java))
+
+        Assert.assertEquals(1, appsflyer.startCallCount)
+    }
+
+    @Test
+    @Throws(Exception::class)
+    fun testOnActivityCreated_withManualStartTrue_doesNotCallStart() {
+        setKitSettings(
+            mapOf(
+                AppsFlyerKit.MANUAL_START to "true",
+            ),
+        )
+        kit.onActivityCreated(mock(Activity::class.java), null)
+        Assert.assertEquals(0, appsflyer.startCallCount)
+    }
+
+    @Test
+    @Throws(Exception::class)
+    fun testOnActivityCreated_withManualStartFalse_callsStart() {
+        setKitSettings(
+            mapOf(
+                AppsFlyerKit.MANUAL_START to "false",
+            ),
+        )
+        kit.onActivityCreated(mock(Activity::class.java), null)
+        Assert.assertEquals(1, appsflyer.startCallCount)
+    }
+
+    @Test
+    @Throws(Exception::class)
+    fun testSetUserIdentity_withUserIdentificationMpid_setsCustomerUserIdToMpid() {
+        setKitSettings(
+            mapOf(
+                AppsFlyerKit.USER_IDENTIFICATION_TYPE to AppsFlyerKit.USER_IDENTIFICATION_MPID,
+            ),
+        )
+        val mpid = 12345L
+        Mockito.`when`(user.getId()).thenReturn(mpid)
+        filteredMParticleUser = FilteredMParticleUser.getInstance(user, kit)
+        setKitCurrentUser(filteredMParticleUser)
+
+        kit.setUserIdentity(MParticle.IdentityType.CustomerId, "custom-client-id")
+
+        Assert.assertEquals("12345", appsflyer.customerUserId)
+    }
+
+    @Test
+    @Throws(Exception::class)
+    fun testSetUserIdentity_withoutUserIdentificationMpid_setsCustomerUserIdToIdentity() {
+        setKitSettings(emptyMap())
+        setKitCurrentUser(null)
+
+        kit.setUserIdentity(MParticle.IdentityType.CustomerId, "custom-client-id")
+
+        Assert.assertEquals("custom-client-id", appsflyer.customerUserId)
+    }
+
+    @Throws(Exception::class)
+    private fun setKitSettings(settings: Map<String, String>) {
+        val settingsField = KitIntegration::class.java.getDeclaredField("settings")
+        settingsField.isAccessible = true
+        val settingsMap = mutableMapOf<String?, String?>()
+        settings.forEach { (k, v) -> settingsMap[k] = v }
+        settingsField.set(kit, settingsMap)
+    }
+
+    @Throws(Exception::class)
+    private fun setKitCurrentUser(user: FilteredMParticleUser?) {
+        val field = KitIntegration::class.java.getDeclaredField("currentUser")
+        field.isAccessible = true
+        field.set(kit, user)
+    }
+
+    // endregion
+
     private var emptyCoreCallbacks: CoreCallbacks =
         object : CoreCallbacks {
             var activity = Activity()
