@vppos/react-native-nfc 1.0.0

package/android/src/main/java/com/nfcsdk/NFCScanActivity.kt

@@ -0,0 +1,299 @@
+package com.nfcsdk
+
+import android.app.PendingIntent
+import android.content.Intent
+import android.content.IntentFilter
+import android.graphics.Color
+import android.graphics.drawable.ColorDrawable
+import android.nfc.NfcAdapter
+import android.nfc.Tag
+import android.nfc.tech.IsoDep
+import android.os.Build
+import android.os.Bundle
+import android.os.VibrationEffect
+import android.os.Vibrator
+import android.provider.Settings
+import android.util.Log
+import android.view.Gravity
+import android.view.View
+import android.widget.Button
+import android.widget.ProgressBar
+import android.widget.TextView
+import android.widget.Toast
+import androidx.appcompat.app.AppCompatActivity
+import com.facebook.react.bridge.Arguments
+import java.security.Security
+
+class NFCScanActivity : AppCompatActivity() {
+
+  private var nfcAdapter: NfcAdapter? = null
+
+  private lateinit var progressBar: ProgressBar
+  private lateinit var progressPercentTextView: TextView
+  private lateinit var retryButton: Button
+
+  @Volatile
+  private var isReading = false
+
+  @Volatile
+  private var scanCompleted = false
+
+  // ── Lifecycle ──────────────────────────────────────────────
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+
+    setContentView(R.layout.activity_nfc)
+    setupWindow()
+    setupTransition()
+    setupSheetAnimation()
+    setupViews()
+
+    Security.insertProviderAt(
+      org.spongycastle.jce.provider.BouncyCastleProvider(),
+      1,
+    )
+
+    nfcAdapter = NfcAdapter.getDefaultAdapter(this)
+    if (nfcAdapter == null) {
+      Toast.makeText(this, "Thiết bị không hỗ trợ NFC", Toast.LENGTH_LONG).show()
+      finish()
+      return
+    }
+
+    if (nfcAdapter?.isEnabled != true) {
+      Toast.makeText(this, "Vui lòng bật NFC", Toast.LENGTH_LONG).show()
+      startActivity(Intent(Settings.ACTION_NFC_SETTINGS))
+    }
+
+    updateProgress(0, "Đưa CCCD sát mặt lưng điện thoại")
+  }
+
+  override fun onResume() {
+    super.onResume()
+
+    val intent = Intent(this, javaClass)
+      .addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP)
+
+    val pendingIntent =
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+        PendingIntent.getActivity(this, 0, intent, PendingIntent.FLAG_MUTABLE)
+      } else {
+        PendingIntent.getActivity(this, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT)
+      }
+
+    val filters = arrayOf(IntentFilter(NfcAdapter.ACTION_TECH_DISCOVERED))
+    val techList = arrayOf(arrayOf(IsoDep::class.java.name))
+
+    nfcAdapter?.enableForegroundDispatch(this, pendingIntent, filters, techList)
+  }
+
+  override fun onPause() {
+    super.onPause()
+    nfcAdapter?.disableForegroundDispatch(this)
+  }
+
+  override fun onDestroy() {
+    super.onDestroy()
+    isReading = false
+    scanCompleted = false
+  }
+
+  override fun onNewIntent(intent: Intent) {
+    super.onNewIntent(intent)
+
+    if (isReading || scanCompleted) return
+
+    @Suppress("DEPRECATION")
+    val tag = intent.getParcelableExtra<Tag>(NfcAdapter.EXTRA_TAG) ?: return
+
+    startChipRead(tag)
+  }
+
+  // ── Chip Reading ───────────────────────────────────────────
+
+  private fun startChipRead(tag: Tag) {
+    isReading = true
+
+    Thread {
+      try {
+        val citizenId = NFCSDKModule.documentNumber.trim()
+        if (citizenId.length < 6) {
+          updateProgress(-1, "CCCD không hợp lệ")
+          Log.e("NFCSDK", "startChipRead: invalid citizenId")
+          isReading = false
+          return@Thread
+        }
+
+        val result = ChipReader.read(tag, citizenId) { progress, message ->
+          updateProgress(progress, message)
+        }
+
+        vibrate(200)
+        scanCompleted = true
+        sendResult(result)
+
+        runOnUiThread {
+          window.decorView.postDelayed({ finish() }, 800)
+        }
+      } catch (e: ChipReadException) {
+        Log.e("NFCSDK", "Chip read failed: ${e.message}")
+        updateProgress(-1, e.message ?: "Đọc NFC thất bại")
+        isReading = false
+      } catch (e: Exception) {
+        Log.e("NFCSDK", "NFC read failed", e)
+        updateProgress(-1, "Đọc NFC thất bại")
+        isReading = false
+      }
+    }.start()
+  }
+
+  private fun sendResult(result: ChipReadResult) {
+    val resultMap = Arguments.createMap().apply {
+      putString("citizenId", result.citizenId)
+      putString("fullName", result.fullName)
+      putString("dob", result.dob)
+      putString("gender", result.gender)
+      putString("nationality", result.nationality)
+      putString("permanentAddress", result.permanentAddress)
+      putString("issueDate", result.issueDate)
+      putString("issuePlace", result.issuePlace)
+      putString("expireDate", result.expireDate)
+      putString("imageFromChip", result.imageFromChipBase64)
+      putString("frontCardBase64", "")
+      putString("backCardBase64", "")
+      putString("dg1DataB64", result.dg1DataB64)
+      putString("dg2DataB64", result.dg2DataB64)
+      putString("dg13DataB64", result.dg13DataB64)
+      putString("dg14DataB64", result.dg14DataB64)
+      putString("sodData", result.sodData)
+    }
+
+    NFCSDKModule.sendEvent("onNfcCompleted", resultMap)
+  }
+
+  // ── UI Setup ───────────────────────────────────────────────
+
+  private fun setupWindow() {
+    window.addFlags(android.view.WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+    window.setBackgroundDrawable(ColorDrawable(Color.TRANSPARENT))
+    window.setLayout(
+      android.view.WindowManager.LayoutParams.MATCH_PARENT,
+      android.view.WindowManager.LayoutParams.MATCH_PARENT,
+    )
+    window.setGravity(Gravity.BOTTOM)
+  }
+
+  private fun setupTransition() {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+      overrideActivityTransition(OVERRIDE_TRANSITION_OPEN, 0, 0)
+    } else {
+      @Suppress("DEPRECATION")
+      overridePendingTransition(0, 0)
+    }
+  }
+
+  private fun setupSheetAnimation() {
+    val sheetScrim = findViewById<View>(R.id.sheetScrim)
+    val sheetContainer = findViewById<View>(R.id.sheetContainer)
+
+    sheetScrim.alpha = 0f
+    sheetContainer.post {
+      sheetContainer.translationY = sheetContainer.height.toFloat()
+      sheetScrim.animate().alpha(1f).setDuration(300).start()
+      sheetContainer.animate()
+        .translationY(0f)
+        .setDuration(300)
+        .setInterpolator(android.view.animation.DecelerateInterpolator())
+        .start()
+    }
+
+    sheetScrim.setOnClickListener {
+      if (!isReading) finish()
+    }
+  }
+
+  private fun setupViews() {
+    progressBar = findViewById(R.id.nfcProgressBar)
+    progressPercentTextView = findViewById(R.id.tvProgressPercent)
+    retryButton = findViewById(R.id.btnRetry)
+
+    retryButton.setOnClickListener {
+      isReading = false
+      scanCompleted = false
+      progressBar.progress = 0
+      retryButton.visibility = View.GONE
+      updateProgress(0, "Đưa CCCD sát mặt lưng điện thoại")
+      vibrate(120)
+    }
+  }
+
+  // ── Progress & Feedback ────────────────────────────────────
+
+  private fun updateProgress(progress: Int, message: String) {
+    runOnUiThread {
+      if (progress >= 0) {
+        progressBar.progress = progress
+        progressPercentTextView.text = "$progress%"
+      } else {
+        progressPercentTextView.text = "--%"
+      }
+
+      retryButton.visibility = if (progress < 0) View.VISIBLE else View.GONE
+    }
+
+    val params = Arguments.createMap().apply {
+      putInt("progress", progress)
+      putString("message", message)
+    }
+    NFCSDKModule.sendEvent("onNfcProgress", params)
+  }
+
+  private fun vibrate(durationMs: Long) {
+    try {
+      @Suppress("DEPRECATION")
+      val vibrator = getSystemService(VIBRATOR_SERVICE) as Vibrator
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        vibrator.vibrate(
+          VibrationEffect.createOneShot(durationMs, VibrationEffect.DEFAULT_AMPLITUDE),
+        )
+      } else {
+        @Suppress("DEPRECATION")
+        vibrator.vibrate(durationMs)
+      }
+    } catch (_: Exception) {
+    }
+  }
+
+  // ── Finish Animation ───────────────────────────────────────
+
+  override fun finish() {
+    val sheetScrim = findViewById<View>(R.id.sheetScrim)
+    val sheetContainer = findViewById<View>(R.id.sheetContainer)
+
+    if (sheetScrim != null && sheetContainer != null) {
+      sheetScrim.animate().alpha(0f).setDuration(250).start()
+      sheetContainer.animate()
+        .translationY(sheetContainer.height.toFloat())
+        .setDuration(250)
+        .setInterpolator(android.view.animation.AccelerateInterpolator())
+        .withEndAction {
+          super.finish()
+          suppressTransition()
+        }
+        .start()
+    } else {
+      super.finish()
+      suppressTransition()
+    }
+  }
+
+  private fun suppressTransition() {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+      overrideActivityTransition(OVERRIDE_TRANSITION_CLOSE, 0, 0)
+    } else {
+      @Suppress("DEPRECATION")
+      overridePendingTransition(0, 0)
+    }
+  }
+}

