Android v1.0.0.3

your-project/
  repo/
    com/
      trustingsocial/
        behaviors/
          1.0.0.3/
            behaviors-1.0.0.3.aar
            behaviors-1.0.0.3.pom
            behaviors-1.0.0.3.module

dependencyResolutionManagement {
    repositories {
        google()
        mavenCentral()
        maven {
            url = uri("${rootProject.projectDir}/repo")
        }
    }
}

dependencies {
    implementation("com.trustingsocial:behaviors:1.0.0.3")
}

import com.ts.behaviorsdk.external.TSBehavioralConfig
import com.ts.behaviorsdk.external.KeyboardConfig
import com.ts.behaviorsdk.external.TouchConfig
import com.ts.behaviorsdk.devicemetadata.MetaDataCollectionConfig
import com.ts.behaviorsdk.sensor.SensorConfig
import com.ts.behaviorsdk.data.SensorType

val config = TSBehavioralConfig(
    appId = "your-app-id",                   // Your app's package name / application ID
    baseUrl = "https://your-base-url/api",   // Provided by TrustVision
    metadataConfig = MetaDataCollectionConfig(
        intervalMillis = 2000L,
        enabled = true,
    ),
    uploadBlockSize = 10,
    sensorConfig = SensorConfig(
        samplingIntervalMs = 20L,
        sensorTypes = listOf(
            SensorType.Gyroscope,
            SensorType.Magnetometer,
            SensorType.Accelerometer,
            SensorType.Light,
        ),
        enabled = true,
    ),
    keyboardConfig = KeyboardConfig(
        trackRawText = false,
        enabled = true,
    ),
    touchConfig = TouchConfig(
        enabled = true,
    ),
    screenTransitionBlockSize = 1,
    appStateBlockSize = 1,
    batchExtra = mapOf("env" to "production"),
    retryConfig = RetryConfig(
        enabled = true,
        maxRetries = 2,
        retryDelayMs = 1000L,
        maxDelayMs = 5000L,
        maxRetryAttempts = 3,
        maxRetryStorageItems = 50,
        finalFlushTimeoutMs = 10000L,
        retryItemDelayMs = 500L,
    ),
)

val config = TSBehavioralConfig(
    appId = "com.example.app",
    baseUrl = "https://api.trustingsocial.com",
    metadataConfig = MetaDataCollectionConfig(intervalMillis = 2000),
    sslCertificates = listOf(R.raw.my_server_cert),
)

suspend fun initialize(context: Context, config: TSBehavioralConfig): TSDeviceInitInfo

lifecycleScope.launch {
    try {
        val initInfo = TSBehavioralSDK.initialize(applicationContext, config)

        Log.d("BehavioralSDK", "Device ID: ${initInfo.deviceId}")
        Log.d("BehavioralSDK", "Already registered: ${initInfo.isRegistered}")
    } catch (e: TSSessionError.KeystoreError) {
        Log.e("BehavioralSDK", "Keystore error: ${e.message}")
    } catch (e: TSSessionError.CryptoError) {
        Log.e("BehavioralSDK", "Crypto error: ${e.message}")
    }
}

suspend fun markDeviceRegistered(isRegistered: Boolean, customerUserDeviceId: String)

lifecycleScope.launch {
    val initInfo = TSBehavioralSDK.initialize(applicationContext, config)

    if (!initInfo.isRegistered) {
        // Your backend calls TrustVision API: POST /v1/register_device
        // with: device_id, key_pair_id, device_public_key, encrypted_secret_key, cus_user_id, protocol
        val userDeviceId = yourBackend.registerDevice(
            deviceId = initInfo.deviceId,
            keyPairId = initInfo.bootstrapKeyId,
            devicePublicKey = initInfo.encryptedDevicePublicKeyPayload,
            encryptedSecretKey = initInfo.encryptedSecretKey,
            cusUserId = "your-user-id",
        )

        TSBehavioralSDK.markDeviceRegistered(
            isRegistered = true,
            customerUserDeviceId = userDeviceId,
        )
    }
}

suspend fun startCollect(context: Context? = null)

lifecycleScope.launch {
    try {
        TSBehavioralSDK.startCollect(this@MainActivity)
        Log.d("BehavioralSDK", "Collection started")
    } catch (e: TSSessionError.DeviceNotRegistered) {
        Log.e("BehavioralSDK", "Register device first")
    } catch (e: TSSessionError.NetworkError) {
        Log.e("BehavioralSDK", "Network error: ${e.httpCode} ${e.message}")
    }
}

