Flutter v1.0.0.3

dependencies:
  flutter_tv_behavioral_plugin:
    path: ./flutter_tv_behavioral_plugin # or your local path

flutter pub get

android {
    compileSdk 36
    defaultConfig {
        minSdk 24
    }
}

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

platform :ios, '13.0'

cd ios && pod install

<key>NSBluetoothAlwaysUsageDescription</key>
<string>Used for device behavioral analysis</string>

<key>NSLocationWhenInUseUsageDescription</key>
<string>Used for device behavioral analysis</string>

import 'package:flutter_tv_behavioral_plugin/flutter_tv_behavioral_plugin.dart';
import 'package:flutter_tv_behavioral_plugin/data/ts_behavioral_config.dart';

final config = TSBehavioralConfig(
  appId: 'your-app-id',                   // Your app's package name or bundle identifier
  baseUrl: 'https://your-base-url/api',   // Provided by TrustVision
  metadataConfig: const MetaDataCollectionConfig(
    intervalMillis: 2000,
    canAskPermission: false,
    enabled: true,
  ),
  uploadBlockSize: 10,
  sensorConfig: const SensorConfig(
    samplingIntervalMs: 20,
    sensorTypes: [
      SensorType.gyroscope,
      SensorType.magnetometer,
      SensorType.accelerometer,
      SensorType.light,
    ],
    enabled: true,
  ),
  keyboardConfig: const KeyboardConfig(
    trackRawText: false,
    enabled: true,
  ),
  touchConfig: const TouchConfig(
    enabled: true,
  ),
  screenTransitionBlockSize: 1,
  appStateBlockSize: 1,
  retryConfig: RetryConfig(
    enabled: true,
    maxRetries: 2,
    retryDelayMs: 1000,
    maxDelayMs: 5000,
    maxRetryAttempts: 3,
    maxRetryStorageItems: 50,
    finalFlushTimeoutSeconds: 10.0,
    retryItemDelaySeconds: 0.5,
  ),
);

final config = TSBehavioralConfig(
  appId: 'com.example.app',
  baseUrl: 'https://api.trustingsocial.com',
  metadataConfig: const MetaDataCollectionConfig(intervalMillis: 2000),
  sslCertificates: const [
    TSCertificate(name: 'my_server_cert', type: 'der'),
  ],
);

Future<TSDeviceInitInfo> initialize(TSBehavioralConfig config)

final plugin = FlutterTvBehavioralPlugin();

try {
  final initInfo = await plugin.initialize(config);

  debugPrint('Device ID: ${initInfo.deviceId}');
  debugPrint('Already registered: ${initInfo.isRegistered}');
} on PlatformException catch (e) {
  debugPrint('Init error [${e.code}]: ${e.message}');
}

Future<bool> markDeviceRegistered({
  required bool isRegistered,
  required String customerUserDeviceId,
})

final initInfo = await plugin.initialize(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
  final userDeviceId = await yourBackend.registerDevice(
    deviceId: initInfo.deviceId,
    keyPairId: initInfo.bootstrapKeyId,
    encryptedDevicePublicKeyPayload: initInfo.encryptedDevicePublicKeyPayload,
    encryptedSecretKey: initInfo.encryptedSecretKey,
    cusUserId: 'your-user-id',
  );

  await plugin.markDeviceRegistered(
    isRegistered: true,
    customerUserDeviceId: userDeviceId,
  );
}

Future<bool> startCollect()

try {
  await plugin.startCollect();
  debugPrint('Collection started');
} on PlatformException catch (e) {
  debugPrint('Start error [${e.code}]: ${e.message}');
}

Future<void> updateScreenTransition(String screenName)

await plugin.startCollect();
await plugin.updateScreenTransition('main_screen');

// Then call again on every screen navigation
await plugin.updateScreenTransition('payment_screen');

class BehavioralNavigatorObserver extends NavigatorObserver {
  final FlutterTvBehavioralPlugin plugin;

  BehavioralNavigatorObserver(this.plugin);

  @override
  void didPush(Route route, Route? previousRoute) {
    super.didPush(route, previousRoute);
    final name = route.settings.name;
    if (name != null) {
      plugin.updateScreenTransition(name);
    }
  }
}

