react-native-mesmart 0.4.0

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2024 Ian Langkammer Batista
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,111 @@
+# react-native-mesmart
+
+Sunmi RFID reader and Plugpag wrapper for React Native
+
+## Installation
+
+```sh
+npm install react-native-mesmart
+```
+
+OR
+
+```sh
+yarn add react-native-mesmart
+```
+
+Now, you just need to add that code line below in your build.gradle in your react native application
+
+```
+allprojects {
+  repositories {
+    ...
+    maven {
+      url 'https://github.com/pagseguro/PlugPagServiceWrapper/raw/master'
+    }
+  }
+}
+```
+
+## Usage
+
+```ts
+import {
+  readRfidCardInSunmi,
+  cancelRfidCardSearchInSunmi,
+  initPlugpag,
+  destroyPlugpag,
+  abortPayment,
+  printEstablishmentReceipt,
+  printClientReceipt,
+  customDialogClientViaPrinter,
+  pay,
+  resolveTransactionEvent,
+} from 'react-native-mesmart';
+
+// ...
+
+// Read rfid asynchronously
+const rfid: string = await readRfidCardInSunmi();
+
+// Cancel rfid read
+cancelRfidCardSearchInSunmi();
+
+// Init PlugPag wrapper
+const activationCode: string = '9999999'
+initPlugpag(activationCode)
+
+// Destroy PlugPag instance
+destroyPlugpag()
+
+// Abort payment process
+abortPayment()
+
+// Print establishment receipt
+printEstablishmentReceipt()
+
+// Print client receipt
+printClientReceipt()
+
+// Custom client modal to print receipt
+const color: string = "#000"
+customDialogClientViaPrinter(color)
+
+// Make transaction process with PlugPag wrapper
+const value: string = "2000"                          // In cents, 2000 means R$ 20,00
+const paymentMethod: TransactionTypes = "creditCard"  // TransactionTypes = 'debitCard' | 'creditCard' | 'pix' | 'voucher'
+const result = await pay(value, paymentMethod)
+
+// Return a message based on a PlugPagEvent
+const plugpagEvent: PlugPagEventData = {
+  customMessage: 'customMessage'
+  eventCode: 0                                        // PlugPagEvent
+}
+const message: string = resolveTransactionEvent(plugpagEvent)
+
+// Register event listener to catch onPlugPagEventData
+useEffect(() => {
+  const eventEmitter = new NativeEventEmitter(NativeModules.Plugpag);
+  let eventListener = eventEmitter.addListener(
+    'onPlugPagEventData',
+    (plugpagEvent: PlugPagEventData) => { console.log(plugpagEvent) },
+  );
+
+  return () => {
+    eventListener.remove();
+  };
+}, []);
+
+```
+
+## Contributing
+
+See the [contributing guide](CONTRIBUTING.md) to learn how to contribute to the repository and the development workflow.
+
+## License
+
+MIT
+
+---
+
+Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)

package/android/build.gradle

@@ -0,0 +1,96 @@
+import com.android.Version
+
+buildscript {
+  // Buildscript is evaluated before everything else so we can't use getExtOrDefault
+  def kotlin_version = rootProject.ext.has("kotlinVersion") ? rootProject.ext.get("kotlinVersion") : project.properties["Plugpag_kotlinVersion"]
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:7.4.2"
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+  }
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["Plugpag_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["Plugpag_" + name]).toInteger()
+}
+
+static def supportsNamespace() {
+  def parsed = Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
+  def major = parsed[0].toInteger()
+  def minor = parsed[1].toInteger()
+
+  // Namespace support was added in 7.3.0
+  return (major == 7 && minor >= 3) || major >= 8
+}
+
+android {
+  if (supportsNamespace()) {
+    namespace "com.mesmart"
+
+    sourceSets {
+      main {
+        manifest.srcFile "src/main/AndroidManifestNew.xml"
+      }
+    }
+  }
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_11
+    targetCompatibility JavaVersion.VERSION_11
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+  // if you open in Android Studio, uncomment the line below
+  // but leave it commented cause it bugs the main project build
+   maven { url 'https://github.com/pagseguro/PlugPagServiceWrapper/raw/master' }
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  implementation "com.facebook.react:react-android:0.75.0-rc.5"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation "com.sunmi:PayLib-release:2.0.07"
+  implementation "br.com.uol.pagseguro.plugpagservice.wrapper:wrapper:1.28.2"
+  implementation "com.sunmi:printerlibrary:1.0.23"
+}

package/android/gradle.properties

