Android SDK

dependencyResolutionManagement {
    repositories {
        google()
        mavenCentral()
        maven("https://jitpack.io")
    }
}

dependencies {
    implementation("com.github.DPDPA-Shield.android-sdk:android:v1.0.0-beta3")
}

class MyApp : Application() {
    lateinit var shield: ShieldConsentManager

    override fun onCreate() {
        super.onCreate()
        shield = ShieldConsentManager.init(
            applicationContext,
            ShieldConsentManager.Config(
                apiKey = "dpdpa_live_YOUR_KEY",
                cmpId = 1234, // your IAB CMP ID, if registered - see IAB TCF v2 below
            ),
        )
        // Flushes the offline write queue automatically whenever
        // connectivity returns - call once, for the process lifetime.
        shield.observeConnectivity()
    }
}

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val shield = (application as MyApp).shield

        setContent {
            var notice by remember { mutableStateOf<ConsentNotice?>(null) }
            var localizedNotice by remember { mutableStateOf<LocalizedNotice?>(null) }

            LaunchedEffect(Unit) {
                if (shield.restoredDecision() == null) {
                    when (val result = shield.loadNotice()) {
                        is ShieldApiResult.Success -> {
                            notice = result.value
                            localizedNotice = shield.localize()
                        }
                        is ShieldApiResult.Failure -> { /* show retry UI */ }
                    }
                }
            }

            localizedNotice?.let { localized ->
                // Build theme from notice branding — logo slot is a composable
                // lambda so you choose the image loader (Coil, Glide, etc.).
                // hexToComposeColor() returns null for non-white-label tenants
                // and the screen falls back to your app's MaterialTheme primary.
                val theme = ShieldConsentTheme(
                    primaryColor  = hexToComposeColor(notice?.primaryColor),
                    showPoweredBy = notice?.brandName == null,
                    logo = notice?.logoUrl?.let { url ->
                        {
                            AsyncImage(   // io.coil-kt:coil-compose in your build.gradle
                                model              = url,
                                contentDescription = notice?.brandName,
                                modifier           = Modifier.height(40.dp),
                            )
                        }
                    },
                )
                ConsentScreen(
                    notice       = localized,
                    theme        = theme,
                    contactEmail = notice?.contactEmail,
                    brandName    = notice?.brandName,
                    onAcceptAll  = { given -> shield.recordDecision("user@example.com", given, "en") },
                    onRejectAll  = { given -> shield.recordDecision("user@example.com", given, "en") },
                    onSave       = { given -> shield.recordDecision("user@example.com", given, "en") },
                )
            }
        }
    }
}

public class MyApplication extends Application {
    public ShieldConsentManager shield;

    @Override
    public void onCreate() {
        super.onCreate();
        // .Companion. prefix until @JvmStatic ships in a future SDK release
        shield = ShieldConsentManager.Companion.init(
            getApplicationContext(),
            new ShieldConsentManager.Config(
                "dpdpa_live_YOUR_KEY",
                1234,   // cmpId
                1,      // cmpVersion (default)
                null    // tcfPurposeMapping (optional)
            )
        );
        // Flush the offline write queue automatically when connectivity returns
        shield.observeConnectivity();
    }
}

ShieldConsentManager shield = ((MyApplication) getApplication()).shield;

// Option A — plain boolean check (simplest from Java)
if (shield.getGate().isConsented(analyticsPurposeId)) {
    initAnalyticsSdk();
}

// Option B — runIfConsented lambda
// Kotlin inline funs require Unit.INSTANCE as the explicit return value in Java
shield.getGate().runIfConsented(analyticsPurposeId, () -> {
    FirebaseAnalytics.getInstance(this).setAnalyticsCollectionEnabled(true);
    return Unit.INSTANCE;
});

// Record a decision — works identically from Java (not a suspend fun)
Map<String, Boolean> purposes = new HashMap<>();
purposes.put(analyticsPurposeId, true);
purposes.put(marketingPurposeId, false);
shield.recordDecision("user@example.com", purposes, "en");

import androidx.lifecycle.LifecycleCoroutineScope
import com.dpdpashield.sdk.android.ShieldConsentManager
import com.dpdpashield.sdk.core.i18n.LocalizedNotice
import com.dpdpashield.sdk.core.net.ShieldApiResult
import kotlinx.coroutines.launch

