iOS v1.0.1.x

let config = TSBehavioralConfig(
    appId: "your-app-id",
    baseUrl: "https://your-base-url/api"
)

let config = TSBehavioralConfig(
    appId: "your-app-id",
    baseUrl: "https://your-base-url/api",
    bootstrapKeyId: "your-bootstrap-key-id",          // Provided by TrustVision
    bootstrapPublicKey: "your-bootstrap-public-key"   // Provided by TrustVision
)

try await TSBehavioralSDK.shared.startCollect()

// Either: one call that closes the running session and opens the next
let previous = try await TSBehavioralSDK.shared.switchJourney()

// Or: two calls
let result = try await TSBehavioralSDK.shared.finalizeCollect()
try await TSBehavioralSDK.shared.startCollect()

let initInfo = try await TSBehavioralSDK.shared.initialize(config: config)
if !initInfo.isRegistered {
    let userDeviceId = try await yourBackend.registerDevice(/* initInfo fields, cusUserId */)
    try TSBehavioralSDK.shared.markDeviceRegistered(
        isRegistered: true,
        customerUserDeviceId: userDeviceId
    )
}

try await TSBehavioralSDK.shared.initialize(config: config)
try await TSBehavioralSDK.shared.setCusUserId(signedInUserId)

if case .required(let request) = try await TSBehavioralSDK.shared.getRegistrationStatus() {
    do {
        let responseData = try await yourBackend.registerDevice(request)
        try TSBehavioralSDK.shared.markDeviceRegistered(
            encryptedPayload: responseData,
            cusUserId: request.cusUserId
        )
    } catch {
        try await TSBehavioralSDK.shared.reportRegistrationFailed(
            statusCode: (error as? YourHTTPError)?.statusCode,
            cusUserId: request.cusUserId
        )
        throw error
    }
}

<!-- Required only if canAskPermission is true and Bluetooth is used -->
<key>NSBluetoothAlwaysUsageDescription</key>
<string>Used for device behavioral analysis</string>

<!-- Required only if canAskPermission is true and Location is used -->
<key>NSLocationWhenInUseUsageDescription</key>
<string>Used for device behavioral analysis</string>

import BehaviorSDK

let config = TSBehavioralConfig(
    appId: "your-app-id",                    // Your app's bundle identifier
    baseUrl: "https://your-base-url/api",    // Provided by TrustVision
    bootstrapKeyId: "your-bootstrap-key-id", // Provided by TrustVision
    bootstrapPublicKey: "your-bootstrap-public-key", // Provided by TrustVision
    metadataConfig: MetaDataCollectionConfig(
        intervalMillis: 2000,
        canAskPermission: false,
        enabled: true
    ),
    uploadBlockSize: 10,
    sensorConfig: SensorConfig(
        samplingIntervalMs: 20,
        enabled: true
    ),
    keyboardConfig: KeyboardConfig(
        trackRawText: false,
        enabled: true
    ),
    touchConfig: TouchConfig(
        enabled: true
    ),
    screenTransitionBlockSize: 1,
    appStateBlockSize: 1,
    retryConfig: RetryConfig(
        enabled: true,
        maxRetries: 2,
        retryDelayMs: 1000,
        maxDelayMs: 5000,
        maxRetryAttempts: 3,
        maxRetryStorageItems: 50,
        finalFlushTimeoutSeconds: 10,
        retryItemDelaySeconds: 0.5
    ),
    challengeTtlMillis: 240_000
)

let config = TSBehavioralConfig(
    appId: "com.example.app",
    baseUrl: "https://api.trustingsocial.com",
    bootstrapKeyId: "your-bootstrap-key-id",
    bootstrapPublicKey: "your-bootstrap-public-key",
    sslCertificates: [
        TSCertificate(name: "my_server_cert", type: "der")
    ]
)

@discardableResult
func initialize(config: TSBehavioralConfig) async throws -> TSDeviceInitInfo

Task {
    do {
        let initInfo = try await TSBehavioralSDK.shared.initialize(
            config: config
        )

        print("Device ID: \(initInfo.deviceId)")
    } catch TSSessionError.invalidConfiguration(let field, let reason) {
        print("Invalid \(field): \(reason)")
    } catch let error as TSSessionError {
        print("Init error [\(error.name)]: \(error.localizedDescription)")
    }
}

@MainActor
func setCusUserId(_ cusUserId: String?) async throws

