A/B Testing Android SDK

repositories {
    google()
    mavenCentral()
    maven { url "https://center.abrova.ir/api/packages/abrova/maven" }
}

dependencies {
    implementation("ir.abrova:abrova-ab-testing-android:0.2.3")
}

<uses-permission android:name="android.permission.INTERNET" />

import android.util.Log
import ir.abrova.abtesting.Experiment
import ir.abrova.abtesting.AbrovaAbTesting
import ir.abrova.abtesting.AbrovaAbTestingCallback
import ir.abrova.abtesting.AbrovaAbTestingConfig
import ir.abrova.abtesting.AbrovaAbTestingError
import ir.abrova.abtesting.AbrovaTokenProvider
import ir.abrova.abtesting.models.FeatureFlag

val config = AbrovaAbTestingConfig(
    apiKey = "YOUR_API_KEY",
    // Runs on a background thread, so a blocking call to your backend is fine.
    // Return null while no one is signed in.
    tokenProvider = AbrovaTokenProvider { myBackend.fetchAbrovaTokenBlocking() },
    debug = BuildConfig.DEBUG,
    // flushInterval = 10000L,  // Your own send interval in ms. Leave it out to follow the console
    maxQueueSize = 100       // Max events before auto-flush
)

AbrovaAbTesting.init(this, config, object : AbrovaAbTestingCallback {
    override fun onInitialized() {
        Log.d("Abrova", "SDK initialized")
    }

    override fun onExperimentAssigned(experimentKey: String, variantKey: String, config: Map<String, Any>?) {
        Log.d("Abrova", "Assigned: $experimentKey -> $variantKey")
    }

    override fun onExperimentsRefreshed(experiments: List<Experiment>) {
        Log.d("Abrova", "Refreshed ${experiments.size} experiments")
    }

    override fun onFeatureFlagsRefreshed(flags: List<FeatureFlag>) {
        Log.d("Abrova", "Refreshed ${flags.size} flags")
    }

    override fun onSyncCompleted(synced: Int, failed: Int, pending: Int) {
        Log.d("Abrova", "Synced: $synced, failed: $failed, pending: $pending")
    }

    override fun onOnlineMode() {
        Log.d("Abrova", "Back online")
    }

    override fun onOfflineMode() {
        Log.d("Abrova", "Offline")
    }

    override fun onError(error: AbrovaAbTestingError) {
        Log.e("Abrova", "Error: ${error.message}")
    }
})

curl -X POST https://auth.abrova.ir/users/token \
  -H "x-api-key: $ABROVA_API_KEY" \
  -H "x-server-secret: $ABROVA_SERVER_SECRET" \
  -H "Content-Type: application/json" \
  -d '{"userId": "user-123", "expiresIn": 3600}'

# → { "token": "eyJhbGciOi…", "userId": "user-123", "expiresIn": 3600, "expiresAt": "…" }

val tokenProvider = AbrovaTokenProvider {
    // No one signed in: return null (or throw). The SDK then waits for a token.
    val session = sessionStore.current() ?: return@AbrovaTokenProvider null
    myBackend.fetchAbrovaTokenBlocking(session)
}

AbrovaAbTesting.onAwaitingUserToken = { /* e.g. show the default experience */ }

// After sign-in
AbrovaAbTesting.refreshUserToken()      // with a tokenProvider: asks it again now
AbrovaAbTesting.setUserToken(token)     // without one: hand the token over

// After sign-out
AbrovaAbTesting.clearUserId()           // or setUserToken(null)

// After login — use the same ID your backend mints the token for
AbrovaAbTesting.setUserId("user-123")
AbrovaAbTesting.refreshUserToken()   // or setUserToken(token) if you hand tokens over yourself

// After logout — forget the user and wait for the next token
AbrovaAbTesting.clearUserId()

// Get current user ID
val userId = AbrovaAbTesting.getUserId()

// Set user attributes for targeting rules
AbrovaAbTesting.setUserAttributes(mapOf(
    "plan" to "premium",
    "country" to "US",
    "age" to 25
))

// Asynchronous (recommended) — waits for the service's answer;
// the result is delivered on the main thread
AbrovaAbTesting.getVariantAsync("checkout-redesign") { variant ->
    when (variant) {
        "variant-a" -> showNewCheckout()
        "variant-b" -> showMinimalCheckout()
        else -> showOriginalCheckout()  // control
    }
}

// Synchronous — never blocks, safe on the main thread
val variant = AbrovaAbTesting.getVariant(
    experimentKey = "checkout-redesign",
    defaultVariant = "control"  // returned until the service has answered
)

// Get variant config (colors, text, etc.) — available once a variant is assigned
val config = AbrovaAbTesting.getVariantConfig("checkout-redesign")
val buttonColor = config?.get("button_color") as? String ?: "#6B7280"
val layout = config?.get("layout") as? String ?: "default"

// List all experiments (API key only)
val experiments = AbrovaAbTesting.getExperiments()

// Refresh from server
AbrovaAbTesting.refreshExperiments()

// Local evaluation against the cached flag list
val darkMode = AbrovaAbTesting.isFeatureEnabled("dark-mode")

// Server-side evaluation (needs a user token; falls back to local evaluation)
AbrovaAbTesting.isFeatureEnabledAsync("dark-mode") { enabled ->
    if (enabled) enableDarkMode()
}