@@ -0,0 +1,19 @@
+## For more details on how to configure your build environment visit
+# http://www.gradle.org/docs/current/userguide/build_environment.html
+#
+# Specifies the JVM arguments used for the daemon process.
+# The setting is particularly useful for tweaking memory settings.
+# Default value: -Xmx1024m -XX:MaxPermSize=256m
+# org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
+#
+# When configured, Gradle will run in incubating parallel mode.
+# This option should only be used with decoupled projects. For more details, visit
+# https://developer.android.com/r/tools/gradle-multi-project-decoupled-projects
+# org.gradle.parallel=true
+#Fri Jul 19 11:34:20 BRT 2024
+Plugpag_compileSdkVersion=31
+Plugpag_kotlinVersion=1.9.24
+Plugpag_minSdkVersion=23
+Plugpag_ndkversion=21.4.7075529
+Plugpag_targetSdkVersion=31
+android.useAndroidX=true

package/android/src/main/AndroidManifest.xml

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

package/android/src/main/AndroidManifestNew.xml

@@ -0,0 +1,4 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+  <uses-permission android:name="com.sunmi.perm.CONTACTLESS_CARD" />
+  <uses-permission android:name="br.com.uol.pagseguro.permission.MANAGE_PAYMENTS"/>
+</manifest>

package/android/src/main/java/com/mesmart/Packages.kt

@@ -0,0 +1,21 @@
+package com.mesmart
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+import com.plugpag.PlugpagModule
+import com.sunmi.SunmiModule
+
+class Packages : ReactPackage {
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+    return listOf(
+      PlugpagModule(reactContext),
+      SunmiModule(reactContext)
+    )
+  }
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    return emptyList()
+  }
+}

package/android/src/main/java/com/plugpag/PlugpagImpl.kt

@@ -0,0 +1,112 @@
+package com.plugpag
+
+import br.com.uol.pagseguro.plugpagservice.wrapper.PlugPag
+import br.com.uol.pagseguro.plugpagservice.wrapper.PlugPagActivationData
+import br.com.uol.pagseguro.plugpagservice.wrapper.PlugPagCustomPrinterLayout
+import br.com.uol.pagseguro.plugpagservice.wrapper.PlugPagEventData
+import br.com.uol.pagseguro.plugpagservice.wrapper.PlugPagEventListener
+import br.com.uol.pagseguro.plugpagservice.wrapper.PlugPagPaymentData
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.plugpag.utils.PlugpagUtils
+
+class PlugpagImpl(
+  private val reactContext: ReactApplicationContext,
+  val activationCode: String
+) {
+  private val plugPag = PlugPag(reactContext)
+
+  init {
+    setEventListener()
+  }
+
+  private fun setEventListener() {
+    plugPag.setEventListener(object : PlugPagEventListener {
+      override fun onEvent(data: PlugPagEventData) {
+        sendEvent(
+          reactContext,
+          Arguments.createMap().apply {
+            putInt("eventCode", data.eventCode)
+            putString("customMessage", data.customMessage)
+          }
+        )
+      }
+    })
+  }
+
+  private fun sendEvent(
+    reactContext: ReactContext,
+    params: WritableMap?
+  ) {
+    reactContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit("onPlugPagEventData", params)
+  }
+
+  fun pay(
+    rechargeValue: String,
+    transactionType: String,
+    promise: Promise
+  ) {
+    Thread {
+      run {
+        val paymentData = PlugpagUtils.resolveTransactionType(transactionType)?.let {
+          PlugPagPaymentData(
+            it,
+            rechargeValue.toInt(),
+            PlugPag.INSTALLMENT_TYPE_A_VISTA,
+            1,
+            null
+          )
+        }
+
+        val terminalResult = plugPag.initializeAndActivatePinpad(
+          PlugPagActivationData(activationCode)
+        )
+
+        if (terminalResult.result == PlugPag.RET_OK) {
+          val paymentResult = paymentData?.let { plugPag.doPayment(it) }
+          promise.resolve(
+            Arguments.createMap().apply {
+              putString("message", paymentResult?.message)
+              putString("errorCode", paymentResult?.errorCode)
+              paymentResult?.result?.let { putInt("result", it) }
+            }
+          )
+        } else {
+          throw Exception("Error on initialize and activate pinpad. Maybe your activationCode is not valid!")
+        }
+      }
+    }.start()
+  }
+
+  fun abortTransaction() {
+    Thread {
+      run {
+        plugPag.abort()
+      }
+    }.start()
+  }
+
+  fun printEstablishmentReceipt() {
+    plugPag.reprintStablishmentReceipt()
+  }
+
+  fun printClientReceipt() {
+    plugPag.reprintCustomerReceipt()
+  }
+
+  fun customDialogClientViaPrinter(color: String) {
+    Thread {
+      run {
+        val customPrinter = PlugPagCustomPrinterLayout()
+        customPrinter.buttonBackgroundColor = color
+        plugPag.setPlugPagCustomPrinterLayout(customPrinter)
+      }
+    }.start()
+  }
+}