try await TSBehavioralSDK.shared.setCusUserId("your-user-id")

@MainActor
func getRegistrationStatus() async throws -> TSRegistrationStatus

switch try await TSBehavioralSDK.shared.getRegistrationStatus() {
case .registered:
    try await TSBehavioralSDK.shared.startCollect()
case .coolingDown:
    break // Try again later
case .required(let request):
    // Call your register-device API with the request's values
    break
}

func markDeviceRegistered(isRegistered: Bool, customerUserDeviceId: String, cusUserId: String? = nil) throws

func markDeviceRegistered(encryptedPayload: Data, cusUserId: String? = nil) throws

if case .required(let request) = try await TSBehavioralSDK.shared.getRegistrationStatus() {
    // 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
    let userDeviceId = try await yourBackend.registerDevice(
        deviceId: request.deviceId,
        keyPairId: request.bootstrapKeyId,
        devicePublicKey: request.encryptedDevicePublicKeyPayload,
        encryptedSecretKey: request.encryptedSecretKey,
        cusUserId: request.cusUserId
    )

    try TSBehavioralSDK.shared.markDeviceRegistered(
        isRegistered: true,
        customerUserDeviceId: userDeviceId,
        cusUserId: request.cusUserId
    )
}

let responseData = try await yourBackend.registerDeviceRaw(request)
// responseData is the raw Data from your server
// SDK parses: { "data": { "customer_user_device_id": "..." } }
try TSBehavioralSDK.shared.markDeviceRegistered(
    encryptedPayload: responseData,
    cusUserId: request.cusUserId
)

@MainActor
func reportRegistrationFailed(statusCode: Int?, cusUserId: String? = nil) async throws

do {
    let responseData = try await yourBackend.registerDeviceRaw(request)
    try TSBehavioralSDK.shared.markDeviceRegistered(
        encryptedPayload: responseData,
        cusUserId: request.cusUserId
    )
} catch {
    try await TSBehavioralSDK.shared.reportRegistrationFailed(
        statusCode: (error as? YourHTTPError)?.statusCode,
        cusUserId: request.cusUserId
    )
}

@MainActor
func startCollect() async throws

Task { @MainActor in
    do {
        try await TSBehavioralSDK.shared.startCollect()
        print("Collection started")
    } catch let error as TSSessionError {
        switch error {
        case .deviceNotRegistered:
            print("Register device first")
        case .networkError(let underlyingError):
            print("Network error: \(underlyingError)")
        default:
            print("Error: \(error.name)")
        }
    }
}

@MainActor
func switchJourney() async throws -> TSFinalizeCollectResult?

Task { @MainActor in
    do {
        if let previous = try await TSBehavioralSDK.shared.switchJourney() {
            // Score the journey that just ended
            try await yourBackend.computeBehaviorScore(
                challengeId: previous.challengeId
            )
        }
    } catch let error as TSSessionError {
        print("Switch error [\(error.name)]: \(error.localizedDescription)")
    }
}

func updateScreenTransition(screenName: String)

TSBehavioralSDK.shared.updateScreenTransition(screenName: "main_screen")
try await TSBehavioralSDK.shared.startCollect() // reports "main_screen"

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

class BehavioralBaseVC: UIViewController {
    var screenName: String? { nil }

    override func viewDidAppear(_ animated: Bool) {
        super.viewDidAppear(animated)
        if let name = screenName {
            TSBehavioralSDK.shared.updateScreenTransition(
                screenName: name
            )
        }
    }
}

class PaymentVC: BehavioralBaseVC {
    override var screenName: String? { "payment" }
}

class InputPinVC: BehavioralBaseVC {
    override var screenName: String? { "input_pin" }
}

@MainActor func startKeyboardTracking(textField: UITextField)
@MainActor func startKeyboardTracking(textView: UITextView)

class FormVC: UIViewController {
    @IBOutlet weak var emailField: UITextField!
    @IBOutlet weak var nameField: UITextField!

    override func viewWillAppear(_ animated: Bool) {
        super.viewWillAppear(animated)
        // Only track non-secure text fields
        TSBehavioralSDK.shared.startKeyboardTracking(textField: emailField)
        TSBehavioralSDK.shared.startKeyboardTracking(textField: nameField)
    }
}

func stopKeyboardTracking(textField: UITextField)
func stopKeyboardTracking(textView: UITextView)