object ConsentBridge {
    @JvmStatic
    fun loadNotice(
        manager: ShieldConsentManager,
        scope: LifecycleCoroutineScope,
        onSuccess: (LocalizedNotice?) -> Unit,
        onError: (Throwable) -> Unit,
    ) {
        scope.launch {
            when (val result = manager.loadNotice()) {
                is ShieldApiResult.Success -> onSuccess(manager.localize())
                is ShieldApiResult.Failure -> onError(result.error)
            }
        }
    }
}

import androidx.lifecycle.LifecycleOwnerKt;

// In onCreate() or wherever you check consent
ShieldConsentManager shield = ((MyApplication) getApplication()).shield;

if (shield.restoredDecision() == null) {
    ConsentBridge.loadNotice(
        shield,
        LifecycleOwnerKt.getLifecycleScope(this),
        notice -> runOnUiThread(() -> {
            if (notice != null) {
                // show your consent screen - notice.getPurposes() etc.
            }
        }),
        error -> Log.e("Shield", "loadNotice failed", error)
    );
}

// In MainActivity.kt — show ParentalConsentScreen when needed
val shield = (application as MyApp).shield
val sessionId = UUID.randomUUID().toString()

// Render the screen inside a dialog, sheet, or full-screen composable
ParentalConsentScreen(
    manager   = shield,
    sessionId = sessionId,
    orgName   = "Acme App",
    onVerified = { result ->
        // result.childAccountId — store if you need it
        // result.restrictions  — ["AD_TARGETING","PROFILING","DATA_SHARING","BEHAVIORAL_TRACKING"]
        // Proceed: child has now been verified + restrictions applied
        showMainContent()
    },
    onCancel = {
        // User cancelled or is an adult (adult flow: show normal ConsentScreen instead)
        showNormalConsent()
    },
    initialDob = "",    // omit to show the DOB field; pre-fill if you already know it
)

// Step 1 — verify age
val ageResult = shield.verifyAge(dob = "2010-06-15", sessionId = mySessionId)
if (ageResult is ShieldApiResult.Success && ageResult.value.isMinor) {
    // Show guardian email input
}

// Step 2 — send OTP to guardian
val initiated = shield.initiateParentalConsent(
    sessionId    = mySessionId,
    guardianEmail = "parent@example.com",
)
// initiated.value.consentId — keep this for step 3
// initiated.value.maskedGuardianEmail — show "OTP sent to par***@example.com"

// Step 3 — verify OTP
val verified = shield.verifyParentalConsent(
    consentId = initiated.value.consentId,
    otp       = "123456",           // from the guardian's email
)
// verified.value.childAccountId — ChildAccount created, restrictions active

// Runs the block only if the purpose is currently consented - reacts
// immediately to the gate flipping, online or offline.
shield.gate.runIfConsented(analyticsPurposeId) {
    FirebaseAnalytics.getInstance(this).setAnalyticsCollectionEnabled(true)
}

// Or observe changes over time - fires immediately with current state,
// then again on every future decision update (e.g. the user later
// grants a purpose they'd initially declined).
shield.gate.observeConsented(analyticsPurposeId) { consented ->
    if (consented) initAnalyticsSdk() else disableAnalyticsSdk()
}

class MyWebViewActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val shield = (application as MyApp).shield
        val webView = WebView(this)
        val bridge = ShieldWebViewBridge(shield)

        bridge.install(webView) // registers the JS interface, once
        webView.webViewClient = object : WebViewClient() {
            override fun onPageStarted(view: WebView, url: String, favicon: Bitmap?) {
                bridge.onPageStarted(view) // before the page's own scripts run
            }
        }
        webView.loadUrl("https://yourdomain.com/support")
    }
}

ShieldConsentManager.Config(
    apiKey = "dpdpa_live_YOUR_KEY",
    cmpId = 1234,
    tcfPurposeMapping = TcfPurposeMapping(mapOf(
        "your-marketing-purpose-uuid" to 4,  // IAB Purpose 4: Ad selection
        "your-analytics-purpose-uuid" to 8,  // IAB Purpose 8: Market research
    )),
)