@appboxo/expo-boxo-sdk 0.1.0

package/.eslintrc.js

@@ -0,0 +1,5 @@
+module.exports = {
+  root: true,
+  extends: ['universe/native', 'universe/web'],
+  ignorePatterns: ['build'],
+};

package/README.md

@@ -0,0 +1,242 @@
+# expo-boxo-sdk
+
+Expo wrapper over Appboxo SDK for IOS and Android.
+
+## Install
+
+```bash
+npm install @appboxo/expo-boxo-sdk
+```
+
+## API
+
+* [`setConfig(...)`](#setconfig)
+* [`openMiniapp(...)`](#openminiapp)
+* [`setAuthCode(...)`](#setauthcode)
+* [`closeMiniapp(...)`](#closeminiapp)
+* [`sendCustomEvent(...)`](#sendcustomevent)
+* [`sendPaymentEvent(...)`](#sendpaymentevent)
+* [`getMiniapps()`](#getminiapps)
+* [`hideMiniapps()`](#hideminiapps)
+* [`logout()`](#logout)
+* [`addAuthListener( ...)`](#AuthListener)
+* [`addCustomEventListener()`](#CustomEventListener)
+* [`addPaymentEventListener()`](#PaymentEventListener)
+* [`addMiniappLifecycleListener()`](#MiniappLifecycleListener)
+* [`addMiniappListListener()`](#MiniappListListener)
+
+### setConfig(...)
+
+```typescript
+setConfig(options: ConfigOptions)
+```
+
+Set global configs
+
+| Prop                      | Type                                       | Description                                                                              |
+|---------------------------| ------------------------------------------ | ---------------------------------------------------------------------------------------- |
+| **`clientId`**            | <code>string</code>                        | your client id from dashboard                                                            |
+| **`userId`**              | <code>string</code>                        | hostapp userId, will be used for the Consent Management                                  |
+| **`sandboxMode`**         | <code>boolean</code>                       | switch to sandbox mode                                                                   |
+| **`multitaskMode`**       | <code>boolean</code>                       | Each miniapp appears as a task in the Recents screen. !It works only on android devices. |
+| **`theme`**               | <code>'light' \| 'dark' \| 'system'</code> | theme for splash screen and other native components used inside miniapp.                 |
+| **`isDebug`**             | <code>boolean</code>                       | enables webview debugging                                                                |
+| **`showPermissionsPage`** | <code>boolean</code>                       | use it to hide "Settings" from Miniapp menu                                              |
+| **`showClearCache`**      | <code>boolean</code>                       | use it to hide "Clear cache" from Miniapp menu                                           |
+
+
+--------------------
+
+
+### openMiniapp(...)
+
+```typescript
+openMiniapp(options: MiniappOptions)
+```
+
+Open miniapp with options
+
+| Prop                 | Type                                       | Description                                                                                       |
+| -------------------- |--------------------------------------------| ------------------------------------------------------------------------------------------------- |
+| **`appId`**          | <code>string</code>                        | miniapp id                                                                                        |
+| **`data`**           | <code>Record<string, any></code>           | (optional) data as Map that is sent to miniapp                                                    |
+| **`theme`**          | <code>'light' \| 'dark' \| 'system'</code> | (optional) miniapp theme "dark" \| "light" (by default is system theme)                           |
+| **`extraUrlParams`** | <code>Record<string, string></code>        | (optional) extra query params to append to miniapp URL (like: http://miniapp-url.com/?param=test) |
+| **`urlSuffix`**      | <code>string</code>                        | (optional) suffix to append to miniapp URL (like: http://miniapp-url.com/?param=test)             |
+| **`colors`**         | <code>Record<string, string></code>        | (optional) provide colors to miniapp if miniapp supports                                          |
+| **`enableSplash`**   | <code>boolean</code>                       | (optional) use to skip miniapp splash screen                                                      |
+
+Color options 
+
+| Prop                 | Type                |
+| -------------------- | ------------------- |
+| **`primaryColor`**   | <code>string</code> |
+| **`secondaryColor`** | <code>string</code> |
+| **`tertiaryColor`**  | <code>string</code> |
+
+--------------------
+
+
+### setAuthCode(...)
+
+```typescript
+setAuthCode(appId: string, authCode: string)
+```
+
+get AuthCode from hostapp backend and send it to miniapp
+
+--------------------
+
+
+### closeMiniapp(...)
+
+```typescript
+closeMiniapp(appId: string)
+```
+
+close miniapp by appId
+
+--------------------
+
+
+### sendCustomEvent(...)
+
+```typescript
+sendCustomEvent(customEventData: CustomEventData)
+```
+
+send custom event to miniapp
+
+| Prop            | Type                |
+| --------------- | ------------------- |
+| **`appId`**     | <code>string</code> |
+| **`requestId`** | <code>number</code> |
+| **`type`**      | <code>string</code> |
+| **`errorType`** | <code>string</code> |
+| **`payload`**   | <code>object</code> |
+
+
+--------------------
+
+
+### sendPaymentEvent(...)
+
+```typescript
+sendPaymentEvent(paymentData: PaymentData)
+```
+
+send payment data to miniapp
+
+| Prop                   | Type                |
+| ---------------------- | ------------------- |
+| **`appId`**            | <code>string</code> |
+| **`transactionToken`** | <code>string</code> |
+| **`miniappOrderId`**   | <code>string</code> |
+| **`amount`**           | <code>number</code> |
+| **`currency`**         | <code>string</code> |
+| **`status`**           | <code>string</code> |
+| **`hostappOrderId`**   | <code>string</code> |
+| **`extraParams`**      | <code>object</code> |
+
+
+--------------------
+
+
+### getMiniapps()
+
+```typescript
+getMiniapps()
+```
+Get list of miniapps. To get results subscribe to
+* [`addMiniappListListener()`](#MiniappListListener)
+--------------------
+
+
+### hideMiniapps()
+
+```typescript
+hideMiniapps()
+```
+
+Miniapp opens on a native screen. To show payment processing page need to hide miniapp screen.
+To use this function need to enable 'enableMultitaskMode: true' in Appboxo.setConfigs()
+
+--------------------
+
+### logout()
+
+```typescript
+logout()
+```
+When host app user logs out, it is highly important to clear all miniapp storage data.
+
+--------------------
+
+#### AuthListener
+
+```typescript
+Boxo.addAuthListener((authEvent) => {
+    Boxo.setAuthCode(authEvent.appId, authCode)
+});
+```
+
+#### CustomEventListener
+
+```typescript
+Boxo.addCustomEventListener((customEvent) => {
+  ..handle custom event
+});
+```
+
+#### PaymentEventListener
+
+```typescript
+Boxo.addPaymentEventListener((paymentData) => {
+  Boxo.hideMiniapps();
+  .. show payment page
+  paymentData.status = "success";
+  ..confirm payment
+  Boxo.sendPaymentEvent(paymentData);
+  Boxo.openMiniapp({ appId: paymentData.appId })
+});
+```
+
+#### MiniappLifecycleListener
+
+```typescript
+Boxo.addMiniappLifecycleListener((lifecycleData) => {
+  console.log(lifecycleData);
+});
+```
+
+| Prop            | Type                | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| --------------- | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **`appId`**     | <code>string</code> |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| **`lifecycle`** | <code>string</code> | onLaunch - Called when the miniapp will launch with Appboxo.open(...) onResume - Called when the miniapp will start interacting with the user onPause - Called when the miniapp loses foreground state onClose - Called when clicked close button in miniapp or when destroyed miniapp page onError - Called when miniapp fails to launch due to internet connection issues onUserInteraction - Called whenever touch event is dispatched to the miniapp page. onAuth - Called when the miniapp starts login and user allows it |
+| **`error`**     | <code>string</code> |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+
+
+#### MiniappListListener
+
+```typescript
+Boxo.addMiniappListListener((result) => {
+  console.log(result.miniapps);
+});
+```
+
+Get miniapp list
+
+| Prop           | Type                       |
+| -------------- | -------------------------- |
+| **`miniapps`** | <code>[MiniappData]</code> |
+| **`error`**    | <code>string</code>        |
+
+MiniappData
+
+| Prop              | Type                |
+| ----------------- | ------------------- |
+| **`appId`**       | <code>string</code> |
+| **`name`**        | <code>string</code> |
+| **`category`**    | <code>string</code> |
+| **`description`** | <code>string</code> |
+| **`logo`**        | <code>string</code> |

package/android/build.gradle

@@ -0,0 +1,63 @@
+apply plugin: 'com.android.library'
+
+group = 'io.boxo.expo'
+version = '0.1.0'
+
+def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
+apply from: expoModulesCorePlugin
+applyKotlinExpoModulesCorePlugin()
+useCoreDependencies()
+useExpoPublishing()
+
+// If you want to use the managed Android SDK versions from expo-modules-core, set this to true.
+// The Android SDK versions will be bumped from time to time in SDK releases and may introduce breaking changes in your module code.
+// Most of the time, you may like to manage the Android SDK versions yourself.
+def useManagedAndroidSdkVersions = false
+if (useManagedAndroidSdkVersions) {
+    useDefaultAndroidSdkVersions()
+} else {
+    buildscript {
+        // Simple helper that allows the root project to override versions declared by this library.
+        ext.safeExtGet = { prop, fallback ->
+            rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+        }
+    }
+    project.android {
+        compileSdkVersion safeExtGet("compileSdkVersion", 34)
+        defaultConfig {
+            minSdkVersion safeExtGet("minSdkVersion", 21)
+            targetSdkVersion safeExtGet("targetSdkVersion", 34)
+        }
+    }
+}
+
+rootProject.allprojects {
+    repositories {
+        google()
+        mavenCentral()
+        maven { url "https://jitpack.io" }
+        maven {
+            url "https://maven.pkg.github.com/Appboxo/android-sdk-packages"
+            credentials {
+                username = "appboxoandroidsdk"
+                password = "\u0037\u0039\u0064\u0031\u0065\u0064\u0061\u0036\u0030\u0034\u0063\u0061\u0031\u0066\u0030\u0032\u0066\u0031\u0037\u0066\u0032\u0061\u0039\u0033\u0064\u0035\u0039\u0039\u0061\u0035\u0035\u0062\u0066\u0065\u0031\u0064\u0066\u0064\u0038\u0038"
+            }
+        }
+    }
+}
+
+android {
+    namespace "io.boxo.expo"
+    defaultConfig {
+        versionCode 1
+        versionName "0.1.0"
+    }
+    lintOptions {
+        abortOnError false
+    }
+}
+dependencies {
+    implementation('com.appboxo:sdk:1.5.18') {
+        exclude group: 'com.google.android.gms', module: 'play-services-location'
+    }
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest>
+</manifest>

package/android/src/main/java/io/boxo/expo/ConfigOptions.kt

@@ -0,0 +1,33 @@
+package io.boxo.expo
+
+import expo.modules.kotlin.records.Field
+import expo.modules.kotlin.records.Record
+
+class ConfigOptions : Record {
+    @Field
+    val clientId: String = ""
+
+    @Field
+    val userId: String = ""
+
+    @Field
+    val language: String = "en"
+
+    @Field
+    val sandboxMode: Boolean = false
+
+    @Field
+    val multitaskMode: Boolean = false
+
+    @Field
+    val theme: String = "system"
+
+    @Field
+    val isDebug: Boolean = false
+
+    @Field
+    val showPermissionsPage: Boolean = true
+
+    @Field
+    val showClearCache: Boolean = true
+}

package/android/src/main/java/io/boxo/expo/CustomEventData.kt

@@ -0,0 +1,21 @@
+package io.boxo.expo
+
+import expo.modules.kotlin.records.Field
+import expo.modules.kotlin.records.Record
+
+class CustomEventData : Record {
+    @Field
+    val appId: String = ""
+
+    @Field
+    val requestId: Int? = null
+
+    @Field
+    val type: String? = null
+
+    @Field
+    val errorType: String? = null
+
+    @Field
+    val payload: Map<String, Any>? = null
+}

package/android/src/main/java/io/boxo/expo/ExpoBoxoSdkModule.kt

@@ -0,0 +1,231 @@
+package io.boxo.expo
+
+import android.os.Handler
+import android.os.Looper
+import com.appboxo.data.models.MiniappData
+import com.appboxo.js.params.CustomEvent
+import com.appboxo.js.params.PaymentData
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import expo.modules.kotlin.Promise
+import com.appboxo.sdk.*
+
+class ExpoBoxoSdkModule : Module() {
+    private var handler: Handler? = null
+
+    override fun definition() = ModuleDefinition {
+        Name("ExpoBoxoSdk")
+
+        handler = Handler(Looper.getMainLooper())
+
+        Events("customEvent", "paymentEvent", "miniappLifecycle", "onAuth", "miniappList")
+
+        Function("setConfig") { options: ConfigOptions ->
+            val globalTheme: Config.Theme = when (options.theme) {
+                "light" -> Config.Theme.LIGHT
+                "dark" -> Config.Theme.DARK
+                else -> Config.Theme.SYSTEM
+            }
+            Appboxo.init(appContext.activityProvider!!.currentActivity.application)
+                .setConfig(
+                    Config.Builder()
+                        .setClientId(options.clientId)
+                        .setUserId(options.userId)
+                        .sandboxMode(options.sandboxMode)
+                        .multitaskMode(options.multitaskMode)
+                        .setTheme(globalTheme)
+                        .setLanguage(options.language)
+                        .permissionsPage(options.showPermissionsPage)
+                        .showClearCache(options.showClearCache)
+                        .debug(options.isDebug)
+                        .build()
+                )
+        }
+
+        Function("openMiniapp") { options: MiniappOptions ->
+            val miniapp: Miniapp = Appboxo.getMiniapp(options.appId)
+                .setCustomEventListener { _, miniapp, customEvent ->
+                    sendEvent(
+                        "customEvent", mapOf(
+                            "appId" to miniapp.appId,
+                            "requestId" to customEvent.requestId,
+                            "type" to customEvent.type,
+                            "errorType" to customEvent.errorType,
+                            "payload" to customEvent.payload,
+                        )
+                    )
+                }
+                .setPaymentEventListener { _, miniapp, paymentData ->
+                    sendEvent(
+                        "paymentEvent", mapOf(
+                            "appId" to miniapp.appId,
+                            "transactionToken" to paymentData.transactionToken,
+                            "miniappOrderId" to paymentData.miniappOrderId,
+                            "amount" to paymentData.amount,
+                            "currency" to paymentData.currency,
+                            "extraParams" to paymentData.extraParams,
+                            "hostappOrderId" to paymentData.hostappOrderId,
+                            "status" to paymentData.status,
+                        )
+                    )
+                }
+                .setAuthListener { _, miniapp ->
+                    sendEvent("onAuth", mapOf("appId" to miniapp.appId))
+                }
+                .setLifecycleListener(object : Miniapp.LifecycleListener {
+                    override fun onClose(miniapp: Miniapp) {
+                        sendEvent(
+                            "miniappLifecycle", mapOf(
+                                "appId" to miniapp.appId,
+                                "lifecycle" to "onClose"
+                            )
+                        )
+                    }
+
+                    override fun onError(miniapp: Miniapp, message: String) {
+                        sendEvent(
+                            "miniappLifecycle", mapOf(
+                                "appId" to miniapp.appId,
+                                "lifecycle" to "onError",
+                                "error" to message
+                            )
+                        )
+                    }
+
+                    override fun onLaunch(miniapp: Miniapp) {
+                        sendEvent(
+                            "miniappLifecycle", mapOf(
+                                "appId" to miniapp.appId,
+                                "lifecycle" to "onLaunch"
+                            )
+                        )
+                    }
+
+                    override fun onPause(miniapp: Miniapp) {
+                        sendEvent(
+                            "miniappLifecycle", mapOf(
+                                "appId" to miniapp.appId,
+                                "lifecycle" to "onPause"
+                            )
+                        )
+                    }
+
+                    override fun onResume(miniapp: Miniapp) {
+                        sendEvent(
+                            "miniappLifecycle", mapOf(
+                                "appId" to miniapp.appId,
+                                "lifecycle" to "onResume"
+                            )
+                        )
+                    }
+
+                    override fun onUserInteraction(miniapp: Miniapp) {
+                        sendEvent(
+                            "miniappLifecycle", mapOf(
+                                "appId" to miniapp.appId,
+                                "lifecycle" to "onUserInteraction"
+                            )
+                        )
+                    }
+                })
+            if (options.data != null) miniapp.setData(options.data)
+            val configBuilder = MiniappConfig.Builder()
+            if (options.theme != null) {
+                val miniappTheme: Config.Theme? = when (options.theme) {
+                    "light" -> Config.Theme.LIGHT
+                    "dark" -> Config.Theme.DARK
+                    "system" -> Config.Theme.SYSTEM
+                    else -> null
+                }
+                if (miniappTheme != null) {
+                    configBuilder.setTheme(miniappTheme)
+                }
+            }
+            options.extraUrlParams?.also { extraUrlParams ->
+                val stringMap: MutableMap<String, String> = HashMap()
+                for ((key, value) in extraUrlParams) stringMap[key] = value.toString()
+                configBuilder.setExtraUrlParams(stringMap)
+            }
+            options.urlSuffix?.also { suffix -> configBuilder.setUrlSuffix(suffix) }
+            options.colors?.also { colors ->
+                configBuilder.setColors(
+                    colors["primaryColor"] ?: "",
+                    colors["secondaryColor"] ?: "",
+                    colors["tertiaryColor"] ?: "",
+                )
+            }
+            configBuilder.enableSplash(options.enableSplash)
+            configBuilder.saveState(options.saveState)
+            miniapp.setConfig(configBuilder.build())
+            miniapp.open(appContext.currentActivity!!)
+        }
+
+        Function("setAuthCode") { appId: String, authCode: String ->
+            Appboxo.getMiniapp(appId)
+                .setAuthCode(authCode)
+        }
+
+        Function("sendCustomEvent") { customEvent: CustomEventData ->
+            handler?.post {
+                Appboxo.getMiniapp(customEvent.appId)
+                    .sendEvent(
+                        CustomEvent(
+                            requestId = customEvent.requestId,
+                            type = customEvent.type ?: "",
+                            errorType = customEvent.errorType,
+                            payload = customEvent.payload ?: emptyMap()
+                        )
+                    )
+            }
+        }
+
+        Function("sendPaymentEvent") { paymentEvent: PaymentEventData ->
+            handler?.post {
+                Appboxo.getMiniapp(paymentEvent.appId)
+                    .sendPaymentResult(
+                        PaymentData(
+                            transactionToken = paymentEvent.transactionToken ?: "",
+                            miniappOrderId = paymentEvent.miniappOrderId ?: "",
+                            amount = paymentEvent.amount ?: 0.0,
+                            currency = paymentEvent.currency ?: "",
+                            status = paymentEvent.status ?: "",
+                            hostappOrderId = paymentEvent.hostappOrderId ?: "",
+                            extraParams = paymentEvent.extraParams
+                        )
+                    )
+            }
+        }
+
+        Function("closeMiniapp") { appId: String ->
+            Appboxo.getExistingMiniapp(appId)?.close()
+        }
+
+        Function("hideMiniapps") {
+            Appboxo.hideMiniapps()
+        }
+
+        Function("logout") {
+            Appboxo.logout()
+        }
+
+        Function("getMiniapps") {
+            Appboxo.getMiniapps(object : MiniappListCallback {
+                override fun onFailure(e: Exception) {
+                    sendEvent("miniappList", mapOf("error" to e.toString()))
+                }
+
+                override fun onSuccess(miniapps: List<MiniappData>) {
+                    sendEvent("miniappList", mapOf("miniapps" to miniapps.map {
+                        mapOf(
+                            "name" to it.name,
+                            "description" to it.description,
+                            "appId" to it.appId,
+                            "logo" to it.logo,
+                            "category" to it.category,
+                        )
+                    }))
+                }
+            })
+        }
+    }
+}

package/android/src/main/java/io/boxo/expo/MiniappOptions.kt

@@ -0,0 +1,30 @@
+package io.boxo.expo
+
+import expo.modules.kotlin.records.Field
+import expo.modules.kotlin.records.Record
+
+class MiniappOptions : Record {
+    @Field
+    val appId: String = ""
+
+    @Field
+    val data: Map<String, Any>? = null
+
+    @Field
+    val theme: String? = null
+
+    @Field
+    val extraUrlParams: Map<String, Any>? = null
+
+    @Field
+    val urlSuffix: String? = null
+
+    @Field
+    val colors: Map<String, String>? = null
+
+    @Field
+    val enableSplash: Boolean = true
+
+    @Field
+    val saveState: Boolean = true
+}

package/android/src/main/java/io/boxo/expo/PaymentEventData.kt

@@ -0,0 +1,30 @@
+package io.boxo.expo
+
+import expo.modules.kotlin.records.Field
+import expo.modules.kotlin.records.Record
+
+class PaymentEventData : Record {
+    @Field
+    val appId: String = ""
+
+    @Field
+    val transactionToken: String? = null
+
+    @Field
+    val miniappOrderId: String? = null
+
+    @Field
+    val currency: String? = null
+
+    @Field
+    val amount: Double? = null
+
+    @Field
+    val hostappOrderId: String? = null
+
+    @Field
+    val status: String? = null
+
+    @Field
+    val extraParams: Map<String, Any>? = null
+}