override func viewWillDisappear(_ animated: Bool) {
    super.viewWillDisappear(animated)
    TSBehavioralSDK.shared.stopKeyboardTracking(textField: emailField)
    TSBehavioralSDK.shared.stopKeyboardTracking(textField: nameField)
}

func addKeyboardTrackingData(_ data: TSTypingData)

TSBehavioralSDK.shared.addKeyboardTrackingData(
    TSTypingData(
        timestamp: Int64(Date().timeIntervalSince1970 * 1000),
        textLength: 5,
        data: nil,
        type: .lowerText,
        viewId: "email_field"
    )
)

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

struct LoginView: View {
    @State private var email = ""
    @State private var previousEmail = ""

    var body: some View {
        TextField("Email", text: $email)
            .onChange(of: email) { newValue in
                TSBehavioralSDK.shared.trackTextChange(
                    oldText: previousEmail,
                    newText: newValue,
                    viewId: "email_field"
                )
                previousEmail = newValue
            }
    }
}

TextField("Email", text: $email)
    .onChange(of: email) { oldValue, newValue in
        TSBehavioralSDK.shared.trackTextChange(
            oldText: oldValue,
            newText: newValue,
            viewId: "email_field"
        )
    }

func trackTouchEvent(event: TSPointerEventDto)

TSBehavioralSDK.shared.trackTouchEvent(
    event: TSPointerEventDto(
        actionName: "down",
        actionMasked: 0,
        pointerId: 0,
        globalX: 150.0,
        globalY: 300.0
    )
)

@MainActor
func finalizeCollect() async throws -> TSFinalizeCollectResult

Task { @MainActor in
    do {
        let result = try await TSBehavioralSDK.shared.finalizeCollect()

        print("Challenge ID: \(result.challengeId)")
        print("Last seq: \(result.lastSeq)")

        if result.droppedBatchCount > 0 {
            print("Dropped \(result.droppedBatchCount) batches. Last error: \(result.lastUploadError ?? "nil")")
        }

        // Send challengeId to your backend for scoring
        try await yourBackend.computeBehaviorScore(
            challengeId: result.challengeId
        )
    } catch let error as TSSessionError {
        print("Finalize error [\(error.name)]: \(error.localizedDescription)")
    }
}

@MainActor
func stopCollect() throws -> TSFinalizeCollectResult

override func viewWillDisappear(_ animated: Bool) {
    super.viewWillDisappear(animated)
    if isMovingFromParent {
        do {
            let result = try TSBehavioralSDK.shared.stopCollect()
            print("Stopped. Last seq: \(result.lastSeq)")
        } catch {
            print("Stop error: \(error)")
        }
    }
}

@MainActor
func clearUser() async throws

func onLogout() async {
    _ = try? await TSBehavioralSDK.shared.finalizeCollect()
    try? await TSBehavioralSDK.shared.clearUser()
}

@MainActor
func clearDeviceIdentity() async throws

do {
    try await TSBehavioralSDK.shared.clearDeviceIdentity()
    print("Device identity cleared")
    // Must call initialize() again before using SDK
} catch {
    print("Clear error: \(error)")
}

func getEnabledFlag() -> Bool?
func setEnabledFlag(_ enabled: Bool?)

if TSBehavioralSDK.shared.getEnabledFlag() != false {
    try await TSBehavioralSDK.shared.initialize(config: config)
}

// Later, when your remote config changes
TSBehavioralSDK.shared.setEnabledFlag(remoteConfig.behavioralEnabled)

do {
    try await TSBehavioralSDK.shared.startCollect()
} catch let error as TSSessionError {
    switch error {
    case .deviceNotRegistered:
        // Server says the device is not registered — register via your backend first
        print("Register device first")
    case .sslPinningError(let underlyingError):
        print("SSL pinning failed: \(underlyingError)")
    case .networkError(let underlyingError):
        if let apiError = underlyingError as? ApiError {
            print("Network error [\(apiError.serverErrorCode ?? "-")]: \(apiError.serverErrorMessage ?? "")")
        } else {
            print("Network error: \(underlyingError)")
        }
    default:
        print("SDK error [\(error.name)]: \(error.localizedDescription)")
    }
}

import UIKit
import BehaviorSDK

class BehavioralViewController: UIViewController {

    @IBOutlet weak var emailTextField: UITextField!
    @IBOutlet weak var passwordTextField: UITextField!
    @IBOutlet weak var submitButton: UIButton!