package/android/src/main/java/com/nfcsdk/utils/Dg13Parser.kt

@@ -0,0 +1,278 @@
+package com.nfcsdk.utils
+
+import java.nio.charset.Charset
+import java.text.Normalizer
+import java.text.ParseException
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+
+data class Dg13ParsedData(
+  val gender: String = "",
+  val permanentAddress: String = "",
+  val issueDate: String = "",
+  val issuePlace: String = "",
+  val expireDate: String = "",
+  val fieldMap: Map<Int, List<String>> = emptyMap(),
+)
+
+private data class Asn1Node(
+  val tagClass: Int,
+  val tagNumber: Int,
+  val constructed: Boolean,
+  val valueOffset: Int,
+  val valueLength: Int,
+  val nextOffset: Int,
+)
+
+object Dg13Parser {
+  private const val TAG_CLASS_UNIVERSAL = 0
+  private const val TAG_CLASS_APPLICATION = 1
+
+  fun parse(
+    dg13Bytes: ByteArray,
+    fallbackIssuePlace: String = "",
+  ): Dg13ParsedData {
+    if (dg13Bytes.isEmpty()) {
+      return Dg13ParsedData(issuePlace = fallbackIssuePlace)
+    }
+
+    val fields = parseStructuredFields(dg13Bytes)
+      ?: return Dg13ParsedData(issuePlace = fallbackIssuePlace)
+
+    val candidates = fields.values.flatten().distinct()
+
+    return Dg13ParsedData(
+      gender = normalizeGender(fields[0x04]?.firstOrNull().orEmpty()),
+      permanentAddress = fields[0x09]?.firstOrNull().orEmpty(),
+      issueDate = normalizeDate(fields[0x0B]?.firstOrNull().orEmpty()),
+      issuePlace = findIssuePlace(candidates) ?: fallbackIssuePlace,
+      expireDate = normalizeDate(fields[0x0C]?.firstOrNull().orEmpty()),
+      fieldMap = fields,
+    )
+  }
+
+  fun normalizeGender(raw: String): String {
+    return when (normalizeForSearch(raw)) {
+      "M", "MALE", "NAM" -> "Nam"
+      "F", "FEMALE", "NU" -> "Nữ"
+      else -> raw.trim()
+    }
+  }
+
+  private fun parseStructuredFields(bytes: ByteArray): Map<Int, List<String>>? {
+    val root = parseNode(bytes, 0) ?: return null
+    if (root.tagClass != TAG_CLASS_APPLICATION || root.tagNumber != 13) {
+      return null
+    }
+
+    val rootChildren = parseChildren(bytes, root)
+    val sequenceNode = rootChildren.firstOrNull() ?: return null
+    val sequenceChildren = parseChildren(bytes, sequenceNode)
+    val setNode = sequenceChildren.firstOrNull {
+      it.tagClass == TAG_CLASS_UNIVERSAL && it.tagNumber == 17
+    } ?: return null
+
+    val fieldNodes = parseChildren(bytes, setNode)
+    if (fieldNodes.isEmpty()) {
+      return null
+    }
+
+    val result = linkedMapOf<Int, List<String>>()
+    fieldNodes.forEach { fieldNode ->
+      if (!(fieldNode.tagClass == TAG_CLASS_UNIVERSAL && fieldNode.tagNumber == 16)) {
+        return@forEach
+      }
+
+      val parts = parseChildren(bytes, fieldNode)
+      val indexNode = parts.firstOrNull {
+        it.tagClass == TAG_CLASS_UNIVERSAL && it.tagNumber == 2
+      } ?: return@forEach
+
+      val index = parseInteger(bytes, indexNode) ?: return@forEach
+      val values = parts
+        .drop(1)
+        .flatMap { extractStrings(bytes, it) }
+        .map(::cleanValue)
+        .filter { it.isNotBlank() }
+
+      if (values.isNotEmpty()) {
+        result[index] = values
+      }
+    }
+
+    return result.takeIf { it.isNotEmpty() }
+  }
+
+  private fun parseChildren(bytes: ByteArray, parent: Asn1Node): List<Asn1Node> {
+    if (!parent.constructed) {
+      return emptyList()
+    }
+
+    val children = mutableListOf<Asn1Node>()
+    var offset = parent.valueOffset
+    val end = parent.valueOffset + parent.valueLength
+
+    while (offset < end) {
+      val child = parseNode(bytes, offset) ?: break
+      if (child.nextOffset > end) {
+        break
+      }
+      children.add(child)
+      offset = child.nextOffset
+    }
+
+    return children
+  }
+
+  private fun parseNode(bytes: ByteArray, offset: Int): Asn1Node? {
+    if (offset >= bytes.size) {
+      return null
+    }
+
+    var cursor = offset
+    val firstTagByte = bytes[cursor].toInt() and 0xFF
+    cursor += 1
+
+    val tagClass = (firstTagByte ushr 6) and 0x03
+    val constructed = (firstTagByte and 0x20) != 0
+    var tagNumber = firstTagByte and 0x1F
+
+    if (tagNumber == 0x1F) {
+      tagNumber = 0
+      while (cursor < bytes.size) {
+        val next = bytes[cursor].toInt() and 0xFF
+        cursor += 1
+        tagNumber = (tagNumber shl 7) or (next and 0x7F)
+        if ((next and 0x80) == 0) {
+          break
+        }
+      }
+    }
+
+    if (cursor >= bytes.size) {
+      return null
+    }
+
+    val lengthByte = bytes[cursor].toInt() and 0xFF
+    cursor += 1
+
+    val valueLength =
+      if ((lengthByte and 0x80) == 0) {
+        lengthByte
+      } else {
+        val count = lengthByte and 0x7F
+        if (count == 0 || count > 4 || cursor + count > bytes.size) {
+          return null
+        }
+
+        var length = 0
+        repeat(count) {
+          length = (length shl 8) or (bytes[cursor + it].toInt() and 0xFF)
+        }
+        cursor += count
+        length
+      }
+
+    val nextOffset = cursor + valueLength
+    if (nextOffset > bytes.size) {
+      return null
+    }
+
+    return Asn1Node(
+      tagClass = tagClass,
+      tagNumber = tagNumber,
+      constructed = constructed,
+      valueOffset = cursor,
+      valueLength = valueLength,
+      nextOffset = nextOffset,
+    )
+  }
+
+  private fun parseInteger(bytes: ByteArray, node: Asn1Node): Int? {
+    if (node.tagClass != TAG_CLASS_UNIVERSAL || node.tagNumber != 2) {
+      return null
+    }
+
+    var result = 0
+    for (index in 0 until node.valueLength) {
+      result = (result shl 8) or (bytes[node.valueOffset + index].toInt() and 0xFF)
+    }
+    return result
+  }
+
+  private fun extractStrings(bytes: ByteArray, node: Asn1Node): List<String> {
+    if (node.constructed) {
+      return parseChildren(bytes, node).flatMap { child ->
+        extractStrings(bytes, child)
+      }
+    }
+
+    if (node.tagClass != TAG_CLASS_UNIVERSAL) {
+      return emptyList()
+    }
+
+    val value = bytes.copyOfRange(node.valueOffset, node.nextOffset)
+    val decoded = when (node.tagNumber) {
+      12, 19, 20, 22 -> decodeString(value, Charsets.UTF_8)
+      30 -> decodeString(value, Charsets.UTF_16BE)
+      else -> ""
+    }
+
+    return decoded.takeIf { it.isNotBlank() }?.let(::listOf) ?: emptyList()
+  }
+
+  private fun decodeString(value: ByteArray, charset: Charset): String {
+    return value.toString(charset).trim()
+  }
+
+  private fun cleanValue(raw: String): String {
+    return raw.replace(Regex("""\s+"""), " ").trim()
+  }
+
+  private fun normalizeForSearch(raw: String): String {
+    return Normalizer.normalize(raw, Normalizer.Form.NFD)
+      .replace(Regex("""\p{M}+"""), "")
+      .uppercase(Locale.ROOT)
+      .trim()
+  }
+
+  private fun findIssuePlace(candidates: List<String>): String? {
+    return candidates.firstOrNull { candidate ->
+      val normalized = normalizeForSearch(candidate)
+      normalized.contains("CONG AN") || normalized.contains("CANH SAT")
+    }
+  }
+
+  private fun normalizeDate(raw: String): String {
+    val parsed = tryParseDate(raw) ?: return raw.trim()
+    return OUTPUT_DATE_FORMAT.format(parsed)
+  }
+
+  private fun tryParseDate(raw: String): Date? {
+    val clean = raw.trim()
+    for (pattern in DATE_PATTERNS) {
+      try {
+        return SimpleDateFormat(pattern, Locale.ROOT).apply {
+          isLenient = false
+        }.parse(clean)
+      } catch (_: ParseException) {
+      }
+    }
+
+    return null
+  }
+
+  private val OUTPUT_DATE_FORMAT =
+    SimpleDateFormat("dd/MM/yyyy", Locale.ROOT).apply {
+      isLenient = false
+    }
+
+  private val DATE_PATTERNS =
+    listOf(
+      "dd/MM/yyyy",
+      "yyyy-MM-dd",
+      "ddMMyyyy",
+      "yyyyMMdd",
+    )
+}