fun updateScreenTransition(value: String)
fun updateScreenTransition(value: ScreenTransitionCollectorListener)

// Must call immediately after startCollect()
TSBehavioralSDK.startCollect(context)
TSBehavioralSDK.updateScreenTransition("main_screen")

// Then call again on every screen navigation
TSBehavioralSDK.updateScreenTransition("payment_screen")

class PaymentActivity : AppCompatActivity(), ScreenTransitionCollectorListener {

    override fun getScreenName() = "payment_screen"

    override fun onResume() {
        super.onResume()
        TSBehavioralSDK.updateScreenTransition(this)
    }
}

suspend fun startKeyboardTracking(activity: Activity)
suspend fun startKeyboardTracking(view: View)
suspend fun startKeyboardTracking(editText: EditText)

// In your Activity's onResume — tracks all EditTexts
override fun onResume() {
    super.onResume()
    lifecycleScope.launch {
        TSBehavioralSDK.startKeyboardTracking(this@MyActivity)
    }
}

// In a Fragment — tracks all EditTexts in the fragment's view
lifecycleScope.launch {
    TSBehavioralSDK.startKeyboardTracking(fragment.requireView())
}

// Track a specific EditText
lifecycleScope.launch {
    TSBehavioralSDK.startKeyboardTracking(emailEditText)
}

suspend fun stopKeyboardTracking()
suspend fun stopKeyboardTracking(editText: EditText)

lifecycleScope.launch {
    TSBehavioralSDK.stopKeyboardTracking()
}

fun addKeyboardTrackingData(data: KeyboardData)

TSBehavioralSDK.addKeyboardTrackingData(
    KeyboardData(
        timestamp = System.currentTimeMillis(),
        type = KeyboardDataType.LowerText,
        textLength = 5,
        viewId = "email_field",
    )
)

fun trackTextChange(oldText: String, newText: String, viewId: String)

var email by remember { mutableStateOf("") }

TextField(
    value = email,
    onValueChange = { newValue ->
        TSBehavioralSDK.trackTextChange(
            oldText = email,
            newText = newValue,
            viewId = "email_field",
        )
        email = newValue
    },
    label = { Text("Email") }
)

fun trackTouchEvent(event: MotionEvent, activity: WeakReference<Activity>)
fun trackTouchEvent(event: PointerEventDto, activity: WeakReference<Activity>)

class MyActivity : AppCompatActivity() {

    override fun dispatchTouchEvent(event: MotionEvent): Boolean {
        TSBehavioralSDK.trackTouchEvent(event, WeakReference(this))
        return super.dispatchTouchEvent(event)
    }
}

TSBehavioralSDK.trackTouchEvent(
    PointerEventDto(
        actionName = "ACTION_DOWN",
        actionMasked = MotionEvent.ACTION_DOWN,
        pointerId = 0,
        globalX = 150.0,
        globalY = 300.0,
    ),
    WeakReference(this)
)

suspend fun finalizeCollect(): TSFinalizeResult

lifecycleScope.launch {
    try {
        val result = TSBehavioralSDK.finalizeCollect()

        Log.d("BehavioralSDK", "Challenge ID: ${result.challengeId}")
        Log.d("BehavioralSDK", "Last seq: ${result.lastSeq}")

        if (result.droppedBatchCount > 0) {
            Log.w(
                "BehavioralSDK",
                "Dropped ${result.droppedBatchCount} batches. Last error: ${result.lastUploadError}",
            )
        }

        // Send challengeId to your backend for scoring
        yourBackend.computeBehaviorScore(result.challengeId!!)
    } catch (e: TSSessionError) {
        Log.e("BehavioralSDK", "Finalize error: ${e.name} - ${e.message}")
    }
}

suspend fun stopCollect(): TSFinalizeResult

lifecycleScope.launch {
    try {
        val result = TSBehavioralSDK.stopCollect()
        Log.d("BehavioralSDK", "Stopped. Last seq: ${result.lastSeq}")
    } catch (e: TSSessionError) {
        Log.e("BehavioralSDK", "Stop error: ${e.message}")
    }
}

suspend fun clearDeviceIdentity()

lifecycleScope.launch {
    try {
        TSBehavioralSDK.clearDeviceIdentity()
        Log.d("BehavioralSDK", "Device identity cleared")
        // Must call initialize() again before using SDK
    } catch (e: TSSessionError) {
        Log.e("BehavioralSDK", "Clear error: ${e.message}")
    }
}

