BetaFlox Documentation

package com.temtem.app

import android.app.Application
import android.util.Log
import kotlinx.coroutines.CompletableDeferred

class InitApp : Application() {
    companion object {
        val sdkReady = CompletableDeferred<Unit>()
    }

    override fun onCreate() {
        super.onCreate()
        Log.i("InitApp", "Application startup clean (SDK initialization deferred to post-Flutter UI display).")
    }
}

package com.temtem.app

import android.content.ClipboardManager
import android.content.Context
import android.content.Intent
import android.net.Uri
import android.os.Bundle
import android.util.Log
import com.betaflox.sdk.BetaFloxSDK
import io.flutter.embedding.android.FlutterActivity
import io.flutter.embedding.engine.FlutterEngine
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch

class MainActivity : FlutterActivity() {

    private var betaFloxHost: BetaFloxChannelHost? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        injectTesterIdIntoIntent(intent)
        super.onCreate(savedInstanceState)
    }

    override fun onFlutterUiDisplayed() {
        super.onFlutterUiDisplayed()
        Log.i("BFX", "onFlutterUiDisplayed: Flutter UI rendered!")

        CoroutineScope(Dispatchers.IO).launch {
            try {
                val validTesterId = resolveValidTesterId(intent)

                if (validTesterId != null) {
                    val prefs = getSharedPreferences("betaflox_prefs", Context.MODE_PRIVATE)
                    prefs.edit().putString("tester_id", validTesterId).apply()

                    if (!InitApp.sdkReady.isCompleted) {
                        BetaFloxSDK.initialize(
                            context    = applicationContext,
                            apiKey     = "YOUR_API_KEY",
                            campaignId = "YOUR_CAMPAIGN_ID"
                        )
                        InitApp.sdkReady.complete(Unit)
                    }

                    BetaFloxSDK.setTesterId(validTesterId)
                    intent.putExtra("betaflox_tester_id", validTesterId)

                    // Manually notify lifecycleTracker so heartbeatManager starts logging sdk_events
                    try {
                        val field = BetaFloxSDK::class.java.getDeclaredField("lifecycleTracker")
                        field.isAccessible = true
                        val tracker = field.get(BetaFloxSDK) as? android.app.Application.ActivityLifecycleCallbacks
                        tracker?.onActivityStarted(this@MainActivity)
                        tracker?.onActivityResumed(this@MainActivity)
                    } catch (_: Exception) {}

                    BetaFloxSDK.handleLaunchIntent(intent)
                    BetaFloxSDK.handleDeepLink(intent)
                } else {
                    Log.i("BFX", "Direct launch before BetaFlox binding -> SDK remains dormant.")
                }
            } catch (e: Exception) {
                Log.e("BFX", "onFlutterUiDisplayed error: ${e.message}", e)
            }
        }

        tryBindFromClipboard()
    }

    override fun onResume() {
        super.onResume()
        // Re-activate SDK lifecycle tracker each time the user returns to the app.
        // Without this, switching to the BetaFlox companion app fires onActivityStopped
        // on the SDK tracker, permanently stopping heartbeats. Calling reactivateSdkLifecycleTracker()
        // here ensures sdk_events resume immediately every time the user comes back.
        reactivateSdkLifecycleTracker()
        tryBindFromClipboard()
    }

    override fun onStop() {
        super.onStop()
        Log.i("BFX", "onStop: User switched away (e.g., to BetaFlox). Heartbeats will resume on return.")
    }

    /**
     * Re-activates the SDK's internal AppLifecycleTracker.
     *
     * Problem (Issue #5): When the user switches from the tested app to the BetaFlox companion
     * app (or any other app), Android fires onActivityStopped on the SDK's registered
     * ActivityLifecycleCallbacks, which calls heartbeatManager.stop() + sessionManager.endSession().
     * When the user returns, Android only fires onActivityResumed — but heartbeatManager.start()
     * is only triggered from onActivityStarted, which is never re-fired for a resume-from-background.
     *
     * Solution: Manually invoke onActivityStarted + onActivityResumed on the tracker on every
     * onResume() so heartbeats restart immediately whenever the user returns to the app.
     */
    private fun reactivateSdkLifecycleTracker() {
        if (!InitApp.sdkReady.isCompleted) return
        val boundId = resolveValidTesterId(intent)
        if (boundId.isNullOrBlank()) return
        CoroutineScope(Dispatchers.IO).launch {
            try {
                val field = BetaFloxSDK::class.java.getDeclaredField("lifecycleTracker")
                field.isAccessible = true
                val tracker = field.get(BetaFloxSDK) as? android.app.Application.ActivityLifecycleCallbacks
                tracker?.onActivityStarted(this@MainActivity)
                tracker?.onActivityResumed(this@MainActivity)
                Log.i("BFX", "reactivateSdkLifecycleTracker: heartbeats resumed for testerId=${BetaFloxSDK.getTesterId()}")
            } catch (e: Exception) {
                Log.w("BFX", "reactivateSdkLifecycleTracker: ${e.message}")
            }
        }
    }

    override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
        super.configureFlutterEngine(flutterEngine)
        betaFloxHost = BetaFloxChannelHost(flutterEngine, applicationContext).apply { register() }
    }

    private fun resolveValidTesterId(intent: Intent?): String? {
        if (intent != null && intent.hasExtra("betaflox_tester_id")) {
            val extraId = intent.getStringExtra("betaflox_tester_id")
            if (!extraId.isNullOrBlank() && extraId != "pending_binding") return extraId
        }
        val prefs = getSharedPreferences("betaflox_prefs", Context.MODE_PRIVATE)
        val storedId = prefs.getString("tester_id", null)
        if (!storedId.isNullOrBlank() && storedId != "pending_binding") return storedId
        return null
    }

    private fun injectTesterIdIntoIntent(intent: Intent?) {
        if (intent == null) return
        val validId = resolveValidTesterId(intent)
        if (!validId.isNullOrBlank()) intent.putExtra("betaflox_tester_id", validId)
    }

    private fun tryBindFromClipboard() {
        CoroutineScope(Dispatchers.IO).launch {
            try {
                InitApp.sdkReady.await()
                if (!BetaFloxSDK.getTesterId().isNullOrBlank()) return@launch
                val clipboard = getSystemService(Context.CLIPBOARD_SERVICE) as? ClipboardManager ?: return@launch
                val text = clipboard.primaryClip?.getItemAt(0)?.coerceToText(this@MainActivity)?.toString()?.trim() ?: return@launch
                if (!text.contains("token=")) return@launch
                BetaFloxSDK.handleDeepLink(Intent(Intent.ACTION_VIEW, Uri.parse(text)))
            } catch (_: Exception) {}
        }
    }
}