package/android/src/main/java/com/nfcsdk/utils/FaceExtractor.kt

@@ -0,0 +1,40 @@
+package com.nfcsdk.utils
+
+import android.util.Base64
+import android.util.Log
+import org.jmrtd.lds.icao.DG2File
+import java.io.ByteArrayInputStream
+
+/**
+ * Trích xuất ảnh khuôn mặt từ DG2 (biometric data).
+ */
+object FaceExtractor {
+
+  private const val TAG = "NFCSDK"
+
+  /**
+   * Trích xuất ảnh khuôn mặt đầu tiên từ DG2 raw bytes.
+   * @return Base64-encoded image string, hoặc null nếu không tìm thấy.
+   */
+  fun extractBase64(dg2Bytes: ByteArray): String? {
+    return try {
+      val dg2File = DG2File(ByteArrayInputStream(dg2Bytes))
+      val faceInfos = dg2File.faceInfos
+      if (faceInfos.isEmpty()) return null
+
+      val faceImageInfos = faceInfos[0].faceImageInfos
+      if (faceImageInfos.isEmpty()) return null
+
+      val imageBytes = faceImageInfos[0].imageInputStream.readBytes()
+      if (imageBytes.isEmpty()) {
+        Log.e(TAG, "extractBase64: imageBytes is empty")
+        return null
+      }
+
+      Base64.encodeToString(imageBytes, Base64.NO_WRAP)
+    } catch (exception: Exception) {
+      Log.e(TAG, "DG2 face extraction failed", exception)
+      null
+    }
+  }
+}

