app
root
repo
    +--com
        +--trustvision
            +--tv_api_sdk
                +--4.0.x
                    +--tv_api_sdk-4.0.x.aar
                    +--tv_api_sdk-4.0.x.pom
                maven-metadata.xml
            +--tv_core_sdk
            +--tv_sdk
...

buildscript {
    ext.kotlin_version = '1.6.21' // or any version that >= 1.5 and < 1.8

    repositories {
        maven {
            url 'https://maven.google.com'
        }
        mavenCentral()
        google()
    }

    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
    }
}

allprojects {
    repositories {
        maven { url "https://maven.google.com" }
        maven { url "https://jitpack.io" }
        maven { url "path/to/tvsdk/folder" }  // example : maven { url "${project.rootDir}/repo" }
        ...
    }
}

pluginManagement {
    repositories {
        google()
        mavenCentral()
        gradlePluginPortal()
    }
}
dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.PREFER_PROJECT)
    repositories {
        google()
        mavenCentral()
    }
}

android {
    ...
    aaptOptions {
        noCompress "tflite"
    }

    // Support 16KB https://developer.android.com/guide/practices/page-sizes
   ndk {
            abiFilters "arm64-v8a", "armeabi-v7a"
     }
}

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation('com.trustvision:tv_sdk:4.x.x.x@aar') {
        transitive = true
    }
    testImplementation 'junit:junit:4.12'

}

TVInitializeConfiguration config = new TVInitializeConfiguration.Build()
    .setJsonConfigurationByServer(jsonConfigurationByServer)
    .setEndpoint(endpoint)
    .setAccessKeyId(accessKeyId)
    .setAccessKeySecret(accessKeySecret)
    .setEndpointLogger(endpointLogger)
    .setAccessKeyIdLogger(accessKeyIdLogger)
    .setAccessKeySecretLogger(accessKeySecretLogger)
    .setLanguageCode(languageCode)
    .setTheme(theme)
    .setImageEncryptionKey(imageEncryptionKey)
    .setSecurityPublicKey(securityPublicKey)
    .setXRequestId(xRequestId)
    .setXRequestId2(xRequestId2)
    .setTvCertificate(tvCertificate)
    .setHeaders(headers)
    .build();

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    TrustVisionSDK.INSTANCE.init(context, config, new BaseTrustVisionSDK.TVInitializeListener() {
        @Override
        public void onInitSuccess() {

        }

        @Override
        public void onInitError(@NonNull TVDetectionError error) {

        }
    });
}

TrustVisionSdk.INSTANCE.getSupportedLanguages();

TrustVisionSdk.INSTANCE.changeLanguageCode(languageCode);

<resources>
    <string name="tv_title_activity_main" />
    <integer name="google_play_services_version">1</integer>
    <style name="tvAppTheme.NoActionBar" parent="AppTheme.NoActionBar" />
</resources>

TrustVisionSDK.INSTANCE.installDynamicFeature(it -> {
    // We often execute this code to install some necessary resources for dynamic feature
    SplitCompat.installActivity(it);
    return Unit.INSTANCE;
});

TVIDConfiguration.Builder builder= new TVIDConfiguration.Builder()
    .setEnableSound(true)
    .setCardType(selectedCard)
    .setCardSide(TVSDKConfiguration.TVCardSide.FRONT)
    .setReadBothSide(false)
    .setEnableScanNfc(true)
    .setEnableScanQr(true)
    .setEnablePhotoGalleryPicker(false)
    .setEnableTiltChecking(false)
    .setSkipConfirmScreen(true)
    .setEnableUploadFrames(true)
    .setEnableUploadImages(true)
    .setEnableSanityCheck(true)
    .setEnableDetectIdCardTampering(true)
    .setEnableReadCardInfo(true)
    .setEnableCheckNfcData(true)
    .setEnableVerifyNfc(true);

TVIDConfiguration configuration=builder.build();

