API Documentation

dependencies {
    implementation("com.codelyticalhub:face-capture:1.0.0")
}

repositories {
    mavenCentral()
}

// onCreate — must be called before activity resumes
FaceCaptureSDK.register(this)

// Launch capture
FaceCaptureSDK.start(activity) { result ->
    when (result) {
        is FaceCaptureResult.Success -> {
            val file   = ImageUtils.bitmapToFile(context, result.bitmap)
            val base64 = ImageUtils.bitmapToBase64(result.bitmap)
        }
        FaceCaptureResult.Cancelled -> { /* dismissed */ }
        is FaceCaptureResult.Error  -> showError(result.message)
    }
}

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        FaceCaptureSDK.register(this)
        setContent {
            MaterialTheme {
                Surface(modifier = Modifier.fillMaxSize()) {
                    DemoScreen(activity = this@MainActivity)
                }
            }
        }
    }
}

@Composable
private fun DemoScreen(activity: ComponentActivity) {
    var resultText by remember { mutableStateOf<String?>(null) }
    var faceBitmap by remember { mutableStateOf<Bitmap?>(null) }

    Column(
        modifier = Modifier.fillMaxSize().padding(24.dp),
        horizontalAlignment = Alignment.CenterHorizontally,
        verticalArrangement = Arrangement.Center
    ) {
        Text("CodeLytical Face Capture Demo", fontSize = 22.sp, fontWeight = FontWeight.Bold)
        Spacer(Modifier.height(28.dp))
        Button(onClick = {
            FaceCaptureSDK.start(activity, FaceCaptureConfig(minFaceSize = 0.15f, requireFaceOnCapture = true)) { result ->
                when (result) {
                    is FaceCaptureResult.Success -> { resultText = "✅ Face captured"; faceBitmap = result.bitmap }
                    FaceCaptureResult.Cancelled  -> resultText = "Cancelled"
                    is FaceCaptureResult.Error   -> resultText = "Error: ${result.message}"
                }
            }
        }) { Text("Start Face Capture") }
        resultText?.let { Text(it, fontSize = 16.sp) }
        faceBitmap?.let { Image(bitmap = it.asImageBitmap(), contentDescription = null, modifier = Modifier.size(220.dp).clip(RoundedCornerShape(16.dp))) }
    }
}

dependencies {
    implementation("com.codelyticalhub:liveness:1.0.0")
}

repositories {
    mavenCentral()
}

// onCreate
LivenessSdk.register(this)

// Validate key once
LivenessSdk.init(activity, "fg_live_your_key") { ok, error ->
    if (ok) { /* enable button */ } else showError(error)
}

// Launch scan
LivenessSdk.start(activity) { result ->
    when (result) {
        is LivenessResult.Real   -> {
            val bitmap = LivenessSdk.uriToBitmap(context, result.imageUri)
            val base64 = LivenessSdk.uriToBase64(context, result.imageUri)
        }
        LivenessResult.Spoof     -> showMessage("Spoof")
        LivenessResult.Cancelled -> { }
        is LivenessResult.Error  -> showError(result.message)
    }
}

sealed class LivenessResult {
    data class Real(val imageUri: Uri, val confidence: Float) : LivenessResult()
    data object Spoof     : LivenessResult()
    data object Cancelled : LivenessResult()
    data class Error(val message: String) : LivenessResult()
}

class MainActivity : ComponentActivity() {
    private val apiKey = "fg_live_your_key_here"
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        LivenessSdk.register(this)
        setContent { MaterialTheme { Surface(Modifier.fillMaxSize()) { DemoScreen(this@MainActivity, apiKey) } } }
    }
}

@Composable
fun DemoScreen(activity: ComponentActivity, apiKey: String) {
    var status by remember { mutableStateOf("Validating…") }
    var ready  by remember { mutableStateOf(false) }
    var result by remember { mutableStateOf<String?>(null) }
    var bitmap by remember { mutableStateOf<android.graphics.Bitmap?>(null) }
    LaunchedEffect(Unit) { LivenessSdk.init(activity, apiKey) { ok, err -> ready = ok; status = if (ok) "SDK ready" else (err ?: "Invalid key") } }
    Column(Modifier.fillMaxSize().padding(24.dp), Alignment.CenterHorizontally, Arrangement.Center) {
        Text("Liveness Demo", fontSize = 22.sp, fontWeight = FontWeight.Bold)
        Spacer(Modifier.height(8.dp)); Text(status)
        Spacer(Modifier.height(28.dp))
        Button(enabled = ready, onClick = {
            result = null; bitmap = null
            LivenessSdk.start(activity) { r ->
                when (r) {
                    is LivenessResult.Real -> { result = "✅ Genuine (${String.format("%.3f", r.confidence)})"; bitmap = LivenessSdk.uriToBitmap(activity, r.imageUri) }
                    LivenessResult.Spoof     -> result = "⚠️ Spoof detected"
                    LivenessResult.Cancelled -> result = "Cancelled"
                    is LivenessResult.Error  -> result = "Error: ${r.message}"
                }
            }
        }) { Text("Start Liveness Check") }
        result?.let { Spacer(Modifier.height(20.dp)); Text(it, fontSize = 16.sp) }
        bitmap?.let { Spacer(Modifier.height(16.dp)); Image(it.asImageBitmap(), null, Modifier.size(220.dp).clip(RoundedCornerShape(16.dp))) }
    }
}

