Android SDK

Kixo Android SDK Kotlin 2.0+ va Java’ni qo‘llab-quvvatlaydi, kamida minSdk 24 (Android 7.0)ni talab qiladi va compileSdk 35 asosida build qilingan. Host ilova o‘zining targetSdki uchun o‘zi javob beradi. Application.onCreate ichidagi bitta Kixo.configure chaqiruvi ekranlar, bosishlar, sessiyalar, crash’lar va lifecycle eventlarni avtomatik kuzatadi. Push tracking uchun quyida tasvirlangan FCM bridge kerak. Tarmoq so‘rovlarini avtomatik kuzatish hozirgi Android reliziga kirmaydi. SDK session replay, identity va maqsadlarni ham qo‘llab-quvvatlaydi.

Tezkor boshlash

Uchta fayl. Maven repo’ni qo‘shing, dependency’ni qo‘shing, keyin Application subclass’ingizga ikki qator kiriting.

Build talablari: compileSdk 35, minSdk 24, Kotlin 2.0+ yoki Java, va Java 17 bytecode.

dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
        maven {
            url = uri("https://raw.githubusercontent.com/kixoio/kixo-android-sdk/main/repo")
        }
    }
}

Ilovangizga qo‘shing

Kixo Maven repo’si GitHub Pages’da joylashgan. Uni settings.gradle.kts ichida google() va mavenCentral() bilan birga qo‘shing:

// settings.gradle.kts
dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
        maven {
            url = uri("https://raw.githubusercontent.com/kixoio/kixo-android-sdk/main/repo")
        }
    }
}

So‘ng dependency’ni ilova modulida e’lon qiling:

// app/build.gradle.kts
dependencies {
    implementation("io.kixo:kixo-android-sdk:0.1.20")
}

Ko‘p modulli loyihalar

Gradle’dagi implementation konfiguratsiyasi transitiv emas: kutubxona modulida (masalan, :core_domain) implementation("io.kixo:kixo-android-sdk:0.1.20")ni e’lon qilish Kixoni :app yoki boshqa iste’molchi modullarga ko‘rinadigan qilmaydi. Ishlaydigan ikki usul bor — bittasini tanlang.

Pattern A — Kixo’ni chaqiradigan har bir modul uni o‘zi e’lon qiladi (tavsiya etiladi). har bir modulning classpath’ini ixcham saqlaydi va zanjirli qayta buildlarning oldini oladi. Version catalog (libs.kixo.sdk) ishlating — shunda versiyani faqat bitta joyda o‘zgartirasiz.

// :core_domain/build.gradle.kts
dependencies {
    implementation("io.kixo:kixo-android-sdk:0.1.20")   // local use only
}

// :app/build.gradle.kts
dependencies {
    implementation(project(":core_domain"))
    implementation("io.kixo:kixo-android-sdk:0.1.20")   // declared again — fine
}

Pattern B — api(...) orqali qayta eksport qiling. Bitta e’lon yetarli, lekin endi kutubxona modulining public ABI’siga Kixo turlari ham kiradi — versiya o‘zgarsa, undan pastdagi barcha modullar qayta build bo‘ladi. Buni faqat kutubxona o‘zining public signaturalarida Kixo turlaridan foydalansa qo‘llang (masalan, funksiya KixoDiagnostics qaytarsa).

// :core_domain/build.gradle.kts
dependencies {
    api("io.kixo:kixo-android-sdk:0.1.20")              // re-exposed
}

// :app/build.gradle.kts
dependencies {
    implementation(project(":core_domain"))            // gets Kixo for free
}

Ishga tushirish

Kixo’ni Application subclass’ingizda sozlang — onCreate har qanday activity’dan oldin ishga tushadi, shuning uchun birinchi kadrdanoq barcha screen view, bosish va lifecycle eventlar qayd etiladi. Manifestda Applicationni android:name=".MyApp" bilan ro‘yxatdan o‘tkazing.

import android.app.Application
import io.kixo.sdk.Kixo