try {
    TSBehavioralSDK.startCollect(context)
} catch (e: TSSessionError.DeviceNotRegistered) {
    // Server says the device is not registered — register via your backend first
} catch (e: TSSessionError.SslPinningError) {
    // Certificate pinning failed — the server cert did not match a pinned certificate
} catch (e: TSSessionError.NetworkError) {
    // Network issue: check e.httpCode, e.serverErrorCode, and e.message
} catch (e: TSSessionError) {
    // Any other SDK error: use e.name and e.message
}

import android.os.Bundle
import android.view.MotionEvent
import androidx.appcompat.app.AppCompatActivity
import androidx.lifecycle.lifecycleScope
import com.ts.behaviorsdk.TSBehavioralSDK
import com.ts.behaviorsdk.external.TSBehavioralConfig
import com.ts.behaviorsdk.external.TSSessionError
import com.ts.behaviorsdk.devicemetadata.MetaDataCollectionConfig
import com.ts.behaviorsdk.sensor.SensorConfig
import com.ts.behaviorsdk.external.KeyboardConfig
import com.ts.behaviorsdk.external.TouchConfig
import com.ts.behaviorsdk.data.SensorType
import kotlinx.coroutines.launch
import java.lang.ref.WeakReference

class BehavioralActivity : AppCompatActivity() {

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

        lifecycleScope.launch {
            try {
                // 1. Configure SDK
                val config = TSBehavioralConfig(
                    appId = "your-app-id",
                    baseUrl = "https://your-base-url/api",
                    metadataConfig = MetaDataCollectionConfig(
                        intervalMillis = 2000L,
                    ),
                    sensorConfig = SensorConfig(
                        samplingIntervalMs = 20L,
                        sensorTypes = listOf(
                            SensorType.Gyroscope,
                            SensorType.Magnetometer,
                            SensorType.Accelerometer,
                            SensorType.Light,
                        ),
                    ),
                    keyboardConfig = KeyboardConfig(
                        trackRawText = false,
                    ),
                    touchConfig = TouchConfig(
                        enabled = true,
                    ),
                )

                // 2. Initialize SDK
                val initInfo = TSBehavioralSDK.initialize(
                    this@BehavioralActivity, config
                )

                // 3. Register device (skip if already registered)
                if (!initInfo.isRegistered) {
                    // Your backend calls:
                    //   POST /v1/register_device
                    //   Body: {
                    //     "device_id": initInfo.deviceId,
                    //     "key_pair_id": initInfo.bootstrapKeyId,
                    //     "device_public_key": initInfo.encryptedDevicePublicKeyPayload,
                    //     "encrypted_secret_key": initInfo.encryptedSecretKey,
                    //     "cus_user_id": "your-user-id",
                    //     "protocol": "encrypted"
                    //   }
                    //   Response: { "data": { "customer_user_device_id": "..." } }
                    val userDeviceId = yourBackend.registerDevice(
                        deviceId = initInfo.deviceId,
                        keyPairId = initInfo.bootstrapKeyId,
                        devicePublicKey = initInfo.encryptedDevicePublicKeyPayload,
                        encryptedSecretKey = initInfo.encryptedSecretKey,
                        cusUserId = "your-user-id",
                    )

                    TSBehavioralSDK.markDeviceRegistered(
                        isRegistered = true,
                        customerUserDeviceId = userDeviceId,
                    )
                }

                // 4. Start data collection
                TSBehavioralSDK.startCollect(this@BehavioralActivity)

                // 5. Start keyboard tracking
                TSBehavioralSDK.startKeyboardTracking(this@BehavioralActivity)

                // 6. Record initial screen
                TSBehavioralSDK.updateScreenTransition("main_screen")

            } catch (e: TSSessionError) {
                Log.e("BehavioralSDK", "Error [${e.name}]: ${e.message}")
            }
        }
    }

    // 7. Track touch events via dispatchTouchEvent
    override fun dispatchTouchEvent(event: MotionEvent): Boolean {
        TSBehavioralSDK.trackTouchEvent(event, WeakReference(this))
        return super.dispatchTouchEvent(event)
    }

    // 8. Track screen transitions on navigation
    private fun navigateToPayment() {
        TSBehavioralSDK.updateScreenTransition("payment_screen")
        // ... navigate to payment screen
    }

    // 9. Finalize when the flow is complete
    private fun onFlowComplete() {
        lifecycleScope.launch {
            try {
                val result = TSBehavioralSDK.finalizeCollect()

                // Send challengeId to your backend to compute behavior score:
                //   POST /v1/behavior/score
                //   Body: { "challenge_id": result.challengeId }
                yourBackend.computeBehaviorScore(result.challengeId!!)

            } catch (e: TSSessionError) {
                Log.e("BehavioralSDK", "Finalize error: ${e.message}")
            }
        }
    }

    // 10. Clear identity on logout
    private fun onLogout() {
        lifecycleScope.launch {
            TSBehavioralSDK.clearDeviceIdentity()
            // Must call initialize() again before next use
        }
    }
}

