@atomicfi/transact-capacitor 0.0.1

package/android/build.gradle

@@ -0,0 +1,72 @@
+ext {
+    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.2'
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.7.1'
+    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.3.0'
+    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.7.0'
+    kotlinVersion = project.hasProperty('kotlinVersion') ? rootProject.ext.kotlinVersion : '2.1.21'
+    transactVersion = project.hasProperty('atomicTransactVersion') ? rootProject.ext.atomicTransactVersion : '3.15.2'
+}
+
+buildscript {
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.13.0'
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${project.hasProperty('kotlinVersion') ? rootProject.ext.kotlinVersion : '2.1.21'}"
+    }
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+android {
+    namespace = "com.atomicfi.transact"
+    compileSdk = project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 36
+
+    buildFeatures {
+        buildConfig true
+    }
+
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 24
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 36
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+        buildConfigField "String", "TRANSACT_VERSION", "\"$transactVersion\""
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+        }
+    }
+    lintOptions {
+        abortOnError = false
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_21
+        targetCompatibility JavaVersion.VERSION_21
+    }
+    kotlinOptions {
+        jvmTarget = '21'
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':capacitor-android')
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion"
+    implementation "financial.atomic:transact:$transactVersion"
+    testImplementation "junit:junit:$junitVersion"
+    androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
+    androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/com/atomicfi/transact/TransactPluginPlugin.kt