// In your MaterialApp:
MaterialApp(
  navigatorObservers: [
    BehavioralNavigatorObserver(plugin),
  ],
  // ...
)

import 'package:flutter_tv_behavioral_plugin/behavioral_widget/tv_behavioral_touch_tracking_widget.dart';

void main() {
  runApp(
    TvBehavioralTouchTrackingWidget(
      child: const MyApp(),
    ),
  );
}

TvBehavioralTouchTrackingWidget(
  child: Column(
    children: [
      TextField(decoration: InputDecoration(labelText: 'Username')),
      TextField(decoration: InputDecoration(labelText: 'Password')),
      ElevatedButton(onPressed: _login, child: Text('Login')),
    ],
  ),
)

class MyFlutterActivity : FlutterActivity() {
    override fun dispatchTouchEvent(ev: MotionEvent): Boolean {
        BehavioralTouchTracker.track(this, ev)
        return super.dispatchTouchEvent(ev)
    }
}

class MyFlutterFragmentActivity : FlutterFragmentActivity() {
    override fun dispatchTouchEvent(ev: MotionEvent): Boolean {
        BehavioralTouchTracker.track(this, ev)
        return super.dispatchTouchEvent(ev)
    }
}

void attachController({
  required TextEditingController controller,
  required String viewId,
})

void detachController(TextEditingController controller)

void detachAll()

final keyboardTracker = FlutterKeyboardTracker();
final emailController = TextEditingController();
final passwordController = TextEditingController();

@override
void initState() {
  super.initState();
  keyboardTracker.attachController(
    controller: emailController,
    viewId: 'email_field',
  );
  keyboardTracker.attachController(
    controller: passwordController,
    viewId: 'password_field',
  );
}

@override
void dispose() {
  keyboardTracker.detachAll();
  emailController.dispose();
  passwordController.dispose();
  super.dispose();
}

Future<bool> addKeyboardTrackingData({
  String? data,
  String? type,
  String? viewId,
  int? textLength,
})

await plugin.addKeyboardTrackingData(
  data: null,
  type: 'lowerText',
  viewId: 'email_field',
  textLength: 5,
);

Future<void> trackTouchEvent(Map<String, dynamic> eventData)

await plugin.trackTouchEvent({
  'actionName': 'action_down',
  'pointerId': 0,
  'globalX': 150.0,
  'globalY': 300.0,
  'actionMasked': 0,
});

Future<TSFinalizeResult> finalizeCollect()

try {
  final result = await plugin.finalizeCollect();

  debugPrint('Challenge ID: ${result.challengeId}');
  debugPrint('Last seq: ${result.lastSeq}');

  if (result.droppedBatchCount > 0) {
    debugPrint(
      'Dropped ${result.droppedBatchCount} batches. Last error: ${result.lastUploadError}',
    );
  }

  // Send challengeId to your backend for scoring
  await yourBackend.computeBehaviorScore(
    challengeId: result.challengeId!,
  );
} on PlatformException catch (e) {
  debugPrint('Finalize error [${e.code}]: ${e.message}');
}

Future<TSFinalizeResult> stopCollect()

try {
  final result = await plugin.stopCollect();
  debugPrint('Stopped. Last seq: ${result.lastSeq}');
} on PlatformException catch (e) {
  debugPrint('Stop error [${e.code}]: ${e.message}');
}

Future<bool> clearDeviceIdentity()

try {
  await plugin.clearDeviceIdentity();
  debugPrint('Device identity cleared');
  // Must call initialize() again before using SDK
} on PlatformException catch (e) {
  debugPrint('Clear error [${e.code}]: ${e.message}');
}

try {
  await plugin.startCollect();
} on PlatformException catch (e) {
  switch (e.code) {
    case 'deviceNotRegistered':
      debugPrint('Register device first via your backend');
      break;
    case 'notInitialized':
      debugPrint('Call initialize() before startCollect()');
      break;
    case 'sslPinningError':
      debugPrint('SSL pinning failed: ${e.message}');
      break;
    case 'networkError':
      // For a network error, e.details is a Map with server context
      final details = e.details as Map?;
      final httpCode = details?['httpCode'] as int?;
      final serverCode = details?['serverCode'] as String?;
      debugPrint('Network issue: HTTP $httpCode / $serverCode — ${e.message}');
      break;
    case 'challengeExpired':
      debugPrint('Challenge expired, retry startCollect()');
      break;
    default:
      debugPrint('SDK error [${e.code}]: ${e.message}');
  }
}