POST {baseUrl}/v1/register_device
Content-Type: application/json
Authorization: TV {accessKeyId}:{signature}
X-TV-Timestamp: {ISO8601 UTC timestamp}

{
  "device_id": "from initResult.deviceId",
  "key_pair_id": "from initResult.bootstrapKeyId",
  "device_public_key": "from initResult.encryptedDevicePublicKeyPayload",
  "encrypted_secret_key": "from initResult.encryptedSecretKey",
  "cus_user_id": "your-user-identifier",
  "protocol": "encrypted"
}

{
  "data": {
    "customer_user_device_id": "server-assigned-id"
  }
}

{METHOD}\n{PATH}\n{TIMESTAMP}

import io.ktor.client.*
import io.ktor.client.call.*
import io.ktor.client.request.*
import io.ktor.http.*
import kotlinx.serialization.SerialName
import kotlinx.serialization.Serializable
import java.time.ZoneId
import java.time.ZonedDateTime
import java.time.format.DateTimeFormatter
import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec
import android.util.Base64

@Serializable
data class RegisterDeviceRequest(
    @SerialName("key_pair_id") val keyPairId: String,
    @SerialName("device_public_key") val devicePublicKey: String,
    @SerialName("encrypted_secret_key") val encryptedSecretKey: String,
    @SerialName("cus_user_id") val cusUserId: String,
    @SerialName("device_id") val deviceId: String,
    val protocol: String = "encrypted",
)

@Serializable
data class RegisterDeviceResponse(
    val data: Data,
) {
    @Serializable
    data class Data(
        @SerialName("customer_user_device_id") val customerUserDeviceId: String,
    )
}

// --- API Client ---

suspend fun registerDevice(
    httpClient: HttpClient,
    request: RegisterDeviceRequest,
): String {
    val response: RegisterDeviceResponse = httpClient
        .post("/api/v1/register_device") {
            contentType(ContentType.Application.Json)
            setBody(request)
        }.body()
    return response.data.customerUserDeviceId
}

// --- HMAC-SHA256 Signing ---

private fun createSignature(
    method: String,
    path: String,
    accessKeySecret: String,
    timestamp: String,
): String {
    val stringToSign = "$method\n$path\n$timestamp"
    val sha256Hmac = Mac.getInstance("HmacSHA256")
    val secretKeySpec = SecretKeySpec(accessKeySecret.toByteArray(), "HmacSHA256")
    sha256Hmac.init(secretKeySpec)
    return Base64.encodeToString(
        sha256Hmac.doFinal(stringToSign.toByteArray()),
        Base64.NO_WRAP,
    )
}

// --- Usage with Ktor Auth Plugin ---

val formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SSSZZZZZ")
val timestamp = ZonedDateTime.now(ZoneId.of("UTC")).format(formatter)
val method = "POST"
val path = "/v1/register_device"
val signature = createSignature(method, path, accessKeySecret, timestamp)

// Set headers on request:
// "X-TV-Timestamp" to timestamp
// "Authorization" to "TV $accessKeyId:$signature"

// 1. Initialize SDK
val initResult = TSBehavioralSDK.initialize(context, config)

// 2. Register device via your backend
val request = RegisterDeviceRequest(
    keyPairId = initResult.bootstrapKeyId,
    devicePublicKey = initResult.encryptedDevicePublicKeyPayload,
    encryptedSecretKey = initResult.encryptedSecretKey,
    cusUserId = "your-user-id",
    deviceId = initResult.deviceId,
)
val customerUserDeviceId = registerDevice(httpClient, request)

// 3. Mark device as registered in SDK
TSBehavioralSDK.markDeviceRegistered(
    isRegistered = true,
    customerUserDeviceId = customerUserDeviceId,
)

// 4. Now you can start collecting
TSBehavioralSDK.startCollect(context)