package com.temtem.app

import android.util.Log
import com.betaflox.sdk.BetaFloxSDK
import com.betaflox.sdk.VerificationState
import io.flutter.embedding.engine.FlutterEngine
import io.flutter.plugin.common.EventChannel
import io.flutter.plugin.common.MethodCall
import io.flutter.plugin.common.MethodChannel
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.collectLatest
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext

class BetaFloxChannelHost(
    private val flutterEngine: FlutterEngine,
    private val context: android.content.Context
) {
    companion object {
        const val CHANNEL = "com.yourcompany.yourapp/betaflox"
        const val EVENT_CHANNEL = "com.yourcompany.yourapp/betaflox_verification"
    }

    private var verificationSink: EventChannel.EventSink? = null

    fun register() {
        MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CHANNEL)
            .setMethodCallHandler { call, result -> handle(call, result) }

        EventChannel(flutterEngine.dartExecutor.binaryMessenger, EVENT_CHANNEL)
            .setStreamHandler(object : EventChannel.StreamHandler {
                override fun onListen(arguments: Any?, events: EventChannel.EventSink?) {
                    verificationSink = events
                    collectVerificationState()
                }
                override fun onCancel(arguments: Any?) { verificationSink = null }
            })
    }

    private fun collectVerificationState() {
        CoroutineScope(Dispatchers.Main).launch {
            try {
                BetaFloxSDK.verificationState.collectLatest { state ->
                    val map = when (state) {
                        is VerificationState.Pending  -> mapOf("state" to "pending")
                        is VerificationState.Complete -> mapOf("state" to "complete", "verdict" to state.verdict.verdict, "riskScore" to state.verdict.riskScore)
                        is VerificationState.Failed   -> mapOf("state" to "failed", "reason" to state.reason)
                    }
                    verificationSink?.success(map)
                }
            } catch (_: Exception) {}
        }
    }

    private fun handle(call: MethodCall, result: MethodChannel.Result) {
        when (call.method) {
            "initialize" -> {
                val apiKey     = call.argument<String>("apiKey")     ?: "YOUR_API_KEY"
                val campaignId = call.argument<String>("campaignId") ?: "YOUR_CAMPAIGN_ID"
                CoroutineScope(Dispatchers.IO).launch {
                    try {
                        BetaFloxSDK.initialize(context.applicationContext, apiKey, campaignId)
                        InitApp.sdkReady.complete(Unit)
                        withContext(Dispatchers.Main) { result.success(null) }
                    } catch (e: Exception) {
                        withContext(Dispatchers.Main) { result.error("INIT_FAILED", e.message, null) }
                    }
                }
            }

            "setTesterId" -> {
                val id = call.argument<String>("testerId") ?: return result.error("ARGS", "testerId required", null)
                if (id.isNotBlank() && id != "pending_binding") {
                    CoroutineScope(Dispatchers.IO).launch {
                        try {
                            if (!InitApp.sdkReady.isCompleted) {
                                BetaFloxSDK.initialize(context.applicationContext, "YOUR_API_KEY", "YOUR_CAMPAIGN_ID")
                                InitApp.sdkReady.complete(Unit)
                            }
                            BetaFloxSDK.setTesterId(id)
                            context.getSharedPreferences("betaflox_prefs", android.content.Context.MODE_PRIVATE).edit().putString("tester_id", id).apply()
                            BetaFloxSDK.syncNow()
                            withContext(Dispatchers.Main) { result.success(null) }
                        } catch (e: Exception) {
                            withContext(Dispatchers.Main) { result.error("SET_TESTER_FAILED", e.message, null) }
                        }
                    }
                } else {
                    result.success(null)
                }
            }

            "getTesterId" -> result.success(BetaFloxSDK.getTesterId())
            "syncNow" -> {
                CoroutineScope(Dispatchers.IO).launch {
                    try {
                        BetaFloxSDK.syncNow()
                        withContext(Dispatchers.Main) { result.success(null) }
                    } catch (e: Exception) {
                        withContext(Dispatchers.Main) { result.error("SYNC_FAILED", e.message, null) }
                    }
                }
            }
            else -> result.notImplemented()
        }
    }
}