import 'dart:io';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:flutter_tv_behavioral_plugin/flutter_tv_behavioral_plugin.dart';
import 'package:flutter_tv_behavioral_plugin/data/ts_behavioral_config.dart';
import 'package:flutter_tv_behavioral_plugin/behavioral_widget/tv_behavioral_touch_tracking_widget.dart';
import 'package:flutter_tv_behavioral_plugin/behavioral_widget/tv_behavioral_keyboard_tracking.dart';

// 1. Wrap your app (or any widget) with touch tracking widget
void main() {
  runApp(
    TvBehavioralTouchTrackingWidget(
      child: const MyApp(),
    ),
  );
}

class MyApp extends StatefulWidget {
  const MyApp({super.key});

  @override
  State<MyApp> createState() => _MyAppState();
}

class _MyAppState extends State<MyApp> {
  final _plugin = FlutterTvBehavioralPlugin();
  final _keyboardTracker = FlutterKeyboardTracker();
  final _emailController = TextEditingController();
  final _passwordController = TextEditingController();
  final _phoneController = TextEditingController();

  String _status = 'Not initialized';

  @override
  void initState() {
    super.initState();

    // 2. Attach keyboard tracking to all text fields
    _keyboardTracker.attachController(
      controller: _emailController,
      viewId: 'email_field',
    );
    _keyboardTracker.attachController(
      controller: _passwordController,
      viewId: 'password_field',
    );
    _keyboardTracker.attachController(
      controller: _phoneController,
      viewId: 'phone_field',
    );

    _initBehavioralSDK();
  }

  Future<void> _initBehavioralSDK() async {
    try {
      // 3. Configure SDK
      final config = TSBehavioralConfig(
        appId: 'your-app-id',
        baseUrl: 'https://your-base-url/api',
        metadataConfig: const MetaDataCollectionConfig(
          intervalMillis: 2000,
        ),
        sensorConfig: const SensorConfig(
          samplingIntervalMs: 20,
          sensorTypes: [
            SensorType.gyroscope,
            SensorType.magnetometer,
            SensorType.accelerometer,
            SensorType.light,
          ],
        ),
        keyboardConfig: const KeyboardConfig(
          trackRawText: false,
        ),
        touchConfig: const TouchConfig(
          enabled: true,
        ),
      );

      // 4. Initialize SDK
      final initInfo = await _plugin.initialize(config);
      setState(() => _status = 'Initialized');

      // 5. 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": "..." } }
        final userDeviceId = await yourBackend.registerDevice(
          deviceId: initInfo.deviceId,
          keyPairId: initInfo.bootstrapKeyId,
          encryptedDevicePublicKeyPayload: initInfo.encryptedDevicePublicKeyPayload,
          encryptedSecretKey: initInfo.encryptedSecretKey,
          cusUserId: 'your-user-id',
        );

        await _plugin.markDeviceRegistered(
          isRegistered: true,
          customerUserDeviceId: userDeviceId,
        );
      }
      setState(() => _status = 'Registered');

      // 6. Start data collection
      await _plugin.startCollect();
      setState(() => _status = 'Collecting...');

      // 7. Track initial screen (required, call immediately after startCollect)
      await _plugin.updateScreenTransition('login_screen');

    } on PlatformException catch (e) {
      setState(() => _status = 'Error: ${e.code}');
      debugPrint('SDK error [${e.code}]: ${e.message}');
    }
  }

  // 8. Track screen transitions on navigation
  void _navigateToPayment() {
    _plugin.updateScreenTransition('payment_screen');
    // ... navigate to payment screen
  }

  // 9. Finalize when the flow is complete
  Future<void> _onSubmit() async {
    try {
      final result = await _plugin.finalizeCollect();
      setState(() => _status = 'Finalized');

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

    } on PlatformException catch (e) {
      debugPrint('Finalize error [${e.code}]: ${e.message}');
    }
  }

  // 10. Clear identity on logout
  Future<void> _onLogout() async {
    await _plugin.clearDeviceIdentity();
    setState(() => _status = 'Cleared');
    // Must call initialize() again before next use
  }

  @override
  void dispose() {
    _keyboardTracker.detachAll();
    _emailController.dispose();
    _passwordController.dispose();
    _phoneController.dispose();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(title: Text('Behavioral SDK — $_status')),
        body: Padding(
          padding: const EdgeInsets.all(16),
          child: Column(
            children: [
              TextField(
                controller: _emailController,
                decoration: const InputDecoration(labelText: 'Email'),
              ),
              const SizedBox(height: 12),
              TextField(
                controller: _passwordController,
                obscureText: true,
                decoration: const InputDecoration(labelText: 'Password'),
              ),
              const SizedBox(height: 12),
              TextField(
                controller: _phoneController,
                keyboardType: TextInputType.phone,
                decoration: const InputDecoration(labelText: 'Phone'),
              ),
              const SizedBox(height: 24),
              ElevatedButton(
                onPressed: _onSubmit,
                child: const Text('Submit'),
              ),
              const SizedBox(height: 12),
              TextButton(
                onPressed: _onLogout,
                child: const Text('Logout'),
              ),
            ],
          ),
        ),
      ),
    );
  }
}

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 'dart:convert';
import 'package:crypto/crypto.dart';
import 'package:dio/dio.dart';