@@ -0,0 +1,274 @@
+package com.atomicfi.transact
+
+import android.os.Build
+import android.util.Base64
+import com.getcapacitor.JSObject
+import com.getcapacitor.Plugin
+import com.getcapacitor.PluginCall
+import com.getcapacitor.PluginMethod
+import com.getcapacitor.annotation.CapacitorPlugin
+import financial.atomic.transact.ActionConfig
+import financial.atomic.transact.Config
+import financial.atomic.transact.Transact
+import financial.atomic.transact.receiver.TransactBroadcastReceiver
+import org.json.JSONObject
+
+@CapacitorPlugin(name = "TransactPlugin")
+class TransactPluginPlugin : Plugin() {
+
+    private var savedCall: PluginCall? = null
+
+    private fun parseEnvironmentURL(environmentObj: JSONObject?): String {
+        if (environmentObj == null) return "https://transact.atomicfi.com"
+
+        return when (environmentObj.optString("environment", "production")) {
+            "sandbox" -> "https://transact-sandbox.atomicfi.com"
+            "custom" -> environmentObj.optString("transactPath", "https://transact.atomicfi.com")
+            else -> "https://transact.atomicfi.com"
+        }
+    }
+
+    private fun parseActionEnvironment(environmentObj: JSONObject?): Pair<Config.Environment, String?> {
+        if (environmentObj == null) return Pair(Config.Environment.PRODUCTION, null)
+
+        return when (environmentObj.optString("environment", "production")) {
+            "sandbox" -> Pair(Config.Environment.SANDBOX, null)
+            "custom" -> {
+                val transactPath = environmentObj.optString("transactPath", "https://transact.atomicfi.com")
+                Pair(Config.Environment.CUSTOM, transactPath)
+            }
+            else -> Pair(Config.Environment.PRODUCTION, null)
+        }
+    }
+
+    @PluginMethod
+    fun presentTransact(call: PluginCall) {
+        val configObj = call.getObject("config")
+        if (configObj == null) {
+            call.reject("Config is required")
+            return
+        }
+
+        val environmentObj = call.getObject("environment")
+        val activity = bridge.activity
+        if (activity == null) {
+            call.reject("Activity not available")
+            return
+        }
+
+        savedCall = call
+
+        // Add platform info to config
+        val platform = JSONObject()
+        platform.put("name", "android")
+        platform.put("systemVersion", Build.VERSION.SDK_INT.toString())
+        platform.put("sdkVersion", BuildConfig.TRANSACT_VERSION + "-capacitor")
+        configObj.put("platform", platform)
+
+        // Base64 encode the config for the token-based constructor
+        val token = Base64.encodeToString(
+            configObj.toString().toByteArray(Charsets.UTF_8),
+            Base64.NO_WRAP
+        )
+
+        val environmentURL = parseEnvironmentURL(environmentObj)
+
+        val config = Config(
+            token = token,
+            environment = "CUSTOM",
+            environmentURL = environmentURL
+        )
+
+        activity.runOnUiThread {
+            try {
+                Transact.present(activity, config, object : TransactBroadcastReceiver() {
+                    override fun onClose(data: JSONObject) {
+                        notifyListeners("onClose", jsonToJSObject(data))
+
+                        val result = JSObject()
+                        result.put("closed", jsonToJSObject(data))
+                        savedCall?.resolve(result)
+                        savedCall = null
+                    }
+
+                    override fun onFinish(data: JSONObject) {
+                        notifyListeners("onFinish", jsonToJSObject(data))
+
+                        val result = JSObject()
+                        result.put("finished", jsonToJSObject(data))
+                        savedCall?.resolve(result)
+                        savedCall = null
+                    }
+
+                    override fun onInteraction(data: JSONObject) {
+                        notifyListeners("onInteraction", jsonToJSObject(data))
+                    }
+
+                    override fun onDataRequest(data: JSONObject) {
+                        notifyListeners("onDataRequest", jsonToJSObject(data))
+                    }
+
+                    override fun onAuthStatusUpdate(data: JSONObject) {
+                        notifyListeners("onAuthStatusUpdate", jsonToJSObject(data))
+                    }
+
+                    override fun onTaskStatusUpdate(data: JSONObject) {
+                        notifyListeners("onTaskStatusUpdate", jsonToJSObject(data))
+                    }
+                })
+            } catch (e: Exception) {
+                call.reject("Failed to present Transact", e)
+                savedCall = null
+            }
+        }
+    }
+
+    @PluginMethod
+    fun presentAction(call: PluginCall) {
+        val id = call.getString("id")
+        if (id == null) {
+            call.reject("id is required")
+            return
+        }
+
+        val environmentObj = call.getObject("environment")
+        val activity = bridge.activity
+        if (activity == null) {
+            call.reject("Activity not available")
+            return
+        }
+
+        savedCall = call
+
+        val (env, envURL) = parseActionEnvironment(environmentObj)
+
+        val config = ActionConfig(
+            id = id,
+            environment = env,
+            environmentURL = envURL
+        )
+
+        activity.runOnUiThread {
+            try {
+                Transact.presentAction(activity, config)
+
+                Transact.registerReceiver(activity, object : TransactBroadcastReceiver() {
+                    override fun onLaunch() {
+                        notifyListeners("onLaunch", JSObject())
+                    }
+
+                    override fun onClose(data: JSONObject) {
+                        notifyListeners("onClose", jsonToJSObject(data))
+
+                        val result = JSObject()
+                        result.put("closed", jsonToJSObject(data))
+                        savedCall?.resolve(result)
+                        savedCall = null
+                    }
+
+                    override fun onFinish(data: JSONObject) {
+                        notifyListeners("onFinish", jsonToJSObject(data))
+
+                        val result = JSObject()
+                        result.put("finished", jsonToJSObject(data))
+                        savedCall?.resolve(result)
+                        savedCall = null
+                    }
+
+                    override fun onAuthStatusUpdate(data: JSONObject) {
+                        notifyListeners("onAuthStatusUpdate", jsonToJSObject(data))
+                    }
+
+                    override fun onTaskStatusUpdate(data: JSONObject) {
+                        notifyListeners("onTaskStatusUpdate", jsonToJSObject(data))
+                    }
+                })
+            } catch (e: Exception) {
+                call.reject("Failed to present action", e)
+                savedCall = null
+            }
+        }
+    }
+
+    @PluginMethod
+    fun hideTransact(call: PluginCall) {
+        val activity = bridge.activity
+        if (activity == null) {
+            call.reject("Activity not available")
+            return
+        }
+
+        activity.runOnUiThread {
+            try {
+                Transact.hideTransact(activity)
+                call.resolve()
+            } catch (e: Exception) {
+                call.reject("Failed to hide Transact", e)
+            }
+        }
+    }
+
+    @PluginMethod
+    fun resolveDataRequest(call: PluginCall) {
+        val activity = bridge.activity
+        if (activity == null) {
+            call.reject("Activity not available")
+            return
+        }
+
+        val cardObj = call.getObject("card")
+        val identityObj = call.getObject("identity")
+
+        var card: Config.TransactDataResponse.CardData? = null
+        if (cardObj != null) {
+            val number = cardObj.getString("number")
+            if (number == null) {
+                call.reject("Card number is required")
+                return
+            }
+            card = Config.TransactDataResponse.CardData(
+                number = number,
+                expiry = cardObj.optStringOrNull("expiry"),
+                cvv = cardObj.optStringOrNull("cvv")
+            )
+        }
+
+        var identity: Config.TransactDataResponse.Identity? = null
+        if (identityObj != null) {
+            identity = Config.TransactDataResponse.Identity(
+                firstName = identityObj.optStringOrNull("firstName"),
+                lastName = identityObj.optStringOrNull("lastName"),
+                postalCode = identityObj.optStringOrNull("postalCode"),
+                address = identityObj.optStringOrNull("address"),
+                address2 = identityObj.optStringOrNull("address2"),
+                city = identityObj.optStringOrNull("city"),
+                state = identityObj.optStringOrNull("state"),
+                phone = identityObj.optStringOrNull("phone"),
+                email = identityObj.optStringOrNull("email")
+            )
+        }
+
+        val response = Config.TransactDataResponse(card = card, identity = identity)
+
+        activity.runOnUiThread {
+            try {
+                Transact.sendData(activity, response)
+                call.resolve()
+            } catch (e: Exception) {
+                call.reject("Failed to send data response", e)
+            }
+        }
+    }
+
+    private fun jsonToJSObject(json: JSONObject): JSObject {
+        return try {
+            JSObject(json.toString())
+        } catch (e: Exception) {
+            JSObject()
+        }
+    }
+
+    private fun JSONObject.optStringOrNull(key: String): String? {
+        return if (has(key) && !isNull(key)) getString(key) else null
+    }
+}