iOS v1.0.0.3

<!-- 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
    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
    )
)

let config = TSBehavioralConfig(
    appId: "com.example.app",
    baseUrl: "https://api.trustingsocial.com",
    sslCertificates: [
        TSCertificate(name: "my_server_cert", type: "der")
    ]
)

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

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

        print("Device ID: \(initInfo.deviceId)")
        print("Already registered: \(initInfo.isRegistered)")
    } catch let error as TSSessionError {
        print("Init error [\(error.name)]: \(error.localizedDescription)")
    }
}

func markDeviceRegistered(isRegistered: Bool, customerUserDeviceId: String) throws

func markDeviceRegistered(encryptedPayload: Data) throws

let initInfo = try await TSBehavioralSDK.shared.initialize(config: 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
    let userDeviceId = try await yourBackend.registerDevice(
        deviceId: initInfo.deviceId,
        keyPairId: initInfo.bootstrapKeyId,
        devicePublicKey: initInfo.encryptedDevicePublicKeyPayload,
        encryptedSecretKey: initInfo.encryptedSecretKey,
        cusUserId: "your-user-id"
    )

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

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

@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)")
        }
    }
}

func updateScreenTransition(screenName: String)

try await TSBehavioralSDK.shared.startCollect()
TSBehavioralSDK.shared.updateScreenTransition(screenName: "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: passwordField)
}

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 = ""

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

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)")
        }
    }
}

func clearDeviceIdentity() throws

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

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 {
        do {
            // 1. Configure SDK
            let config = TSBehavioralConfig(
                appId: "your-app-id",
                baseUrl: "https://your-base-url/api",
                metadataConfig: MetaDataCollectionConfig(
                    intervalMillis: 2000
                ),
                sensorConfig: SensorConfig(
                    samplingIntervalMs: 20
                ),
                keyboardConfig: KeyboardConfig(
                    trackRawText: false
                ),
                touchConfig: TouchConfig(
                    enabled: true
                )
            )

            // 2. Initialize SDK
            let initInfo = try await TSBehavioralSDK.shared.initialize(
                config: 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": "..." } }
                let userDeviceId = try await yourBackend.registerDevice(
                    deviceId: initInfo.deviceId,
                    keyPairId: initInfo.bootstrapKeyId,
                    devicePublicKey: initInfo.encryptedDevicePublicKeyPayload,
                    encryptedSecretKey: initInfo.encryptedSecretKey,
                    cusUserId: "your-user-id"
                )

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

            // 4. Start data collection
            try await TSBehavioralSDK.shared.startCollect()

            // 5. Track screen transition (required, call immediately)
            TSBehavioralSDK.shared.updateScreenTransition(
                screenName: "login_screen"
            )

            // 6. Start keyboard tracking
            TSBehavioralSDK.shared.startKeyboardTracking(
                textField: emailTextField
            )
            TSBehavioralSDK.shared.startKeyboardTracking(
                textField: passwordTextField
            )

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

    // MARK: - Screen Navigation

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

    // MARK: - Finalize

    @IBAction func submitTapped(_ sender: UIButton) {
        Task { @MainActor in
            do {
                // 8. Stop keyboard tracking
                TSBehavioralSDK.shared.stopKeyboardTracking(
                    textField: emailTextField
                )
                TSBehavioralSDK.shared.stopKeyboardTracking(
                    textField: passwordTextField
                )

                // 9. Finalize — flushes data and drains upload queue
                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() {
        // 10. Clear identity on logout
        do {
            try TSBehavioralSDK.shared.clearDeviceIdentity()
            // Must call initialize() again before next use
        } catch {
            print("Clear error: \(error)")
        }
    }
}

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

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

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

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

import Foundation
import CryptoKit

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

    // MARK: - Register Device

    func registerDevice(
        deviceId: String,
        keyId: String,
        encryptedDevicePublicKeyPayload: String,
        encryptedSecretKey: String,
        cusUserId: String
    ) async throws -> String {
        let path = "/v1/register_device"
        guard let url = URL(string: endpoint + path) else {
            throw URLError(.badURL)
        }

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

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

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

        let json = try JSONSerialization.jsonObject(with: data) as? [String: Any]
        let responseData = json?["data"] as? [String: Any]
        return responseData?["customer_user_device_id"] as? String ?? ""
    }

    // 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")
    }
}

// 1. Initialize SDK
let config = TSBehavioralConfig(
    appId: "your-app-id",
    baseUrl: "https://your-trustvision-endpoint.com/api"
)
let initInfo = try await TSBehavioralSDK.shared.initialize(config: config)

// 2. Register device via your backend
let client = DemoApiClient(
    endpoint: "https://your-trustvision-endpoint.com/api",
    apiKeyId: "your-access-key-id",
    apiSecretKey: "your-access-key-secret"
)
let customerUserDeviceId = try await client.registerDevice(
    deviceId: initInfo.deviceId,
    keyId: initInfo.bootstrapKeyId,
    encryptedDevicePublicKeyPayload: initInfo.encryptedDevicePublicKeyPayload,
    encryptedSecretKey: initInfo.encryptedSecretKey,
    cusUserId: "your-user-id"
)

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

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