class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()
        Kixo.configure(
            context   = this,
            projectId = "kx_proj_YOUR_PROJECT_ID",
            apiKey    = "kx_key_YOUR_API_KEY",
        )
    }
}

Nozik sozlamalar uchun (auto-track flag’lari, flush oralig‘i, replay sampling, custom API host) KixoConfigurationni ochiq yaratib oling:

import io.kixo.sdk.Kixo
import io.kixo.sdk.KixoConfiguration

val config = KixoConfiguration.Builder(
    projectId = "kx_proj_YOUR_PROJECT_ID",
    apiKey    = "kx_key_YOUR_API_KEY",
)
    .autoTrackScreens(true)
    .autoTrackTaps(true)
    .autoTrackNetwork(false)  // reserved; no-op in the current Android release
    .autoTrackCrashes(true)
    .autoTrackSessions(true)
    .autoTrackPush(true)
    .flushIntervalMillis(30_000)
    .flushAt(20)
    .maxBufferSize(200)
    .build(applicationContext)

Kixo.configure(this, config)

Eventlarni kuzatish

Instrumentatsiyaning asosiy qismi uchta primitive’ga tayanadi: eventlar uchun track, konversiya signallari uchun markGoal va event bo‘lmagan kontekst uchun addBreadcrumb.

import io.kixo.sdk.Kixo

Kixo.track("video_played", mapOf(
    "video_id"    to "vid_42",
    "duration_ms" to 18_500,
    "autoplay"    to false,
))

// markGoal(name, value?, currency?, properties?) — pass extra context
// through the named 'properties' argument (a Map can't be the 2nd
// positional arg; that slot is the Double 'value').
Kixo.markGoal("activated", properties = mapOf(
    "step" to "onboarding_completed",
))

// Revenue goals use the typed value + currency parameters:
Kixo.markGoal("purchase_completed", value = 49.99, currency = "USD")

Kixo.addBreadcrumb(
    message  = "user toggled dark mode",
    category = "ui",
    level    = "info",
)

Standart eventlar

Kixo nomidan taniydigan eventlar uchun Kixo.track ustidagi qulay qobiq — backend’dagi standart event aniqlagichi aynan shu satr kalitlarini moslaydi. Property tuzilmasi compile time’da tekshiriladi, nomlash esa yagona manbadan boshqariladi.

import io.kixo.sdk.Kixo
import io.kixo.sdk.SubscriptionInterval

Kixo.trackPurchase(
    amount    = 49.99,
    currency  = "USD",
    productId = "pro_yearly",
)

Kixo.trackSubscriptionStart(
    plan     = "pro",
    amount   = 9.99,
    currency = "USD",
    interval = SubscriptionInterval.MONTH,
)

Kixo.trackSignup(method = "google")
Kixo.trackTrialStart(plan = "pro", days = 14)
Kixo.trackCancel(plan = "pro", reason = "too_expensive")
Kixo.trackUpgrade(fromPlan = "free", toPlan = "pro")
Kixo.trackActivation(event = "first_post_published")
Kixo.trackShare(channel = "twitter", contentId = "post_123")
Kixo.trackInvite(channel = "email", recipientCount = 5)

Foydalanuvchilarni tanitish

Keyingi eventlarni barqaror user id va traitlar to‘plamiga bog‘lang. Anonymous-to-known stitching Kixo ichida bajariladi — identifydan oldin yig‘ilgan eventlar keyinroq shu foydalanuvchiga biriktiriladi.

import io.kixo.sdk.Kixo

// Reserved standard property keys carry a $-prefix (Mixpanel
// convention) so they namespace away from your own custom traits
// and promote to the dashboard's profile columns. See
// io.kixo.sdk.StandardProperty for the typed catalogue, or the
// "Standard property catalog" section below for the full 37-key list.
Kixo.identify("user_123", mapOf(
    "$email" to "jane@example.com",     // identity
    "$name"  to "Jane Doe",              // identity
    "$plan"  to "pro",                   // subscription pack
    "$lifetime_orders" to 12,            // e-commerce pack
    "signup_source" to "twitter_ad",     // custom trait
))

