Search

Platform Implementation Guides

Android App Attribution Partner Plugins

The Android App Attribution Partner Plugins provide seamless integration with popular attribution and analytics SDKs while ensuring privacy compliance through the TrustArc Mobile Consent SDK.

AndroidManifest.xml Requirements

These permissions are universally common for all SDKs. Refer to the App Attribution Partner SDK guide to learn more about these requirements.

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="com.google.android.gms.permission.AD_ID" />
Firebase Analytics Plugin
  • Package: com.trustarc.firebase_plugin.TAFirebasePlugin
  • Purpose: Privacy-compliant Firebase Analytics integration
  • Consent Management: Controls analytics data collection based on functional consent
  • Official Documentation: Firebase Android Setup Guide  |  Get Started with Analytics

Gradle Setup:

dependencies {
    // TrustArc Firebase Plugin
    implementation("com.trustarc:trustarc-firebase-plugin:VERSION")

    // Firebase Analytics SDK
    implementation(platform("com.google.firebase:firebase-bom:34.1.0"))
    implementation("com.google.firebase:firebase-analytics")
}

Prerequisites:

1
Add your Android app to your Firebase project.
2
Download and add the google-services.json file to your app module.
3
Add the Google services plugin to your project.

AndroidManifest Setup:

No additional AndroidManifest.xml requirements — Firebase automatically handles configuration through google-services.json.

SDK Initialization and Plugin Initialization:

class MainActivity : AppCompatActivity() {
    private lateinit var trustArc: TrustArc
    private lateinit var taFirebasePlugin: TAFirebasePlugin

    private fun setupTrustArcSdk() {
        // 1. Initialize TrustArc SDK first
        trustArc = TrustArc(applicationContext, SdkMode.IabTCFv_2_2)

        trustArc.addSdkInitializedListener {
            Log.i("TrustArc", "SDK initialized successfully")
            // Setup Firebase plugin after TrustArc initialization
            setupFirebasePlugin()
        }

        // Start TrustArc SDK
        trustArc.start("your-domain.com")
    }

    private fun setupFirebasePlugin() {
        // 2. Initialize Firebase (standard Firebase setup)
        FirebaseApp.initializeApp(applicationContext)

        // 3. Add Google consent listener for additional consent monitoring
        trustArc.addGoogleConsentListener {
            Log.d("CONSENTS", "Google consent update: $this")
        }

        // 4. Initialize Firebase plugin with TrustArc SDK instance
        taFirebasePlugin = TAFirebasePlugin(applicationContext, TASharedInstance.getSdkInstance())
    }
}

Event Logging / SDK Usage:

// Usage: Logging events through the plugin (consent-controlled)
private fun logFirebaseEvent() {
    // Plugin automatically controls event logging based on consent state
    taFirebasePlugin.logEvent("test_event") {
        it.param("event_value", "demo_test")
        it.param("plugin_version", "enhanced")
        it.param("timestamp", System.currentTimeMillis())
    }
}

// Standard Firebase Analytics events will also be controlled by the plugin
private fun logStandardFirebaseEvent() {
    Firebase.analytics.logEvent(FirebaseAnalytics.Event.SELECT_CONTENT) {
        param(FirebaseAnalytics.Param.ITEM_ID, "test_item")
        param(FirebaseAnalytics.Param.CONTENT_TYPE, "button")
    }
}
AppsFlyer Plugin
  • Package: com.trustarc.trustarc_appsflyer_plugin.TAAppsFlyerPlugin
  • Purpose: Privacy-compliant AppsFlyer attribution tracking
  • Consent Management: Controls attribution tracking based on advertising consent
  • Official Documentation: AppsFlyer Android SDK  |  Integration Guide

Gradle Setup:

dependencies {
    // TrustArc AppsFlyer Plugin
    implementation("com.trustarc:trustarc-appsflyer-plugin:VERSION")

    // AppsFlyer SDK
    implementation("com.appsflyer:af-android-sdk:6.14.2")
    implementation("com.android.installreferrer:installreferrer:2.2")
    implementation("com.google.android.gms:play-services-appset:16.1.0")
}

Prerequisites:

1
Obtain your AppsFlyer Dev Key from your AppsFlyer dashboard.
2
Ensure your app's applicationId matches the app ID in AppsFlyer.

AndroidManifest Setup:

No additional AndroidManifest.xml requirements beyond universal permissions. AppsFlyer automatically handles install referrer and other configurations.

SDK Initialization and Plugin Initialization:

class MainActivity : AppCompatActivity() {
    private lateinit var trustArc: TrustArc
    private lateinit var appsflyerPlugin: TAAppsFlyerPlugin

    private fun setupTrustArcSdk() {
        // 1. Initialize TrustArc SDK first
        trustArc = TrustArc(applicationContext, SdkMode.IabTCFv_2_2)

        trustArc.addSdkInitializedListener {
            Log.i("TrustArc", "SDK initialized successfully")
            // Setup AppsFlyer plugin after TrustArc initialization
            setupAppsFlyerPlugin()
        }

        // Start TrustArc SDK
        trustArc.start("your-domain.com")
    }