    private var collectTask: Task<Void, Never>?

    // MARK: - Lifecycle

    override func viewDidLoad() {
        super.viewDidLoad()
        collectTask = Task { @MainActor in
            await setupAndStartCollection()
        }
    }

    override func viewWillDisappear(_ animated: Bool) {
        super.viewWillDisappear(animated)
        if isMovingFromParent {
            collectTask?.cancel()
            // Fast stop if user navigates away
            _ = try? TSBehavioralSDK.shared.stopCollect()
        }
    }

    // MARK: - SDK Setup

    func setupAndStartCollection() async {
        let sdk = TSBehavioralSDK.shared
        do {
            // 1. Configure SDK
            let config = TSBehavioralConfig(
                appId: "your-app-id",
                baseUrl: "https://your-base-url/api",
                bootstrapKeyId: "your-bootstrap-key-id",
                bootstrapPublicKey: "your-bootstrap-public-key",
                metadataConfig: MetaDataCollectionConfig(
                    intervalMillis: 2000
                ),
                sensorConfig: SensorConfig(
                    samplingIntervalMs: 20
                ),
                keyboardConfig: KeyboardConfig(
                    trackRawText: false
                ),
                touchConfig: TouchConfig(
                    enabled: true
                )
            )

            // 2. Initialize SDK
            try await sdk.initialize(config: config)

            // 3. Tell the SDK who signed in
            try await sdk.setCusUserId("your-user-id")

            // 4. Register device if the SDK says so
            switch try await sdk.getRegistrationStatus() {
            case .registered:
                break
            case .coolingDown:
                return // A registration was rejected recently; try again later
            case .required(let request):
                do {
                    // Your backend calls:
                    //   POST /v1/register_device
                    //   Body: {
                    //     "device_id": request.deviceId,
                    //     "key_pair_id": request.bootstrapKeyId,
                    //     "device_public_key": request.encryptedDevicePublicKeyPayload,
                    //     "encrypted_secret_key": request.encryptedSecretKey,
                    //     "cus_user_id": request.cusUserId,
                    //     "protocol": "encrypted"
                    //   }
                    //   Response: { "data": { "customer_user_device_id": "..." } }
                    let userDeviceId = try await yourBackend.registerDevice(
                        deviceId: request.deviceId,
                        keyPairId: request.bootstrapKeyId,
                        devicePublicKey: request.encryptedDevicePublicKeyPayload,
                        encryptedSecretKey: request.encryptedSecretKey,
                        cusUserId: request.cusUserId
                    )
                    try sdk.markDeviceRegistered(
                        isRegistered: true,
                        customerUserDeviceId: userDeviceId,
                        cusUserId: request.cusUserId
                    )
                } catch {
                    try await sdk.reportRegistrationFailed(
                        statusCode: (error as? YourHTTPError)?.statusCode,
                        cusUserId: request.cusUserId
                    )
                    throw error
                }
            }

            // 5. Report the current screen (remembered and reported into the session)
            sdk.updateScreenTransition(screenName: "login_screen")

            // 6. Start keyboard tracking (attached when the session opens)
            sdk.startKeyboardTracking(textField: emailTextField)

            // 7. Start data collection (no-op if a session is already collecting)
            try await sdk.startCollect()

        } catch let error as TSSessionError {
            print("SDK error [\(error.name)]: \(error.localizedDescription)")
        } catch {
            print("Unexpected error: \(error)")
        }
    }

    // MARK: - Screen Navigation

    func navigateToPayment() {
        // 8. Track screen transitions on navigation
        TSBehavioralSDK.shared.updateScreenTransition(
            screenName: "payment_screen"
        )
        // ... navigate to payment screen
    }

    // MARK: - New journey on the same screen

    func startNewJourney() {
        Task { @MainActor in
            // 9. Close the running session and open the next one in one call
            if let previous = try? await TSBehavioralSDK.shared.switchJourney() {
                try? await yourBackend.computeBehaviorScore(
                    challengeId: previous.challengeId
                )
            }
        }
    }

    // MARK: - Finalize

    @IBAction func submitTapped(_ sender: UIButton) {
        Task { @MainActor in
            do {
                // 10. Finalize — flushes data, drains upload queue, detaches text fields
                let result = try await TSBehavioralSDK.shared.finalizeCollect()

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

            } catch let error as TSSessionError {
                print("Finalize error [\(error.name)]: \(error.localizedDescription)")
            }
        }
    }