// Logout: clear identity, super-properties, and the persisted queue.
Kixo.reset()

⚠️ Kotlin’da dollar belgisi tuzog‘i. Standart identity kalitlari $ prefiksi bilan yoziladi ($email, $name, $first_name) — Kotlin literalida esa dollar belgisini "\$email" ko‘rinishida escape qilish shart. Agar "$email" deb yozsangiz, satrga email o‘zgaruvchisining qiymati qo‘yiladi; natijada qiymat sezdirmay maxsus trait sifatida yozilib ketadi va Audience’dagi email / name ustunlari to‘lmaydi. Eng oson yechim — typed overload’dan foydalanish (SDK 0.1.13+): bunda adashib bo‘lmaydi: Kixo.setUserProperty(StandardProperty.EMAIL, email).

Foydalanuvchini segmentlash uchun belgilash

Foydalanuvchiga oddiy ha/yo‘q belgisi biriktirish uchun boolean qiymatli setUserPropertydan foydalaning. Bu belgi ilova qayta ochilgandan keyin ham saqlanadi va segmentlar, email kampaniyalari hamda chat so‘rovlari uchun ishlaydi — SDK chaqiruvidan tashqari boshqa sozlama kerak emas.

// Tag a user as subscribed — segments + campaigns can target this
Kixo.setUserProperty("subscribe", true)

// VIP membership
Kixo.setUserProperty("vip", true)

// String + numeric values work too
Kixo.setUserProperty("plan_tier", "enterprise")
Kixo.setUserProperty("lifetime_orders", 42)

// Bulk-set
Kixo.setUserProperties(mapOf(
    "subscribe" to true,
    "plan_tier" to "enterprise",
))

Propertylar SharedPreferences orqali ilova qayta ochilgandan keyin ham saqlanadi va har bir tashqi eventga avtomatik biriktiriladi. Chat’da "subscribe qiymati true bo‘lgan foydalanuvchilarga xush kelibsiz emailini yubor" kabi yozing — Kixo segmentni tuzib, shablon qoralamasini tayyorlab beradi. Kixo.reset()da tozalanadi.

Standart property katalogi

Ajratilgan property kalitlari maxsus traitlaringiz bilan to‘qnashmasligi uchun $ prefiksi bilan keladi. Kixo katalogida 37 ta kalit bor: 3 ta universal to‘plam (identity, geo, lifecycle) va 5 ta B2B vertikal to‘plam (subscription, e-commerce, media, marketplace, loyalty). Mahsulotingizga moslarini belgilang — dashboard faqat to‘ldirilgan to‘plamlarni ko‘rsatishga moslashadi.

Identity

Har doim qo‘llanadi. Profil sarlavhasidagi ustunlarni belgilaydi.

Geo

Geografik kontekst.

Hayot sikli

Ularni qachon ko‘rganmiz.

Obuna

Agar mahsulotingizda tariflar bo‘lsa, belgilang.

Elektron tijorat

Agar mahsulot sotsangiz, belgilang.

Media

Agar kontent nashr qilsangiz, belgilang.

Marketpleys

Agar ikki tomonlama platforma bo‘lsangiz, belgilang.

Sodiqlik

Faollik va mukofot dasturlari uchun qo‘llanadi.

Super-properties

Har bir tashqi eventga avtomatik biriktiriladigan, sessiya bo‘yicha saqlanadigan key/value juftliklar. identify traitlaridan farqli ravishda, ular identifikatsiyani emas, sessiya kontekstini ifodalaydi — masalan, faol A/B varianti, build flavor yoki yoqilgan feature flag’lar. Ilova qayta ishga tushirilgandan keyin ham saqlanadi; reset()da tozalanadi. To‘qnashuv bo‘lsa, trackdagi per-event properties har doim ustun keladi.

import io.kixo.sdk.Kixo