    private fun setupAppsFlyerPlugin() {
        // 2. Initialize AppsFlyer SDK with your Dev Key
        AppsFlyerLib.getInstance().init("YOUR_APPSFLYER_DEV_KEY", null, applicationContext)
        AppsFlyerLib.getInstance().setDebugLog(true)

        // 3. Start AppsFlyer SDK (will be controlled by TrustArc plugin)
        AppsFlyerLib.getInstance().start(applicationContext)

        // 4. Initialize AppsFlyer plugin with TrustArc integration
        appsflyerPlugin = TAAppsFlyerPlugin(applicationContext, trustArc, AppsFlyerLib.getInstance())
    }
}

Event Logging / SDK Usage:

// Usage: Events are automatically controlled by plugin based on consent
private fun logAppsFlyerEvent() {
    // Plugin automatically manages tracking based on consent state
    AppsFlyerLib.getInstance().logEvent(applicationContext, AFInAppEventType.ADD_TO_WISH_LIST, mapOf(
        "EVENT_TEST" to "DEMO_TEST",
        "plugin_version" to "enhanced",
        "test_timestamp" to System.currentTimeMillis().toString()
    ))
}

// Custom event tracking
private fun trackPurchaseEvent() {
    val eventValues = HashMap<String, Any>()
    eventValues[AFInAppEventParameterName.REVENUE] = 29.99
    eventValues[AFInAppEventParameterName.CURRENCY] = "USD"
    eventValues[AFInAppEventParameterName.CONTENT_ID] = "product_123"

    // Plugin controls whether this gets tracked based on consent
    AppsFlyerLib.getInstance().logEvent(applicationContext, AFInAppEventType.PURCHASE, eventValues)
}
Airbridge Plugin
  • Package: com.trustarc.airbridge_plugin.TAAirBridgePlugin
  • Purpose: Privacy-compliant Airbridge attribution tracking
  • Consent Management: Controls tracking and consent flags based on user preferences
  • Official Documentation: Airbridge Android SDK v4  |  SDK Migration Guide

Gradle Setup:

repositories {
    maven { url = uri("https://sdk-download.airbridge.io/maven") }
}

dependencies {
    // TrustArc Airbridge Plugin
    implementation("com.trustarc:trustarc-airbridge-plugin:VERSION")

    // Airbridge SDK v4
    implementation("io.airbridge:sdk-android:2.27.2")
}

Prerequisites:

1
Obtain your App Name and App SDK Token from the Airbridge dashboard.
2
Create an Application class for SDK initialization.

AndroidManifest Setup:

Application class registration required:

<application
    android:name=".YourApplication"
    android:allowBackup="true"
    ...>
</application>

SDK Initialization and Plugin Initialization:

// In your Application class
class YourApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        setupAirbridge()
    }

    private fun setupAirbridge() {
        // 1. Airbridge SDK v4 with privacy-first initialization
        val option = AirbridgeOptionBuilder("YOUR_APP_NAME", "YOUR_APP_SDK_TOKEN")
            .setAutoStartTrackingEnabled(false) // Privacy by design - don't start until consent
            .build()

        Airbridge.initializeSDK(this, option)
        Log.d("Airbridge", "SDK v4 initialized with auto-tracking disabled for consent management")
    }
}

// In your Activity
class MainActivity : AppCompatActivity() {
    private lateinit var trustArc: TrustArc
    private lateinit var airbridgePlugin: TAAirBridgePlugin

    private fun setupTrustArcSdk() {
        // 2. Initialize TrustArc SDK first
        trustArc = TrustArc(applicationContext, SdkMode.IabTCFv_2_2)

        trustArc.addSdkInitializedListener {
            Log.i("TrustArc", "SDK initialized successfully")
            // Setup Airbridge plugin after TrustArc initialization
            setupAirbridgePlugin()
        }

        // Start TrustArc SDK
        trustArc.start("your-domain.com")
    }

    private fun setupAirbridgePlugin() {
        // 3. Initialize Airbridge plugin (after TrustArc SDK initialization)
        airbridgePlugin = TAAirBridgePlugin(trustArc, Airbridge)
    }
}

Event Logging / SDK Usage:

// Usage: Events are automatically controlled by plugin
private fun logAirbridgeEvent() {
    // Plugin controls whether this gets tracked based on consent
    Airbridge.trackEvent("demo_test", mapOf(
        "plugin_version" to "enhanced",
        "sdk_version" to "v4",
        "test_timestamp" to System.currentTimeMillis().toString()
    ))
}

// Custom event with properties
private fun trackPurchaseEvent() {
    val eventData = mapOf(
        "revenue" to 29.99,
        "currency" to "USD",
        "product_id" to "product_123",
        "category" to "electronics"
    )

    // Plugin manages tracking and consent flags based on user preferences
    Airbridge.trackEvent("purchase", eventData)
}