class TVApiClient {
  final Dio _dio;

  TVApiClient({
    required String baseUrl,
    required String accessKeyId,
    required String accessKeySecret,
  }) : _dio = Dio(BaseOptions(baseUrl: baseUrl))
    ..interceptors.add(_AuthInterceptor(
      accessKeyId: accessKeyId,
      accessKeySecret: accessKeySecret,
    ));

  Future<String> registerDevice({
    required String keyPairId,
    required String encryptedDevicePublicKeyPayload,
    required String encryptedSecretKey,
    required String cusUserId,
    required String deviceId,
  }) async {
    final response = await _dio.post('/v1/register_device', data: {
      'key_pair_id': keyPairId,
      'device_public_key': encryptedDevicePublicKeyPayload,
      'encrypted_secret_key': encryptedSecretKey,
      'cus_user_id': cusUserId,
      'device_id': deviceId,
      'protocol': 'encrypted',
    });

    final responseData = response.data;
    if (responseData is! Map<String, dynamic>) {
      throw Exception('Unexpected response format: $responseData');
    }
    final data = responseData['data'] as Map<String, dynamic>?;
    return data?['customer_user_device_id'] ?? '';
  }
}

// --- HMAC-SHA256 Auth Interceptor ---

class _AuthInterceptor extends Interceptor {
  final String accessKeyId;
  final String accessKeySecret;

  _AuthInterceptor({
    required this.accessKeyId,
    required this.accessKeySecret,
  });

  @override
  void onRequest(RequestOptions options, RequestInterceptorHandler handler) {
    final method = options.method;
    final path = options.path;
    final timestamp = DateTime.now().toUtc().toIso8601String();

    final stringToSign = '$method\n$path\n$timestamp';
    final hmacSha256 = Hmac(sha256, utf8.encode(accessKeySecret));
    final digest = hmacSha256.convert(utf8.encode(stringToSign));
    final signature = base64.encode(digest.bytes);

    options.headers['Authorization'] = 'TV $accessKeyId:$signature';
    options.headers['X-TV-Timestamp'] = timestamp;

    super.onRequest(options, handler);
  }
}

// 1. Initialize SDK
final initInfo = await plugin.initialize(config);

// 2. Register device via your backend
final client = TVApiClient(
  baseUrl: 'https://your-trustvision-endpoint.com/api',
  accessKeyId: 'your-access-key-id',
  accessKeySecret: 'your-access-key-secret',
);
final customerUserDeviceId = await client.registerDevice(
  keyPairId: initInfo.bootstrapKeyId,
  encryptedDevicePublicKeyPayload: initInfo.encryptedDevicePublicKeyPayload,
  encryptedSecretKey: initInfo.encryptedSecretKey,
  cusUserId: 'your-user-id',
  deviceId: initInfo.deviceId,
);

// 3. Mark device as registered in SDK
await plugin.markDeviceRegistered(
  isRegistered: true,
  customerUserDeviceId: customerUserDeviceId,
);

// 4. Now you can start collecting
await plugin.startCollect();