Kixo.setSuperProperty("build_flavor", "beta")
Kixo.setSuperProperties(mapOf(
    "ab_variant"        to "B",
    "referrer_campaign" to "autumn-launch",
))

// Sugar for A/B tracking — stored as 'experiment_<id>'.
Kixo.setExperimentVariant("checkout_v2", "variant_a")

Kixo.unsetSuperProperty("build_flavor")
Kixo.clearSuperProperties()

Push bildirishnomalar

Integratsiyaning ikki yo‘li bor. Agar FCM ishlatsangiz va eng qisqa ishlaydigan sozlama kerak bo‘lsa, A’ni tanlang; agar qayta tuzib bo‘lmaydigan custom FirebaseMessagingService bo‘lsa yoki Kixo qaysi FCM yetkazilishlarini ko‘rishini aniq boshqarmoqchi bo‘lsangiz, B’ni tanlang.

Variant A — KixoFirebaseMessagingServicedan meros oling (auto-tracking)

KixoFirebaseMessagingServicedan meros oling va override ichida super.onMessageReceived(...)ni chaqiring — Kixo push_receivedni (ko‘rinadigan payload) yoki push_silentni (faqat data) avtomatik yuboradi. Agar override qilmasangiz, bazaviy class onNewToken ro‘yxatdan o‘tishini ham boshqaradi. AndroidManifest.xml ro‘yxatdan o‘tishi oddiy FCM service’dagidek qoladi.

import com.google.firebase.messaging.RemoteMessage
import io.kixo.sdk.KixoFirebaseMessagingService

class MyMessagingService : KixoFirebaseMessagingService() {
    override fun onMessageReceived(remoteMessage: RemoteMessage) {
        super.onMessageReceived(remoteMessage)  // Kixo auto-tracks push_received
        // … your own routing / notification display
    }
}

Variant B — o‘z FCM service’ingizdan manual API’ni chaqiring

FCM tokenini FirebaseMessagingService.onNewToken orqali Kixo’da ro‘yxatdan o‘tkazing, so‘ng har bir yetkazilishni alohida log qiling. Agar Kixo FCM yetkazilishlarining faqat bir qismini ko‘rishini istasangiz, shu yo‘lni tanlang. Android’da yetkazilishni kuzatish hozircha faqat FCM’ni qo‘llab-quvvatlaydi.

import com.google.firebase.messaging.FirebaseMessagingService
import com.google.firebase.messaging.RemoteMessage
import io.kixo.sdk.Kixo
import io.kixo.sdk.PushProvider

class MyMessagingService : FirebaseMessagingService() {
    override fun onNewToken(token: String) {
        Kixo.setPushToken(token, PushProvider.FCM)
    }

    override fun onMessageReceived(message: RemoteMessage) {
        // Convert the FCM payload to a Map<String, Any?> and log it —
        // Kixo correlates this with the open / dismiss it sees later.
        Kixo.logPushReceived(message.data.toMap(), appState = "background")
    }
}

Android bildirishnomani ochish, yopish yoki undagi action buttonlar uchun universal lifecycle hook bermaydi. Bu signallarni ilovangiz yaratgan notification intent yoki receiverlardan uzating:

import io.kixo.sdk.Kixo

Kixo.logPushOpened(payload = pushPayload)            // open
Kixo.logPushOpened(payload = pushPayload, actionId = "reply")  // action-button tap
Kixo.logPushDismissed(payload = pushPayload)         // swipe-away

Sessiyani qayta ko‘rish

Foydalanuvchi ko‘rgan narsaning real vizual qayta tiklanishini ko‘ring. Har bir capture vaqtida SDK ekranning siqilgan kadrini (JPEG rasm) va view hierarchy’ning tuzilmaviy snapshot’ini kodlaydi hamda ikkalasini ham yuklaydi — shunda dashboard’dagi player o‘zaro ta’sirlar vaqt chizig‘i bilan birga piksellar darajasida aniq ijroni ko‘rsata oladi. Replay’ni loyiha bo‘yicha Boshqaruv paneli → Sozlamalar → Sessiya qayta ko‘rishida sozlang. SDK loyiha siyosatini, jumladan maskalash, capture rejimlari va mobil tarmoq orqali yuklash ruxsatini avtomatik o‘qiydi va yangilab turadi.