    // MARK: - Logout

    func onLogout() {
        Task { @MainActor in
            // 11. Forget the signed-in user; the device identity is kept
            do {
                try await TSBehavioralSDK.shared.clearUser()
            } catch {
                print("Clear user error: \(error)")
            }
        }
    }
}

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

{
  "device_id": "from request.deviceId",
  "key_pair_id": "from request.bootstrapKeyId",
  "device_public_key": "from request.encryptedDevicePublicKeyPayload",
  "encrypted_secret_key": "from request.encryptedSecretKey",
  "cus_user_id": "from request.cusUserId",
  "protocol": "encrypted"
}

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

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

import Foundation
import CryptoKit
import BehaviorSDK

struct DemoApiClient {
    let endpoint: String
    let apiKeyId: String
    let apiSecretKey: String

    struct HTTPError: Error {
        let statusCode: Int
    }

    // MARK: - Register Device

    /// Returns the raw response body, for `markDeviceRegistered(encryptedPayload:cusUserId:)`.
    func registerDevice(_ request: TSRegistrationRequest) async throws -> Data {
        let path = "/v1/register_device"
        guard let url = URL(string: endpoint + path) else {
            throw URLError(.badURL)
        }

        let body: [String: String] = [
            "cus_user_id": request.cusUserId,
            "device_id": request.deviceId,
            "key_pair_id": request.bootstrapKeyId,
            "device_public_key": request.encryptedDevicePublicKeyPayload,
            "encrypted_secret_key": request.encryptedSecretKey,
            "protocol": "encrypted",
        ]
        let jsonData = try JSONSerialization.data(withJSONObject: body)

        var urlRequest = URLRequest(url: url)
        urlRequest.httpMethod = "POST"
        urlRequest.httpBody = jsonData
        urlRequest.setValue("application/json", forHTTPHeaderField: "Content-Type")
        applyAuthHeaders(to: &urlRequest, method: "POST", path: path)

        let (data, response) = try await URLSession.shared.data(for: urlRequest)
        guard let httpResponse = response as? HTTPURLResponse else {
            throw URLError(.badServerResponse)
        }
        guard (200...299).contains(httpResponse.statusCode) else {
            throw HTTPError(statusCode: httpResponse.statusCode)
        }
        return data
    }

    // MARK: - HMAC-SHA256 Signing

    private func applyAuthHeaders(
        to request: inout URLRequest,
        method: String,
        path: String
    ) {
        let formatter = ISO8601DateFormatter()
        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
        let timestamp = formatter.string(from: Date())

        let stringToSign = "\(method)\n\(path)\n\(timestamp)"
        let hmac = HMAC<SHA256>.authenticationCode(
            for: Data(stringToSign.utf8),
            using: SymmetricKey(data: Data(apiSecretKey.utf8))
        )
        let signature = Data(hmac).base64EncodedString()

        request.setValue(timestamp, forHTTPHeaderField: "X-TV-Timestamp")
        request.setValue("TV \(apiKeyId):\(signature)", forHTTPHeaderField: "Authorization")
    }
}

let sdk = TSBehavioralSDK.shared

// 1. Initialize SDK
let config = TSBehavioralConfig(
    appId: "your-app-id",
    baseUrl: "https://your-trustvision-endpoint.com/api",
    bootstrapKeyId: "your-bootstrap-key-id",
    bootstrapPublicKey: "your-bootstrap-public-key"
)
try await sdk.initialize(config: config)
try await sdk.setCusUserId("your-user-id")

// 2. Register device if required
if case .required(let request) = try await sdk.getRegistrationStatus() {
    let client = DemoApiClient(
        endpoint: "https://your-trustvision-endpoint.com/api",
        apiKeyId: "your-access-key-id",
        apiSecretKey: "your-access-key-secret"
    )
    do {
        let responseData = try await client.registerDevice(request)

        // 3. Mark device as registered in SDK
        try sdk.markDeviceRegistered(
            encryptedPayload: responseData,
            cusUserId: request.cusUserId
        )
    } catch {
        try await sdk.reportRegistrationFailed(
            statusCode: (error as? DemoApiClient.HTTPError)?.statusCode,
            cusUserId: request.cusUserId
        )
        throw error
    }
}

// 4. Now you can start collecting
try await sdk.startCollect()