TrustVisionSDK.INSTANCE.startIDCapturing(activity, configuration, new TVCapturingCallBack(){
    @Override
    public void onNewFrameBatch(FrameBatch frameBatch){

    }

    @Override
    public void onError(TVDetectionError error){

    }

    @Override
    public void onSuccess(TVDetectionResult result){

    }

    @Override
    public void onCanceled(TVCancelReason reason){

    }

    @Override
    public TVNfcParams readIdCardImage(@NonNull TVImageClass image) {

    }
});

// this dictionary will be used for ID Tampering Verification
Map frontCardFrameBatchIdsDictionary = new HashMap<String, String>();
Map backCardFrameBatchIdsDictionary = new HashMap<String, String>();
// frameBatchIdsDictionary.put(
//    key = <id_returned_from_sdk>,
//    value = <id_responded_from_server>
// );

@Override
public void onNewFrameBatch(FrameBatch frameBatch) {
    Gson gson = new Gson();
    String framesStr = gson.toJson(frameBatch.getFrames());
    Map<String, Object> params = new HashMap<>();
    params.put("frames", framesStr);
    params.put("metadata", frameBatch.getMetadata());
    params.put("label", "video");

    String jsonToBeUploaded=gson.toJson(map);
    // upload frame batch to server using this api:
    // https://ekyc.trustingsocial.com/api-reference/customer-api/#upload-videoaudioframes
    YourResponseObject uploadingResult = yourMethodToUploadFrameBatch(jsonToBeUploaded);

    // Keep the id that generated by the SDK corresponding with the one responded from server
    if (cardSide == TVSDKConfiguration.TVCardSide.FRONT) {
        frontCardFrameBatchIdsDictionary.put(
            key = frameBatch.batchId,
            value = uploadingResult.fileId
        );
    } else {
        backCardFrameBatchIdsDictionary.put(
            key = frameBatch.batchId,
            value = uploadingResult.fileId
        );
    }
}

// These lists contain all valid frame batch ids that responded by server
var validFrontCardServerFrameBatchIds: List<String>? = null
var validBackCardServerFrameBatchIds: List<String>? = null

override fun onSuccess(result: TVDetectionResult) {
// the batch id list is null when Frame Recording feature is disabled by client settings.
// Wait until every Frame batch has been uploaded to server before calling this
    if (everyFrameBatchUploadingCompleted) {
        result.frontCardFrameBatchIds?.also {
            validFrontCardServerFrameBatchIds = removeRedundantFrameBatchIds(
                frontCardFrameBatchIdsDictionary,
                it
            )
        }
        result.backCardFrameBatchIds?.also {
            validBackCardServerFrameBatchIds = removeRedundantFrameBatchIds(
                backCardFrameBatchIdsDictionary,
                it
            )
        }
    }
}

private fun removeRedundantFrameBatchIds(
    batchIdsDictionary: MutableMap<String, String>,
    validIdsFromSDK: Collection<String>
): List<String> {
    val iter: MutableIterator<Map.Entry<String, String>> = batchIdsDictionary.entries.iterator()
    while (iter.hasNext()) {
        val (key1) = iter.next()
        if (!validIdsFromSDK.contains(key1)) {
            iter.remove()
        }
    }
    return batchIdsDictionary.values.toList()
}

{
  "file": "<byte[] dataToUpload>",
  "label": "proper label, check the API document for detail"
}

{
  "image": {
    "id": "<frontCardId>"
  },
  "image2": {
    "id": "<backCardId>"
  },
  "qr1_images": [
    {
      "id": "<qrId>"
    }
  ],
  "card_type": "<result.cardType.getCardId()>",
  "videos": [
    {
      "id": "<validFrontCardServerFrameBatchIds.get(index)>"
    },
    {
      "id": "<validFrontCardServerFrameBatchIds.get(index + 1)>"
    },
    ...
    {
      "id": "<validBackCardServerFrameBatchIds.get(index)>"
    },
    {
      "id": "<validBackCardServerFrameBatchIds.get(index + 1)>"
    },
    ...
  ]
}

TVImageClass frontQrImage = result.getFrontIdQr().getImages().get(i);
Map<String, String> metadata = frontQrImage.getMetadata();
String label = frontQrImage.getLabel();
byte[] data = frontQrImage.getImageByteArray();

