Android SDK

import android.app.Application
import dev.sankofa.sdk.Sankofa
import dev.sankofa.sdk.SankofaConfig
import dev.sankofa.sdk.catchmod.SankofaCatch
import dev.sankofa.sdk.switchmod.SankofaSwitch
import dev.sankofa.sdk.remoteconfig.SankofaRemoteConfig
import dev.sankofa.sdk.pulse.SankofaPulse

class MyApplication : Application() {
  override fun onCreate() {
      super.onCreate()
      // Switch + Config first so the auto-discovered flag/config
      // snapshots Catch attaches to its events on the very first
      // crash already see something useful.
      SankofaSwitch.init(this, defaults = mapOf("new_checkout" to false))
      SankofaRemoteConfig.init(this, defaults = mapOf("max_upload_mb" to 25))

      // One-line init. enableCatch=true (default) auto-installs the
      // chained Thread.UncaughtExceptionHandler + ANR watcher — no
      // separate `SankofaCatch.init` call needed.
      Sankofa.init(
          context = this,
          apiKey = BuildConfig.SANKOFA_KEY,
          config = SankofaConfig(
              endpoint = "https://api.sankofa.dev",
              recordSessions = true,
              maskAllInputs = true,
              debug = BuildConfig.DEBUG,
              catchEnvironment = "production",
              release = "v1.0.0",
              appVersion = BuildConfig.VERSION_NAME,
          ),
      )

      SankofaPulse.register(applicationContext)
  }
}

<application
  android:name=".MyApplication"
  android:label="@string/app_name">
  ...
</application>

// Track
Sankofa.track("checkout_started", mapOf(
  "cart_value" to 49.99,
  "item_count" to 3
))

// Tag a screen
Sankofa.screen("Checkout")

// Identify
Sankofa.identify("user_123")

// Update profile traits
Sankofa.setPerson(
  name = "Ada Lovelace",
  email = "[email protected]",
  properties = mapOf("company" to "Sankofa Ltd")
)

// Logout
Sankofa.reset()

// Force-flush
Sankofa.flush()

// Capture a handled exception from anywhere — Sentry-style.
try {
  chargeCard(amount)
} catch (e: Exception) {
  Sankofa.captureException(e)
}

// Capture a non-error event (warning-level).
Sankofa.captureMessage("Payment retry attempted")

// Crashlytics-style breadcrumb log — rides on the next captured
// event. Doesn't bill on its own.
Sankofa.log("checkout: applying coupon SUMMER25")

// Attach ambient context. Sticky — every subsequent event carries it.
Sankofa.setUser(CatchUserContext(id = "user_123", email = "[email protected]"))
Sankofa.setTag("flow", "checkout")
Sankofa.setExtra("cart_id", cart.id)

// Structured breadcrumb (HTTP, navigation, console, etc.).
Sankofa.addBreadcrumb(CatchBreadcrumb(
  type = "user-action",
  category = "ui",
  message = "Tapped checkout"
))

Sankofa.withScope { scope ->
  scope.setTag("checkout_step", "payment")
  scope.setExtra("cart_id", cart.id)
  scope.setLevel(CatchLevel.WARNING)
  Sankofa.captureException(err)
}
// Outside the closure, those tags / extras are gone.

Sankofa.init(
  context = this,
  apiKey = BuildConfig.SANKOFA_KEY,
  config = SankofaConfig(
      endpoint = "https://api.sankofa.dev",
      beforeSend = { event ->
          // Drop framework noise.
          if (event.message?.contains("setState called after destroy") == true) {
              null
          } else if (event.user?.email != null) {
              // PII scrubbing — strip email.
              event.copy(user = event.user.copy(email = null))
          } else {
              event
          }
      },
  ),
)

npx sankofa-cli catch symbols upload \
--kind proguard_mapping \
--release "$RELEASE_SHA" \
--file ./build/outputs/mapping/release/mapping.txt

import dev.sankofa.sdk.switchmod.SankofaSwitch

class MyApplication : Application() {
  override fun onCreate() {
      super.onCreate()
      Sankofa.init(this, BuildConfig.SANKOFA_KEY, SankofaConfig())
      SankofaSwitch.init(this, mapOf(
          "new_checkout" to false,
          "dark_mode_default" to false
      ))
  }
}

if (SankofaSwitch.getFlag("new_checkout")) {
  showNewCheckout()
}

val variant = SankofaSwitch.getVariant("checkout_redesign", default = "control")

// Subscribe to changes
val token = SankofaSwitch.onChange("new_checkout") { decision ->
  runOnUiThread {
      binding.newCheckoutToggle.isChecked = decision.value as Boolean
  }
}

// Later: cancel
token.cancel()

import dev.sankofa.sdk.remoteconfig.SankofaRemoteConfig

// Init in Application.onCreate
SankofaRemoteConfig.init(this, mapOf(
  "max_upload_mb" to 25,
  "support_email" to "[email protected]"
))

// Read anywhere — generic typed read
val maxMB: Int = SankofaRemoteConfig.get("max_upload_mb", 25)
val email: String = SankofaRemoteConfig.get("support_email", "[email protected]")

// Subscribe to changes
val token = SankofaRemoteConfig.onChange("max_upload_mb") { decision ->
  // Update UI
}

// In Application.onCreate, after Sankofa.init
val registered = SankofaPulse.register(applicationContext)

// Show a survey from an Activity
SankofaPulse.show(surveyId = "srv_post_purchase_feedback", activity = this)

// Listen for events
val sub = SankofaPulse.on(PulseEvent.Completed) { event ->
  Log.i("pulse", "Survey ${event.surveyId} completed")
}

// Inspect eligibility
SankofaPulse.activeMatchingSurveys { surveys ->
  Log.i("pulse", "Eligible: ${surveys.map { it.id }}")
}

mySensitiveView.tag = "sankofa_mask"

@Composable
fun ProductList() {
  val scrollState = rememberScrollState()
  DisposableEffect(scrollState) {
      val handle = Sankofa.tagScrollContainer { scrollState.value }
      onDispose { handle.remove() }
  }
  Column(modifier = Modifier.verticalScroll(scrollState)) {
      // ...
  }
}

val handle = Sankofa.tagScrollContainer {
  lazyListState.firstVisibleItemIndex * estimatedItemHeightPx +
      lazyListState.firstVisibleItemScrollOffset
}