import io.kixo.sdk.Kixo
import io.kixo.sdk.KixoConfiguration

val config = KixoConfiguration.Builder(
    projectId = "kx_proj_YOUR_PROJECT_ID",
    apiKey    = "kx_key_YOUR_API_KEY",
)
    .build(applicationContext)

Kixo.configure(this, config)

Mobil tarmoq orqali yuklash o‘chirilgan bo‘lsa, navbatdagi replay ruxsat berilgan tarmoqni kutadi.

Ma’lumot yig‘ish

SDK loyihangizda yoqilgan ma’lumotlarni, shuningdek ilovangiz yuboradigan eventlar va propertylarni yig‘adi.

Debuglash

Kixo.diagnostics() SDK holatining faqat o‘qish uchun mo‘ljallangan snapshot’ini qaytaradi — yashirin debug ekranida yoki smoke testda juda qulay. “Nega eventlarim oqib bormayapti?” degan savolga debugger ochmasdan javob beradi.

import io.kixo.sdk.Kixo

val diag = Kixo.diagnostics()
Log.d("Kixo", "queued=${diag.queue.bufferedEventCount}")
Log.d("Kixo", "paused=${diag.paused}")                  // collection paused state
Log.d("Kixo", "lifecycleState=${diag.lifecycleState}")  // SDK lifecycle state

Test harness’dan flush’ni majburan ishga tushiring — tarmoqdagi bir round-trip uchun timeoutMsgacha bloklaydi:

import io.kixo.sdk.Kixo

// Async fire-and-forget — returns immediately.
Kixo.flush()

// Blocking variant for instrumentation tests. Never call on the main thread.
val landed: Boolean = Kixo.flushBlocking(timeoutMs = 5_000L)
assertTrue(landed)

Compose Navigation

Activity / Fragment route’lari darhol screen_vieweventlarini va dwell hamda flow metama’lumotlari bor tuzilmaviy screen_visit yozuvlarini qo‘shimcha sozlamasiz beradi. Jetpack Compose Navigation uchun route bo‘yicha kalitlangan LaunchedEffect ichidan Kixo.screenni yuboring — shunda SDK recomposition sonidan qat’i nazar har bir destination uchun bitta event ko‘radi.

import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.navigation.NavHostController
import androidx.navigation.compose.NavHost
import androidx.navigation.compose.composable
import io.kixo.sdk.Kixo

@Composable
fun AppNavHost(nav: NavHostController) {
    NavHost(navController = nav, startDestination = "home") {
        composable("home") {
            LaunchedEffect("home") { Kixo.screen("HomeScreen") }
            HomeScreen()
        }
        composable("settings") {
            LaunchedEffect("settings") { Kixo.screen("SettingsScreen") }
            SettingsScreen()
        }
    }
}

AI kod agentlari

SDK’ning public surface’i kichik va code completion uchun qulay qilib tuzilgan: barcha metodlar Kixo singleton’ida, bu qo‘llanmadagi barcha Kotlin misollari import io.kixo.sdk.Kixo bilan boshlanadi, README esa Claude Code, Cursor va Codex kabi vositalar kontekstiga bevosita qo‘yish mumkin bo‘lgan "AI agent quick reference" blokini o‘z ichiga oladi. Agentingiz tiqilib qolsa, ishonchli boshlang‘ich variant mana bu:

// Tell your AI coding agent:
// "Integrate the Kixo Android SDK using io.kixo:kixo-android-sdk
//  from https://raw.githubusercontent.com/kixoio/kixo-android-sdk/main/repo.
//  Call Kixo.configure(this, projectId, apiKey) in Application.onCreate.
//  Then use Kixo.track / Kixo.identify / Kixo.markGoal as needed."