override fun readIdCardImage(image: TVImageClass): TVNfcParams? {
  var idNumber: String? = null;
  // call api or do any thing to read and return id number
  // TODO
  return TVNfcParams(idNumber, null, null, null)
}

TVSelfieConfiguration configuration = new TVSelfieConfiguration.Builder()
    .setCameraOption(TVSDKConfiguration.TVCameraOption.FRONT)
    .setEnableSound(false)
    .setLivenessMode(TVLivenessMode.PASSIVE)
    .setEnableVerticalChecking(false)
    .setSkipConfirmScreen(false)
    .setEnableUploadFrames(true)
    .setEnableUploadImages(true)
    .setEnableSanityCheck(true)
    .setEnableVerifyLiveness(true)
    .build();

TrustVisionSDK.INSTANCE.startSelfieCapturing(activity, configuration, new TVCapturingCallBack() {
    @Override
    public void onNewFrameBatch(FrameBatch frameBatch) {

    }

    @Override
    public void onError(TVDetectionError error) {

    }

    @Override
    public void onSuccess(TVDetectionResult result) {

    }

    @Override
    public void onCanceled(TVCancelReason reason){

    }
});

// this dictionary will be used for Liveness verification
Map selfieFrameBatchIdsDictionary = new HashMap<String, String>();
// frameBatchIdsDictionary.put(
//    key = <id_returned_from_sdk>,
//    value = <id_responded_from_server>
// );

@Override
public void onNewFrameBatch(FrameBatch frameBatch) {
    Gson gson = new Gson();
    String framesStr = gson.toJson(frameBatch.getFrames());
    Map<String, Object> params = new HashMap<>();
    params.put("frames", framesStr);
    params.put("metadata", frameBatch.getMetadata());
    params.put("label", "video");

    String jsonToBeUploaded = gson.toJson(map);
    // upload frame batch to server using this api:
    // https://ekyc.trustingsocial.com/api-reference/customer-api/#upload-videoaudioframes
    YourResponseObject uploadingResult = yourMethodToUploadFrameBatch(jsonToBeUploaded);

    // Keep the id that generated by the SDK corresponding with the one responded from server
    selfieFrameBatchIdsDictionary.put(
        key = frameBatch.getId(),
        value = uploadingResult.fileId
    );
}

// These lists contain all valid frame batch ids that responded by server
var validServerFrameBatchIds: List<String>? = null

override fun onSuccess(result: TVDetectionResult) {
    // the batch id list is null when Frame Recording feature is disabled by client settings.
    // Wait until every Frame batch has been uploaded to server before calling this
    if (everyFrameBatchUploadingCompleted) {
        result.livenessFrameBatchIds?.also {
            validServerFrameBatchIds = removeRedundantFrameBatchIds(
                selfieFrameBatchIdsDictionary,
                it
            )
        }
    }
}

private fun removeRedundantFrameBatchIds(
    batchIdsDictionary: MutableMap<String, String>,
    validIdsFromSDK: Collection<String>
): List<String> {
    val iter: MutableIterator<Map.Entry<String, String>> = batchIdsDictionary.entries.iterator()
    while (iter.hasNext()) {
        val (key1) = iter.next()
        if (!validIdsFromSDK.contains(key1)) {
            iter.remove()
        }
    }
    return batchIdsDictionary.values.toList()
}

// These lists of image ids will be used in Liveness Verification
List<String> frontalImageIds = new ArrayList<>();
List<String> gestureImageIds = new ArrayList<>();