// Get feature flag value
val maxUpload = AbrovaAbTesting.getFeatureValue("max-upload-size", defaultValue = 10)

// Get all flags
val flags = AbrovaAbTesting.getFeatureFlags()
flags.forEach { flag ->
    Log.d("Abrova", "${flag.key}: enabled=${flag.enabled}, rollout=${flag.rolloutPercentage}%")
}

// Refresh flags from server
AbrovaAbTesting.refreshFeatureFlags()

AbrovaAbTesting.trackView("experiment-key")
AbrovaAbTesting.trackClick("experiment-key")
AbrovaAbTesting.trackConversion("experiment-key", 500000.0)

AbrovaAbTesting.trackCustomEvent(
    "experiment-key",
    "button_hover",
    mapOf("duration_ms" to 1500, "element" to "cta_button")
)

AbrovaAbTesting.trackAddToCart("experiment-key", 300000.0, "sku-123", mapOf("quantity" to 2))
AbrovaAbTesting.trackRemoveFromCart("experiment-key", 300000.0, "sku-123")
AbrovaAbTesting.trackBeginCheckout("experiment-key", 1500000.0)
AbrovaAbTesting.trackPurchase("experiment-key", 1250000.0, "txn-12345", mapOf("currency" to "Toman"))

AbrovaAbTesting.trackScroll("experiment-key", 75.0)
AbrovaAbTesting.trackFormSubmit("experiment-key", "signup-form")
AbrovaAbTesting.trackSearch("experiment-key", "shoes")
AbrovaAbTesting.trackShare("experiment-key", "twitter")

AbrovaAbTesting.trackVideoStart("experiment-key", "vid-001")
AbrovaAbTesting.trackVideoComplete("experiment-key", "vid-001")

AbrovaAbTesting.trackSignUp("experiment-key", "google")
AbrovaAbTesting.trackLogin("experiment-key", "email")
AbrovaAbTesting.trackLogout("experiment-key")

import ir.abrova.abtesting.models.EventType

AbrovaAbTesting.track(
    experimentKey = "experiment-key",
    eventType = EventType.CUSTOM,
    eventName = "page_load_time",
    eventValue = 2.3,
    properties = mapOf("page" to "/checkout", "cached" to false)
)

// Check online status
val online = AbrovaAbTesting.isOnline

// Get pending event count
val pending = AbrovaAbTesting.getPendingEventCount()

// Force sync pending events
AbrovaAbTesting.flush()

class MyActivity : AppCompatActivity() {
    override fun onStop() {
        super.onStop()
        AbrovaAbTesting.flush()  // Sync events when activity stops
    }

    override fun onResume() {
        super.onResume()
        AbrovaAbTesting.refreshExperiments()  // Refresh on resume
    }
}

// Clear cached experiments, flags, assignments and the token.
// Mainly for tests — call init() again before using the SDK.
AbrovaAbTesting.reset()

// Stop the event queue and network listener
AbrovaAbTesting.dispose()

class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()
        AbrovaAbTesting.init(this, AbrovaAbTestingConfig(
            apiKey = "YOUR_API_KEY",
            // Returns null while no one is signed in
            tokenProvider = AbrovaTokenProvider { myBackend.fetchAbrovaTokenBlocking() }
        ))
    }
}

// In your login flow, once your backend knows the user
fun onLoggedIn(user: User) {
    AbrovaAbTesting.setUserId(user.id)   // the ID your backend puts in the token
    AbrovaAbTesting.refreshUserToken()   // asks tokenProvider again now
    AbrovaAbTesting.setUserAttributes(mapOf("plan" to user.plan, "country" to user.country))
}

// In your logout flow
fun onLoggedOut() {
    AbrovaAbTesting.clearUserId()
}

class CheckoutActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_checkout)

        // Check feature flag
        if (AbrovaAbTesting.isFeatureEnabled("dark-mode")) applyDarkTheme()

        // Get experiment variant, then track the view
        AbrovaAbTesting.getVariantAsync("checkout-redesign") { variant ->
            val config = AbrovaAbTesting.getVariantConfig("checkout-redesign")
            setupCheckout(variant, config)
            AbrovaAbTesting.trackView("checkout-redesign")
        }
    }

    private fun setupCheckout(variant: String, config: Map<String, Any>?) {
        val button = findViewById<Button>(R.id.checkoutButton)
        button.text = config?.get("text") as? String ?: "Complete Purchase"

        val colorHex = config?.get("color") as? String ?: when (variant) {
            "variant-a" -> "#22C55E"
            "variant-b" -> "#3B82F6"
            else -> "#6B7280"
        }
        button.setBackgroundColor(Color.parseColor(colorHex))

        button.setOnClickListener {
            AbrovaAbTesting.trackClick("checkout-redesign")
            processCheckout()
        }
    }

    private fun processCheckout() {
        // ... checkout logic ...
        AbrovaAbTesting.trackPurchase("checkout-redesign", orderTotal, "txn-123")
    }

    override fun onStop() {
        super.onStop()
        AbrovaAbTesting.flush()
    }
}

# Gson (used by AbrovaAbTesting)
-keepattributes Signature
-keepattributes *Annotation*
-keep class com.google.gson.** { *; }