// User properties
private fun setUserProperties() {
    // Plugin controls user data collection based on consent
    Airbridge.setUser(mapOf(
        "user_id" to "user_123",
        "email" to "user@example.com"
    ))
}
Singular Plugin
  • Package: com.trustarc.trustarc_singular_plugin.TASingularPlugin
  • Purpose: Privacy-compliant Singular attribution tracking
  • Consent Management: Controls data sharing limitations based on consent state
  • Official Documentation: Singular Android SDK Basic Integration  |  Prerequisites

Gradle Setup:

repositories {
    maven { url = uri("https://maven.singular.net/") }
}

dependencies {
    // TrustArc Singular Plugin
    implementation("com.trustarc:trustarc-singular-plugin:VERSION")

    // Singular SDK
    implementation("com.singular.sdk:singular_sdk:12.10.0")
}

Prerequisites:

1
Complete the planning and prerequisites guide.
2
Obtain your API Key and Secret from the Singular dashboard.
3
Initialize in MainActivity (not Application class).

AndroidManifest Setup:

No additional AndroidManifest.xml requirements — Singular handles configuration programmatically during initialization.

SDK Initialization and Plugin Initialization:

class MainActivity : AppCompatActivity() {
    private lateinit var trustArc: TrustArc
    private lateinit var singularPlugin: TASingularPlugin

    private fun setupTrustArcSdk() {
        // 1. Initialize TrustArc SDK first
        trustArc = TrustArc(applicationContext, SdkMode.IabTCFv_2_2)

        trustArc.addSdkInitializedListener {
            Log.i("TrustArc", "SDK initialized successfully")
            // Setup Singular plugin after TrustArc initialization
            setupSingularPlugin()
        }

        // Start TrustArc SDK
        trustArc.start("your-domain.com")
    }

    private fun setupSingularPlugin() {
        // 2. Initialize Singular SDK with required configuration
        val config = SingularConfig("YOUR_API_KEY", "YOUR_SECRET_KEY")
            .withCustomUserId("custom_user_id")
            .withLoggingEnabled()
            .withLogLevel(1)

        Singular.init(applicationContext, config)

        // 3. Initialize Singular plugin with TrustArc integration
        singularPlugin = TASingularPlugin(trustArc, SingularInstance.getInstance())
    }
}

Event Logging / SDK Usage:

// Usage: Plugin manages limitDataSharing() based on consent
private fun logSingularEvent() {
    val eventPayload = JSONObject()
    eventPayload.put("EVENT_TEST", "DEMO_TEST")
    eventPayload.put("plugin_version", "enhanced")
    eventPayload.put("test_timestamp", System.currentTimeMillis())

    // Plugin automatically manages data sharing limitations
    Singular.eventJSON("test_event", eventPayload)
}

// Custom event tracking
private fun trackPurchaseEvent() {
    val purchaseEvent = JSONObject()
    purchaseEvent.put("revenue", 29.99)
    purchaseEvent.put("currency", "USD")
    purchaseEvent.put("product_id", "product_123")
    purchaseEvent.put("category", "electronics")

    // Plugin controls data sharing based on consent state
    Singular.eventJSON("purchase", purchaseEvent)
}

// Revenue tracking
private fun trackRevenue() {
    // Plugin manages revenue tracking based on consent
    Singular.revenue("USD", 29.99)
}

// Custom user ID
private fun setCustomUserId() {
    // Plugin controls user identification based on consent
    Singular.setCustomUserId("user_123")
}
Best Practices
1. Privacy-First Initialization
  • Initialize third-party SDKs with tracking disabled by default.
  • Enable tracking only after obtaining proper consent.
  • Use setAutoStartTrackingEnabled(false) for privacy-compliant initialization.
2. Consent Monitoring
  • Always add consent listeners to respond to user preference changes.
  • Update plugin behavior immediately when the consent state changes.
  • Provide clear visual feedback to users about the tracking state.
3. Error Handling
  • Implement proper error handling for all plugin operations.
  • Log consent state changes for debugging and compliance verification.
  • Handle cases where third-party SDKs may not be available.
4. Testing
  • Test all consent scenarios: no consent, functional-only consent, and full consent.
  • Verify that tracking is properly disabled when consent is withdrawn.
  • Test deep link attribution flows under different consent states.
Troubleshooting

Common Issues

1. Plugin not responding to consent changes
  • Verify that the TrustArc SDK is properly initialized before setting up plugins.
  • Check that consent listeners are added before starting the SDK.
2. Attribution not working
  • Ensure that advertising consent is granted for attribution plugins.
  • Verify that third-party SDK initialization is correct.
  • Check the deep link configuration in AndroidManifest.xml.
3. Analytics events not firing
  • Verify that functional consent is granted for analytics plugins.
  • Check that Firebase/Analytics SDKs are properly configured.
  • Ensure that the plugin initialization order is correct.

Debugging

// Enable debug logging for troubleshooting
AppsFlyerLib.getInstance().setDebugLog(true)
Singular.init(applicationContext, config.withLoggingEnabled().withLogLevel(1))
Log.d("TrustArc", "Consent state: ${trustArc.getConsentDataByCategory()}")
TrustArc  ·  Mobile App Consent — Android App Attribution Partner Plugins  ·  www.trustarc.com