package/android/src/main/java/com/plugpag/PlugpagModule.kt

@@ -0,0 +1,77 @@
+package com.plugpag
+
+import br.com.uol.pagseguro.plugpagservice.wrapper.PlugPagEventData
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import com.plugpag.utils.PlugpagUtils
+
+class PlugpagModule(
+  private val reactContext: ReactApplicationContext
+) : ReactContextBaseJavaModule(reactContext) {
+  private var plugpag: PlugpagImpl? = null
+
+  override fun getName(): String {
+    return "Plugpag"
+  }
+
+  private fun checkPlugpag() {
+    if (plugpag == null)
+      throw Exception("Plugpag is not initiated! Did you use initPlugpag(code: string) method before calling this method?")
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun init(code: String) {
+    if (plugpag != null)
+      throw Exception("Plugpag has already been initiated with code: '" + plugpag!!.activationCode + "'!")
+
+    plugpag = PlugpagImpl(reactContext, code)
+  }
+
+  @ReactMethod
+  fun pay(
+    rechargeValue: String,
+    transactionType: String,
+    promise: Promise
+  ) {
+    try {
+      checkPlugpag()
+      plugpag!!.pay(rechargeValue, transactionType, promise)
+    } catch (e: Exception) {
+     e.printStackTrace()
+     promise.reject(e)
+    }
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun abortPayment() {
+    checkPlugpag()
+    plugpag!!.abortTransaction()
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun printEstablishmentReceipt() {
+    checkPlugpag()
+    plugpag!!.printEstablishmentReceipt()
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun printClientReceipt() {
+    checkPlugpag()
+    plugpag!!.printClientReceipt()
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun customDialogClientViaPrinter(color: String) {
+    checkPlugpag()
+    plugpag!!.customDialogClientViaPrinter(color)
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun resolveTransactionEvent(data: ReadableMap): String {
+    val plugPagEventData = PlugPagEventData(data.getInt("eventCode"))
+    return PlugpagUtils.resolveTransactionEvent(plugPagEventData)
+  }
+}

package/android/src/main/java/com/plugpag/utils/PlugpagUtils.kt

@@ -0,0 +1,40 @@
+package com.plugpag.utils
+
+import br.com.uol.pagseguro.plugpagservice.wrapper.PlugPag
+import br.com.uol.pagseguro.plugpagservice.wrapper.PlugPagEventData
+import br.com.uol.pagseguro.plugpagservice.wrapper.PlugPagEventData.Companion.EVENT_CODE_INSERTED_CARD
+import br.com.uol.pagseguro.plugpagservice.wrapper.PlugPagEventData.Companion.EVENT_CODE_PIN_OK
+import br.com.uol.pagseguro.plugpagservice.wrapper.PlugPagEventData.Companion.EVENT_CODE_REMOVED_CARD
+import br.com.uol.pagseguro.plugpagservice.wrapper.PlugPagEventData.Companion.EVENT_CODE_SALE_APPROVED
+import br.com.uol.pagseguro.plugpagservice.wrapper.PlugPagEventData.Companion.EVENT_CODE_SALE_NOT_APPROVED
+import br.com.uol.pagseguro.plugpagservice.wrapper.PlugPagEventData.Companion.EVENT_CODE_WAITING_CARD
+import br.com.uol.pagseguro.plugpagservice.wrapper.PlugPagEventData.Companion.EVENT_CODE_WAITING_REMOVE_CARD
+
+class PlugpagUtils {
+  companion object {
+    fun resolveTransactionType(type: String): Int? {
+      return when(type) {
+        "debitCard" -> PlugPag.TYPE_DEBITO
+        "creditCard" -> PlugPag.TYPE_CREDITO
+        "voucher" -> PlugPag.TYPE_VOUCHER
+        "pix" -> PlugPag.TYPE_PIX
+        else -> null
+      }
+    }
+    fun resolveTransactionEvent(data : PlugPagEventData): String {
+      return when(data.eventCode) {
+        EVENT_CODE_WAITING_CARD -> "Aproxime ou insira o cartão de pagamento"
+        EVENT_CODE_SALE_APPROVED -> "Processando..."
+        EVENT_CODE_SALE_NOT_APPROVED -> "Processando..."
+        EVENT_CODE_WAITING_REMOVE_CARD -> "Por favor, remova o seu cartão"
+        EVENT_CODE_INSERTED_CARD -> "Processando..."
+        EVENT_CODE_PIN_OK -> "Processando..."
+        EVENT_CODE_REMOVED_CARD -> "Processando..."
+        18 -> "Transação aprovada"
+        17 -> "Informe a senha do seu cartão"
+        4 -> "Processando..."
+        else -> ""
+      }
+    }
+  }
+}

package/android/src/main/java/com/sunmi/SunmiImpl.kt

@@ -0,0 +1,75 @@
+package com.sunmi
+
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.mesmart.R
+import com.sunmi.utils.SunmiPrintHelper
+import com.sunmi.utils.SunmiRfidHelper
+import sunmi.paylib.SunmiPayKernel
+import sunmi.paylib.SunmiPayKernel.ConnectCallback
+
+class SunmiImpl(
+  private val reactContext: ReactApplicationContext
+) {
+  private val payKernel = SunmiPayKernel.getInstance()
+  private lateinit var sunmiRfidHelper: SunmiRfidHelper
+  private lateinit var sunmiPrintHelper: SunmiPrintHelper
+
+  fun bindService() {
+    payKernel.initPaySDK(reactContext, object : ConnectCallback {
+      override fun onConnectPaySDK() {
+        sunmiRfidHelper = SunmiRfidHelper(payKernel)
+        sunmiPrintHelper = SunmiPrintHelper(reactContext)
+      }
+
+      override fun onDisconnectPaySDK() {
+      }
+    })
+  }
+
+  fun searchRfid(promise: Promise) {
+    sunmiRfidHelper.searchRfid(promise)
+  }
+
+  fun cancelCardSearch() {
+    sunmiRfidHelper.cancelCardSearch()
+  }
+
+  fun printText(
+    str: String,
+    fontSize: Int,
+    isBold: Boolean,
+    isUnderline: Boolean
+  ) {
+    sunmiPrintHelper.printText(
+      str,
+      fontSize.toFloat(),
+      isBold,
+      isUnderline,
+      null)
+  }
+
+  fun printEmptyLine() {
+    sunmiPrintHelper.printEmptyLine()
+  }
+
+  fun printBpLogo() {
+    val options = BitmapFactory.Options().apply {
+      inTargetDensity = 160
+      inDensity = 160
+    }
+    val bitmap = BitmapFactory.decodeResource(reactContext.resources, R.drawable.logo_black, options)
+
+    sunmiPrintHelper.printBitmap(
+      Bitmap.createScaledBitmap(bitmap, 375, 100, true),
+      1
+    )
+  }
+
+  fun setPrinterAlign(align: Int) {
+      sunmiPrintHelper.setPrinterAlign(align)
+  }
+}
+

package/android/src/main/java/com/sunmi/SunmiModule.kt

@@ -0,0 +1,75 @@
+package com.sunmi
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.sunmi.utils.SunmiUtils
+
+class SunmiModule(
+  reactContext: ReactApplicationContext
+) : ReactContextBaseJavaModule(reactContext) {
+  private var sunmi: SunmiImpl? = null
+
+  init {
+    if (SunmiUtils.isSunmiP2()) {
+      sunmi = SunmiImpl(reactContext)
+      sunmi!!.bindService()
+    }
+  }
+
+  override fun getName(): String {
+    return "Sunmi"
+  }
+
+  private fun checkSunmi() {
+    if (sunmi == null)
+      throw Exception("Sunmi is null! You may not working in a Sunmi P2 or an error ocurred during the initialization!")
+  }
+
+  @ReactMethod
+  fun searchRfid(promise: Promise) {
+    try {
+      checkSunmi()
+      this.sunmi!!.searchRfid(promise)
+    } catch (e: Exception) {
+      e.printStackTrace()
+      promise.reject(e)
+    }
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun cancelCardSearch() {
+    checkSunmi()
+    this.sunmi!!.cancelCardSearch()
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun printText(
+    str: String,
+    fontSize: Int,
+    isBold: Boolean,
+    isUnderline: Boolean
+  ) {
+    checkSunmi()
+    this.sunmi!!.printText(str, fontSize, isBold, isUnderline)
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun printEmptyLine() {
+    checkSunmi()
+    sunmi!!.printEmptyLine()
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun printBpLogo() {
+    checkSunmi()
+    sunmi!!.printBpLogo()
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun setPrinterAlign(align: Int) {
+    checkSunmi()
+    sunmi!!.setPrinterAlign(align)
+  }
+}