Tích hợp Flutter

Yêu cầu

Yêu cầu Dart >= 3.1.5

Bước 1: Tải module và cấu hình

• Copy thư mục vnpt_smartca_module vào trong project
• Trong pubspec.yaml bổ sung đường dẫn tới thư mục vnpt_smartca_module

vnpt_smartca_module:
    path: ../vnpt_smartca_module

• Trong main.dart bổ sung đoạn code sau

@pragma('vm:entry-point')
void VNPTSmartCAEntryponit() => bootstrapSmartCAApp();

• Bổ sung MethodChannel tương tác giữa Flutter và Native code

  static const platform = MethodChannel("com.vnpt.flutter/partner");

  Future<void> getAuthentication() async {
    await platform.invokeMethod('getAuthentication');
  }

  Future<void> getWaitingTransaction() async {
    await platform.invokeMethod('getWaitingTransaction');
  }

  Future<void> toMainPage() async {
    await platform.invokeMethod('getMainInfo');
  }

  initMethod(BuildContext context) {
    platform.setMethodCallHandler((call) async {
      if (call.method == "getAuthenticationResult") {
        if (call.arguments is Map && call.arguments["status"] == 0) {
          // Xử lý khi thành công
        } else {
          // Xử lý khi thất bại
        }
      } else if (call.method == "getMainInfoResult") {
        debugPrint("getMainInfoResult");
      } else if (call.method == "getWaitingTransactionResult") {
        if (call.arguments is Map && call.arguments["status"] == 0) {
          // Xử lý khi thành công
        } else {
          // Xử lý khi thất bại
        }
      }
    });
  }

Tích hợp native iOS

Bước 1: Tải SDK và cấu hình Project

• Thực hiện các Bước 1 theo hướng dẫn tại đây

Bước 2: Khởi tạo SDK tại nơi bắt đầu kết nối

• Code tại AppDelegate

  import UIKit
  import Flutter
  import SmartCASDK
  
  @UIApplicationMain
  @objc class AppDelegate: FlutterAppDelegate {
      
      var channelFlutter: FlutterMethodChannel?
      var vnptSmartCASDK: VNPTSmartCASDK?
      
      override func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
          
          if let rootView = window?.rootViewController as? FlutterViewController {
              self.vnptSmartCASDK = VNPTSmartCASDK(
                  viewController: rootView,
                  partnerId: "CLIENT_ID",
                  environment: VNPTSmartCASDK.ENVIRONMENT.DEMO,
                  lang: VNPTSmartCASDK.LANG.VI,
                  isFlutterApp: true)
              
              let channel = FlutterMethodChannel(name: "com.vnpt.flutter/partner", binaryMessenger: rootView.binaryMessenger)
              channel.setMethodCallHandler({ (call: FlutterMethodCall, result: @escaping FlutterResult) -> Void in
                  self.channelFlutter = channel
                  
                  if call.method == "getAuthentication" {
                      self.getAuthentication()
                  } else if call.method == "getMainInfo" {
                      self.getMainInfo()
                  } else if call.method == "getWaitingTransaction" {
                      let transactionId = call.arguments as? String ?? ""
                      self.getWaitingTransaction(transactionId: transactionId)
                  }
              })
          }
          
          GeneratedPluginRegistrant.register(with: self)
          return super.application(application, didFinishLaunchingWithOptions: launchOptions)
      }
      
      // Lấy thông tin về AccessToken & CredentialId
      func getAuthentication() {
          self.vnptSmartCASDK?.getAuthentication(callback: { result in
              self.channelFlutter?.invokeMethod("getAuthenticationResult", arguments: result.toJson())
          });
      }
      
      func getMainInfo() {
          self.vnptSmartCASDK?.getMainInfo(callback: { result in
              self.channelFlutter?.invokeMethod("getMainInfoResult", arguments: result.toJson())
          })
      }
      
      // Khách hàng xác nhận / hủy giao dịch.
      func getWaitingTransaction(transactionId: String) {
          self.vnptSmartCASDK?.getWaitingTransaction(tranId: transactionId, callback: { result in
              self.channelFlutter?.invokeMethod("getWaitingTransactionResult", arguments: result.toJson())
          })
      }
  }

Bước 3: Chi tiết các hàm chính

Tích hợp native Android

Bước 1: Tải SDK và cấu hình Project

• Thực hiện các Bước 1 theo hướng dẫn tại đây

Bước 2: Khởi tạo SDK tại nơi bắt đầu kết nối

• Thêm đoạn code dưới đây tại MainActivity:

import android.os.Handler
import com.vnpt.smartca.ConfigSDK
import com.vnpt.smartca.SmartCAEnvironment
import com.vnpt.smartca.SmartCALanguage
import com.vnpt.smartca.SmartCAResult
import com.vnpt.smartca.VNPTSmartCASDK
import io.flutter.embedding.android.FlutterFragmentActivity
import io.flutter.embedding.engine.FlutterEngine
import io.flutter.plugin.common.MethodChannel
import io.flutter.plugins.GeneratedPluginRegistrant

class MainActivity : FlutterFragmentActivity() {
    var VNPTSmartCA = VNPTSmartCASDK()
    lateinit var methodChannel: MethodChannel

    override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
        GeneratedPluginRegistrant.registerWith(flutterEngine)
        try {
            val config = ConfigSDK()
            config.context = this
            //clientId của đối tác được VNPTSmartCA cung cấp khi yêu cầu tích hợp
            config.partnerId = "CLIENT_ID"
            config.environment = SmartCAEnvironment.DEMO_ENV
            config.lang = SmartCALanguage.VI
            config.isFlutter = true

            VNPTSmartCA.initSDK(config)

            methodChannel = MethodChannel(flutterEngine.dartExecutor.binaryMessenger, "com.vnpt.flutter/partner")
            methodChannel.setMethodCallHandler { call, result ->
                when (call.method) {
                    "getAuthentication" -> getAuthentication();
                    "getMainInfo" -> getMainInfo()
                    "getWaitingTransaction" -> (call.arguments as? String)?.let { getWaitingTransaction(it) };
                }
            }

        } catch (ex: Exception) {
            throw ex;
        }
    }

    private fun getAuthentication() {
        try {
            VNPTSmartCA.getAuthentication { result ->
                methodChannel.invokeMethod("getAuthenticationResult", getMap(result))
            }
        } catch (ex: Exception) {
            throw ex;
        }
    }

    private fun getMainInfo() {
        try {
            VNPTSmartCA.getMainInfo { result ->
                methodChannel.invokeMethod("getMainInfoResult", getMap(result))
            }
        } catch (ex: Exception) {
            throw ex;
        }
    }

    private fun getWaitingTransaction(transId: String) {
        try {
            VNPTSmartCA.getWaitingTransaction(transId) { result ->
                methodChannel.invokeMethod("getWaitingTransactionResult", getMap(result))
            }
        } catch (ex: Exception) {
            throw ex;
        }
    }

    fun getMap(result: SmartCAResult) : HashMap<String, Any> {
        var hashMap = HashMap<String, Any> ()
        hashMap.put("status", result.status)
        result.statusDesc?.let { hashMap.put("statusDesc", it) }
        result.data?.let { hashMap.put("data", it) }
        return hashMap;
    }
}

Bước 3: Chi tiết các hàm chính