@Override
public void onSuccess(TVDetectionResult result) {
    handleSelfieImages(result.getFaces(), result.getGestureFaces();
}

private void handleSelfieImages(List<TVImageClass> faces, List<TVGestureFace> gestureFaces) {
    for (face: faces) {
        // Handle frontal images
        if (face.getImageByteArray() != null){
            byte[] frontalImageByteArray = face.getImageByteArray();
            // frontalImageId is the id of the image, returned from server when the uploading API is completed successfully
            String frontalImageId = yourUploadImageMethod(frontalImageByteArray);
            frontalImageIds.add(frontalImageId);
        }
    }

    for (face: gestureFaces) {
      for (image: face.getImages) {
        // Handle gesture images
        if (image.getImageByteArray() != null){
            byte[] gestureImageByteArray = image.getImageByteArray();
            // gestureImageId is the id of the image, returned from server when the uploading API is completed successfully
            String gestureImageId = yourUploadImageMethod(gestureImageByteArray);
            gestureImageIds.add(gestureImageId);
        }
      }
    }
}

{
  "file": "<byte[] dataToUpload>",
  "label": "<proper label, check the API document for detail>"
}

{
  "images": [
    {
      "id": "<frontalImageIds.get(index)>"
    },
    {
      "id": "<frontalImageIds.get(index + 1)>"
    },
    ...
  ]
}

{
  "gesture_images": [
    {
      "gesture": "<result.getSelfieImages().get(index).getGestureType().toGestureType().toLowerCase()>",
      "images": [
        {
          "id": "<gestureImageIds.get(index)>"
        }
      ]
    },
    {
      "gesture": "<result.getSelfieImages().get(index + 1).getGestureType().toGestureType().toLowerCase()>",
      "images": [
        {
          "id": "<gestureImageIds.get(index + 1)>"
        }
      ]
    },
    ...
  ]
}

{
  "videos": [
    {
      "id": "<validServerFrameBatchIds.get(index)>"
    },
    {
      "id": "<validServerFrameBatchIds.get(index + 1)>"
    },
    ...
  ]
}

{
  "metadata": "<result.getLivenessMetadata()>"
}

TVQRConfiguration.Builder builder= new TVQRConfiguration.Builder()
    .setCardTypes(cards)
    .setCardSide(TVSDKConfiguration.TVCardSide.FRONT)
    .setEnableSound(false)
    .setSkipConfirmScreen(false)
    .setEnableUploadFrames(true)
    .setEnableUploadImages(true);

TVQRConfiguration configuration=builder.build();

new TVCardType(
    "vn.national_id",
    "CMND cũ / CMND mới / CCCD",
    true,
    TVCardType.TVCardOrientation.HORIZONTAL,
    null,
    null
);

TrustVisionSDK.INSTANCE.startQRScanning(activity, configuration, new TVCapturingCallBack(){
    @Override
    public void onError(TVDetectionError error){

    }

    @Override
    public void onSuccess(TVDetectionResult result){

    }

    @Override
    public void onCanceled(TVCancelReason reason){

    }
});

TVImageClass frontQrImage = result.getFrontIdQr().getImages().get(i);
Map<String, String> metadata = frontQrImage.getMetadata();
String label = frontQrImage.getLabel();
byte[] data = frontQrImage.getImageByteArray();

TVNfcConfiguration.Builder builder = TVNfcConfiguration.builder()
    .setNfcCode(nfcCode)
    .setHashSod(sod)
    .setIssueDate(issueDate)
    .setCachedFields(cachedFields)
    .setRequestReadImageNfc(true)
    .setRequestIntegrityCheckNfc(true)
    .setRequestCloneDetectionNfc(true)
    .setNfcMaxRetries(5)
    .setEnableCheckNfcData(true)
    .setEnableVerifyNfc(true);

TVNfcConfiguration configuration = builder.build();

TrustVisionSDK.INSTANCE.startNfcScanning(activity, configuration, new TVCapturingCallBack() {
    @Override
    public void onCanceled(TVCancelReason reason) {

    }

    @Override
    public void onSuccess(@NonNull TVDetectionResult result) {

    }

    @Override
    public void onError(@NonNull TVDetectionError error) {

    }
});

TVFaceAuthenticationConfiguration configuration = TVFaceAuthenticationConfiguration.builder()
        .setCusUserId("1")
        .setAuthType(AuthType.AUTH)
        .setAuthMode(TVAuthMode.flashEdge())
        .setEnableFaceAuthentication(true)
        .setEnableFaceRegistration(true)
        .build();

TrustVisionSDK.INSTANCE.startFaceAuthentication(activity, configuration, new TVCapturingCallBack() {
    @Override
    public void onNewFrameBatch(FrameBatch frameBatch) {
    }

    @Override
    public void onError(TVDetectionError error) {
    }

    @Override
    public void onSuccess(TVDetectionResult result) {
    }

    @Override
    public void onCanceled(TVCancelReason reason){
    }
});

TVFaceAuthenticationConfiguration configuration = TVFaceAuthenticationConfiguration.builder()
        .setCusUserId("1")
        .setAuthType(AuthType.AUTH)
        .setAuthMode(TVAuthMode.FlashEdge())
        .setEnableFaceAuthentication(false)
        .setEnableFaceRegistration(false)
        .build();
TrustVisionSDK.INSTANCE.startFaceAuthentication(activity, configuration, new TVCapturingCallBack() {
    @Override
    public void onError(TVDetectionError error) {

    }

    @Override
    public void onSuccess(TVDetectionResult result) {
        List<TVSyncFile> faceIds = new ArrayList();
        List<TVGestureImage> gestureFaces = new ArrayList();
        List<TVVideoFile> videoIds = new ArrayList();
        String cusUserId = "1";
        String selfieType = "selfie";
        String authType = "transfer";
        for (TVImageClass face: result.getFaces()) {
          faceIds.add(TVSyncFile.createById(face.getImageId());
        }
        for (TVGestureFace gesture: result.getGestureFaces()) {
          String gestureName = gesture.getGesture();
          List<TVSyncFile> ids = new ArrayList();
          for (TVImageClass img: gesture.getImages()) {
            ids.add(TVSyncFile.createById(img.getImageId()));
          }
          gestureFaces.add(new TVGestureImage(gesture, ids));
        }
        for (String id: result.getLivenessFrameBatchIds()) {
          videoIds.add(TVVideoFile.createById(id));
        }

        // SDK uploads images to the server and returns the image IDs to the host app
        // call api to verify face authentication
        // /api-docs/face-authentication-api/authenticate/
        yourMethodToCallFaceAuthenticationAPI(
            cusUserId,
            faceIds,
            gestureFaces,
            videoIds,
            selfieType,
            authType
        );
    }

    @Override
    public void onCanceled(TVCancelReason reason){

    }
});

// [FlowStartingFunc]: startIdCapturing, startSelfieCapturing, startQRScanning, startNfcScanning

TrustVisionSDK.INSTANCE.[FlowStartingFunc](..., builder.build(), new TVCapturingCallBack() {
    @Override
    public void onError(TVDetectionError error) {
        String message = error.getErrorDescription();
        Log.d("", message);
        showToast(message);

        ///////////////////////////////////////
        // ERROR HANDLER
        int code = error.getErrorCode();
        String description = error.getErrorDescription();

        switch code {
            case TVDetectionError.CONFIGURATION_ERROR:
            // Invalid configuration
            case TVDetectionError.DETECTION_ERROR_PERMISSION_MISSING:
            // No camera permission.
            case TVDetectionError.DETECTION_ERROR_CAMERA_ERROR:
            // The camera can't be opened.
            case TVDetectionError.DETECTION_ERROR_SDK_INTERNAL:
            // The SDK has an unexpected error.
            case TVDetectionError.DETECTION_ERROR_NFC:
            // The SDK has an unexpected error when scanning NFC
        }
    }

    @Override
    public void onSuccess(TVDetectionResult result) {

    }

    @Override
    public void onCanceled(TVCancelReason reason) {

    }
});

boolean isNfcSupport = BooleanTrustVisionSDK.INSTANCE.isNfcSupport(Context);

DeviceInfo info = TrustVisionSDK.INSTANCE.getDeviceInfo(Context);

int NEUTRAL = 1
int TURN_LEFT = 5
int TURN_RIGHT = 6
int FACE_UP = 7
int FACE_DOWN = 8

int TVDetectionError.DETECTION_ERROR_PERMISSION_MISSING = 1004
int TVDetectionError.DETECTION_ERROR_CAMERA_ERROR = 1005
int TVDetectionError.DETECTION_ERROR_SDK_INTERNAL = 1007