package/android/src/main/java/com/nfcsdk/utils/MrzUtils.kt

@@ -0,0 +1,75 @@
+package com.nfcsdk.utils
+
+import java.util.Calendar
+import java.util.Locale
+
+/**
+ * Utility functions xử lý dữ liệu MRZ (Machine Readable Zone) từ DG1.
+ */
+object MrzUtils {
+
+  /**
+   * Format ngày sinh từ MRZ (YYMMDD) sang DD/MM/YYYY.
+   * Sử dụng năm hiện tại làm ngưỡng xác định thế kỷ (19xx vs 20xx).
+   */
+  fun formatBirthDate(value: String): String {
+    if (value.length != 6) return value
+
+    val yy = value.substring(0, 2)
+    val mm = value.substring(2, 4)
+    val dd = value.substring(4, 6)
+    val currentYearShort = Calendar.getInstance().get(Calendar.YEAR) % 100
+    val year = if (yy.toIntOrNull() ?: 0 > currentYearShort) "19$yy" else "20$yy"
+
+    return "$dd/$mm/$year"
+  }
+
+  /**
+   * Format ngày hết hạn từ MRZ (YYMMDD) sang DD/MM/20YY.
+   * CCCD luôn hết hạn trong thế kỷ 21.
+   */
+  fun formatExpireDate(value: String): String {
+    if (value.length != 6) return value
+
+    val yy = value.substring(0, 2)
+    val mm = value.substring(2, 4)
+    val dd = value.substring(4, 6)
+
+    return "$dd/$mm/20$yy"
+  }
+
+  /**
+   * Ghép primaryIdentifier + secondaryIdentifier từ MRZ thành họ tên.
+   * Thay ký tự '<' bằng khoảng trắng và chuẩn hóa.
+   */
+  fun normalizeName(primary: String?, secondary: String?): String {
+    return listOf(primary, secondary)
+      .filterNotNull()
+      .joinToString(" ")
+      .replace("<", " ")
+      .replace(Regex("\\s+"), " ")
+      .trim()
+  }
+
+  /**
+   * Chuẩn hóa giới tính từ MRZ sang tiếng Việt.
+   */
+  fun normalizeGender(raw: String): String {
+    return when (raw.trim().uppercase(Locale.ROOT)) {
+      "M", "MALE", "NAM" -> "Nam"
+      "F", "FEMALE", "NU" -> "Nữ"
+      else -> "Khác"
+    }
+  }
+
+  /**
+   * Chuẩn hóa quốc tịch từ mã ISO 3166 sang tiếng Việt.
+   */
+  fun normalizeNationality(raw: String?): String {
+    return when (raw?.uppercase(Locale.ROOT)) {
+      "VNM" -> "Việt Nam"
+      null, "" -> "Việt Nam"
+      else -> raw
+    }
+  }
+}

package/android/src/main/res/drawable/bg_nfc_bottom_sheet.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+    android:shape="rectangle">
+    <solid android:color="#FFF7ED" />
+    <corners
+        android:topLeftRadius="28dp"
+        android:topRightRadius="28dp"
+        android:bottomLeftRadius="24dp"
+        android:bottomRightRadius="24dp" />
+    <stroke
+        android:width="1dp"
+        android:color="#FED7AA" />
+</shape>