import 'dart:async';
import 'package:flutter/foundation.dart';
import 'package:flutter/services.dart';

sealed class VerificationState {
  const VerificationState();
}

class VerificationPending extends VerificationState {
  const VerificationPending();
}

class VerificationComplete extends VerificationState {
  final String verdict;
  final double riskScore;
  const VerificationComplete({required this.verdict, required this.riskScore});
}

class VerificationFailed extends VerificationState {
  final String reason;
  const VerificationFailed({required this.reason});
}

class BetaFloxService {
  static const MethodChannel _channel = MethodChannel('com.yourcompany.yourapp/betaflox');
  static const EventChannel _eventChannel = EventChannel('com.yourcompany.yourapp/betaflox_verification');

  static final BetaFloxService instance = BetaFloxService._();
  BetaFloxService._();

  Stream<VerificationState>? _verificationStream;

  Future<void> setTesterId(String testerId) async {
    try {
      await _channel.invokeMethod('setTesterId', {'testerId': testerId});
    } on PlatformException catch (e) {
      debugPrint('BetaFlox setTesterId error: ${e.message}');
    }
  }

  Future<String?> getTesterId() async {
    try {
      return await _channel.invokeMethod<String>('getTesterId');
    } on PlatformException catch (e) {
      return null;
    }
  }

  Future<void> syncNow() async {
    try {
      await _channel.invokeMethod('syncNow');
    } on PlatformException catch (_) {}
  }

  Stream<VerificationState> get verificationStateStream {
    _verificationStream ??= _eventChannel.receiveBroadcastStream().map((dynamic event) {
      final map = Map<String, dynamic>.from(event as Map);
      final stateStr = map['state'] as String?;
      return switch (stateStr) {
        'complete' => VerificationComplete(
            verdict: (map['verdict'] as String?) ?? 'VALID',
            riskScore: ((map['riskScore'] as num?) ?? 0.0).toDouble(),
          ),
        'failed' => VerificationFailed(
            reason: (map['reason'] as String?) ?? 'Unknown error',
          ),
        _ => const VerificationPending(),
      };
    });
    return _verificationStream!;
  }
}