dependencies {
    implementation("com.codelyticalhub:ghana-card-sdk:1.0.1")
}

repositories {
    mavenCentral()
}

private var pendingAction: (() -> Unit)? = null

private val cameraPermissionLauncher = registerForActivityResult(
    ActivityResultContracts.RequestPermission()
) { granted ->
    if (granted) { pendingAction?.invoke(); pendingAction = null }
    else Toast.makeText(this, "Camera permission required", Toast.LENGTH_LONG).show()
}

private fun withCamera(action: () -> Unit) {
    if (ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA)
            == PackageManager.PERMISSION_GRANTED) action()
    else { pendingAction = action; cameraPermissionLauncher.launch(Manifest.permission.CAMERA) }
}

// onCreate
GhanaCardSDK.register(this)

// Launch (always wrap with withCamera)
private fun launchScan() {
    GhanaCardSDK.init(this, "YOUR_API_KEY") { success, error ->
        if (success) {
            GhanaCardSDK.scan(this) { result ->
                when (result) {
                    is GhanaCardResult.Success -> {
                        val data = result.data
                        println(data.fullName)
                        println(data.personalIdNumber)
                        val photoBase64 = data.passportPhotoBase64
                    }
                    is GhanaCardResult.Error -> showError(result.error.message)
                }
            }
        }
    }
}

// From button: withCamera { launchScan() }

data class GhanaCardData(
    val fullName:            String,
    val personalIdNumber:    String,  // e.g. "GHA-123456789-0"
    val documentNumber:      String,
    val dateOfBirth:         String,
    val expiryDate:          String,
    val sex:                 String,  // "M" or "F"
    val nationality:         String,
    val passportPhotoBase64: String,  // Base64 JPEG
    val processingTimeMs:    Long,
    val confidence:          Float
)

class MainActivity : ComponentActivity() {
    private val TEST_API_KEY = "YOUR_API_KEY"
    private var pendingAction: (() -> Unit)? = null
    private val cameraPermissionLauncher = registerForActivityResult(
        ActivityResultContracts.RequestPermission()
    ) { granted ->
        if (granted) { pendingAction?.invoke(); pendingAction = null }
        else Toast.makeText(this, "Camera permission required", Toast.LENGTH_LONG).show()
    }
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        GhanaCardSDK.register(this)
        val composeView = ComposeView(this).apply {
            setContent { MaterialTheme { SampleScreen(onScanClick = { withCamera { launchScan() } }) } }
        }
        setContentView(composeView)
    }
    private fun withCamera(action: () -> Unit) {
        if (ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED) action()
        else { pendingAction = action; cameraPermissionLauncher.launch(Manifest.permission.CAMERA) }
    }
    private fun launchScan() {
        GhanaCardSDK.init(this, TEST_API_KEY) { success, error ->
            if (success) GhanaCardSDK.scan(this) { result -> resultState.value = result }
            else resultState.value = GhanaCardResult.Error(GhanaCardError(GhanaCardErrorCode.INVALID_API_KEY, error ?: "Init failed"))
        }
    }
    private var resultState = mutableStateOf<GhanaCardResult?>(null)
    @Composable private fun SampleScreen(onScanClick: () -> Unit) {
        val r by resultState
        Column(Modifier.fillMaxSize().padding(24.dp).verticalScroll(rememberScrollState()), Alignment.CenterHorizontally, Arrangement.spacedBy(16.dp)) {
            Spacer(Modifier.height(48.dp))
            Text("GhanaCard SDK Test", fontSize = 22.sp, fontWeight = FontWeight.Bold)
            Button(onClick = onScanClick, modifier = Modifier.fillMaxWidth().height(52.dp)) { Text("Scan Ghana Card", fontSize = 15.sp) }
            when (val res = r) {
                null -> Text("No result yet.", color = Color.Gray)
                is GhanaCardResult.Success -> Text("✓ ${res.data.fullName} · ${res.data.personalIdNumber}")
                is GhanaCardResult.Error   -> Text("✕ ${res.error.code}: ${res.error.message}", color = Color.Red)
            }
        }
    }
}

-keep class com.codelyticalhub.ghanacardsdk.model.** { *; }
-keep class com.codelyticalhub.ghanacardsdk.GhanaCardSDK { *; }