Adxiety Client SDK Integration Guide

# Adxiety SDK integration — current source contract
These are current E1 source API examples. Use only an E1-capable locally reviewed AAR whose full SHA-256 and provenance you verify. The frozen P2c consumer artifact lacks Adxiety.initialize; the obsolete bundled 1.0.0 AAR is also unsuitable. No public Maven release/download or provisioned Companion Play listing is established. Existing consumer-smoke compilation did not exercise initialize; external Kotlin/Java initializer coverage remains a pre-production gate. Production signer pins remain empty and fail closed.
One SDK artifact; explicitly initialize SANDBOX or LIVE before normal use. Same-environment repeat succeeds; a conflicting environment returns false without switching. Before initialization, SDK calls fail closed without IPC, observer registration, navigation or entitlement persistence mutation. Build/release safeguards remain separate; debug flags do not select an environment.
Keep host monetization policy explicit; no mandatory paid/attention waterfall. Do not add SDK networking or ad SDKs for this integration. Preserve cancellation and signed trust checks. Memory reads do not query disk or the companion; no universal latency or DEX-size guarantee is made.

## Dependencies
dependencies {
    // Placeholder filename: supply and hash-verify an E1-capable reviewed local AAR.
    // Frozen P2c bytes do NOT implement the initialization examples below.
    implementation(files("libs/adxiety-client-reviewed-e1-<sha12>.aar"))
    implementation("org.jetbrains.kotlin:kotlin-stdlib:1.9.22")
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3")
    // Only if the HOST uses Dispatchers.Main (for example, Compose):
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3")
}

## Inspect merged manifest
<!-- Inspection excerpt, NOT a replacement for the full merged SDK manifest. -->
<queries>
    <package android:name="com.adxiety.companion.sandbox" />
    <package android:name="com.adxiety.companion" />
</queries>
<!-- Also verify merged com.adxiety.client.AdxietyReturnActivity and
     com.adxiety.action.HOST_APP against the actual reviewed AAR manifest.
     Keep manifest merging enabled; inspect the actual host variant output. -->

## Initialize, then read/refresh/renew
import android.content.Context
import com.adxiety.client.Adxiety
import com.adxiety.client.AdxietyClient
import com.adxiety.client.AdxietyEnvironment
import com.adxiety.client.model.AdxietyLeaseState

// Call at host startup with AdxietyEnvironment.SANDBOX or .LIVE chosen explicitly.
// No default, build-type inference or runtime switching. Never ignore false.
fun initializeAttention(applicationContext: Context, environment: AdxietyEnvironment): Boolean {
    if (!Adxiety.initialize(applicationContext, environment)) {
        return false // Keep attention access unavailable; do not navigate or refresh.
    }
    return true
}

// Caller invokes these only after initializeAttention returned true.
fun memoryAttentionState(context: Context): AdxietyLeaseState =
    AdxietyClient.getLeaseState(context) // Cold UNKNOWN is not proof of no entitlement.

// Call from a coroutine. SDK owns persistence/refresh dispatch; cancellation propagates.
suspend fun refreshAttentionState(context: Context): AdxietyLeaseState =
    AdxietyClient.getLeaseStateAsync(context)

// User action only; authenticates destination asynchronously. Opening UI earns nothing.
fun requestAttentionRenewal(context: Context) = AdxietyClient.launchRenewal(context)

## Optional Compose example (requires the host's existing Compose setup)
import androidx.compose.material3.Button
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import androidx.compose.runtime.remember
import androidx.compose.ui.platform.LocalContext
import com.adxiety.client.Adxiety
import com.adxiety.client.AdxietyClient
import com.adxiety.client.AdxietyEnvironment

@Composable
fun FeaturePassCard(environment: AdxietyEnvironment) {
    val context = LocalContext.current.applicationContext
    // Prefer host startup initialization. Same-environment repeat is safe.
    // The host must supply SANDBOX or LIVE; changing this argument cannot switch SDK state.
    val initialized = remember(context, environment) { Adxiety.initialize(context, environment) }
    if (!initialized) {
        Text("Attention access unavailable")
        return
    }
    val leaseFlow = remember(context) { AdxietyClient.observeLease(context) }
    val leaseState by leaseFlow.collectAsState(initial = AdxietyClient.getLeaseState(context))
    if (leaseState.isActive) {
        Text("Feature unlocked")
    } else {
        Button(onClick = { AdxietyClient.launchRenewal(context) }) {
            Text("Open companion renewal")
        }
    }
}

Observe semantic states, not a guaranteed countdown or real-time deadline. Scope collection to the host UI lifecycle. Discovery is not authentication or entitlement. Renewal may fail closed; no current public Play listing is promised. Voucher delivery requires the host's atomic deposit/receipt adapter; never add summary counters to a balance. See /llms-sdk.txt for the retained delivery contract.
Privacy wording must be reviewed against the entire host and companion, not treated as automatic compliance certification.