react-native-mesmart 3.0.1 → 3.1.0

package/android/build.gradle

@@ -59,6 +59,7 @@ android {
   defaultConfig {
     minSdkVersion getExtOrIntegerDefault("minSdkVersion")
     targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    consumerProguardFiles "consumer-rules.pro"
   }
 
   buildTypes {
@@ -88,9 +89,10 @@ android {
 }
 
 repositories {
+  // local.properties e opcional (no EAS nao existe; o token vem da env var).
   def localProp = new Properties()
-  def fileName = 'local.properties'
-  localProp.load(new FileInputStream(rootProject.file(fileName)))
+  def localPropFile = rootProject.file('local.properties')
+  if (localPropFile.exists()) localPropFile.withInputStream { localProp.load(it) }
   def stoneToken = System.env.PACKAGECLOUD_READ_TOKEN != null ? System.env.PACKAGECLOUD_READ_TOKEN : localProp["packageCloudReadToken"] ?: ""
 
   mavenCentral()

package/android/consumer-rules.pro

@@ -0,0 +1,2 @@
+# Interface trocada com o dex do SDK Gertec Neo (assets/gertec-neo): nao pode ser renomeada nem ter metodos removidos.
+-keep class com.gertec.backend.** { *; }

package/android/src/main/assets/gertec-neo/VERSION

@@ -0,0 +1 @@
+2.0.10-b12dc1dd8256

package/android/src/main/java/com/gertec/GertecImpl.kt

@@ -1,8 +1,15 @@
 package com.gertec
 
+import android.util.Log
 import br.com.gertec.gedi.GEDI
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
+import java.util.concurrent.ExecutionException
+import java.util.concurrent.Executors
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.TimeoutException
+import com.gertec.backend.GertecBackend
+import com.gertec.backend.GertecCallback
 import com.gertec.utils.MifareGPOS780
 import com.gertec.utils.PrinterGPOS780
 import com.mesmart.Utils
@@ -12,42 +19,124 @@ class GertecImpl(
 ) {
   private val isSupported = Utils.isGPOS780()
 
+  // GPOS780S usa o SDK Gertec Neo (libgedi 2.x), carregado a parte; os demais GPOS780 seguem na libgedi 1.16.
+  private val useNeo = Utils.isGPOS780S()
+
   @Volatile private var mifare: MifareGPOS780? = null
   @Volatile private var printer: PrinterGPOS780? = null
+  private var neo: GertecBackend? = null
+  private var neoError: Throwable? = null
+
+  // Falha no init da GEDI (ex.: libgedi.so incompativel com o Android do aparelho) nao pode derrubar o modulo:
+  // fica guardada e volta como erro legivel em cada chamada.
+  private var initError: Throwable? = null
 
   init {
-    if (isSupported) {
-      GEDI.init(reactContext.applicationContext)
+    if (isSupported && !useNeo) {
+      try {
+        GEDI.init(reactContext.applicationContext)
+      } catch (t: Throwable) {
+        initError = t
+        Log.e(TAG, "GEDI.init failed: ${t.javaClass.name}: ${t.message} (${Utils.deviceContext()})", t)
+      }
+    }
+  }
+
+  private fun checkSupported() {
+    if (!isSupported) throw Exception("Unsupported device (Supported models GPOS780, GPOS780S). ${Utils.deviceContext()}")
+    initError?.let {
+      throw Exception("GEDI init failed: ${it.javaClass.name}: ${it.message} (${Utils.deviceContext()})", it)
+    }
+  }
+
+  // GEDI.init() sobe a instancia numa thread e engole falhas; a lib de RFID le GEDI.getInstance() sem argumento
+  // e leva NPE se ainda for null. getInstance(context) cria de forma sincrona e deixa a causa real subir,
+  // com timeout p/ nao travar a fila de modulos nativos caso o init fique pendurado (visto na GPOS780S).
+  private fun ensureGedi() {
+    if (GEDI.getInstance() != null) return
+    val executor = Executors.newSingleThreadExecutor()
+    try {
+      executor.submit<Any?> { GEDI.getInstance(reactContext.applicationContext) }.get(GEDI_INIT_TIMEOUT_S, TimeUnit.SECONDS)
+    } catch (e: TimeoutException) {
+      throw Exception("GEDI init timeout (${GEDI_INIT_TIMEOUT_S}s) (${Utils.deviceContext()})", e)
+    } catch (e: ExecutionException) {
+      val cause = e.cause ?: e
+      throw Exception("GEDI init failed: ${cause.javaClass.name}: ${cause.message} (${Utils.deviceContext()})", cause)
+    } finally {
+      executor.shutdownNow()
+    }
+    if (GEDI.getInstance() == null) {
+      throw Exception("GEDI instance is null after init (${Utils.deviceContext()})")
     }
   }
 
   @Synchronized
   private fun ensureMifare(): MifareGPOS780 {
-    if (!isSupported) throw Exception("Unsupported device (Supported models GPOS780, GPOS780S).")
+    checkSupported()
+    ensureGedi()
     if (mifare == null) mifare = MifareGPOS780()
     return mifare!!
   }
 
   @Synchronized
   private fun ensurePrinter(): PrinterGPOS780 {
-    if (!isSupported) throw Exception("Unsupported device (Supported models GPOS780, GPOS780S).")
+    checkSupported()
     if (printer == null) printer = PrinterGPOS780(reactContext)
     return printer!!
   }
 
+  // Carga preguicosa: so a GPOS780S paga o custo de extrair o dex/.so da Neo, e a falha vira erro legivel por chamada.
+  @Synchronized
+  private fun ensureNeo(): GertecBackend {
+    neo?.let { return it }
+    neoError?.let { throw neoLoadException(it) }
+    return try {
+      NeoSdkLoader.load(reactContext.applicationContext).also { neo = it }
+    } catch (t: Throwable) {
+      neoError = t
+      Log.e(TAG, "Gertec Neo SDK load failed: ${t.javaClass.name}: ${t.message} (${Utils.deviceContext()})", t)
+      throw neoLoadException(t)
+    }
+  }
+
+  private fun neoLoadException(t: Throwable) =
+    Exception("Gertec Neo SDK load failed: ${t.javaClass.name}: ${t.message} (${Utils.deviceContext()})", t)
+
+  private fun neoCallback(promise: Promise, transform: (Any?) -> Any? = { it }) = object : GertecCallback {
+    override fun resolve(value: Any?) {
+      try {
+        promise.resolve(transform(value))
+      } catch (t: Throwable) {
+        promise.reject("GERTEC_RFID_ERROR", t.message, t)
+      }
+    }
+
+    override fun reject(code: String, message: String?, cause: Throwable?) {
+      if (cause != null) promise.reject(code, message, cause) else promise.reject(code, message)
+    }
+  }
+
   fun scanRfid(promise: Promise) {
     try {
+      if (useNeo) {
+        ensureNeo().scanRfid(neoCallback(promise) { Utils.resolveRFID(Utils.byteArrayToHexString(it as ByteArray)) })
+        return
+      }
       ensureMifare().scanRfid(promise)
     } catch (t: Throwable) {
-      promise.reject(t)
+      promise.reject("GERTEC_RFID_ERROR", t.message, t)
     }
   }
 
   fun cancelScan(promise: Promise) {
     try {
+      if (useNeo) {
+        ensureNeo().cancelScan(neoCallback(promise))
+        return
+      }
       ensureMifare().cancelScan(promise)
     } catch (t: Throwable) {
-      promise.reject(t)
+      promise.reject("GERTEC_RFID_ERROR", t.message, t)
     }
   }
 
@@ -55,13 +144,34 @@ class GertecImpl(
     lines: Int,
     promise: Promise
   ) {
-    ensurePrinter().scrollPaper(lines, promise)
+    try {
+      if (useNeo) {
+        ensureNeo().scrollPrinterPaper(lines, neoCallback(promise))
+        return
+      }
+      ensurePrinter().scrollPaper(lines, promise)
+    } catch (t: Throwable) {
+      promise.reject("GERTEC_PRINTER_ERROR", t.message, t)
+    }
   }
 
   fun printHtml(
     html: String,
     promise: Promise
   ) {
-    ensurePrinter().printHtml(html, promise)
+    try {
+      if (useNeo) {
+        ensureNeo().printHtml(html, neoCallback(promise))
+        return
+      }
+      ensurePrinter().printHtml(html, promise)
+    } catch (t: Throwable) {
+      promise.reject("GERTEC_PRINTER_ERROR", t.message, t)
+    }
+  }
+
+  private companion object {
+    const val TAG = "MeSmartGertec"
+    const val GEDI_INIT_TIMEOUT_S = 5L
   }
 }

package/android/src/main/java/com/gertec/GertecModule.kt

@@ -18,7 +18,7 @@ class GertecModule(
   fun scanRfid(promise: Promise) {
     try {
       gertec.scanRfid(promise)
-    } catch (e: Exception) {
+    } catch (e: Throwable) {
       e.printStackTrace()
       promise.reject(e)
     }
@@ -28,7 +28,7 @@ class GertecModule(
   fun cancelScan(promise: Promise) {
     try {
       gertec.cancelScan(promise)
-    } catch (e: Exception) {
+    } catch (e: Throwable) {
       e.printStackTrace()
       promise.reject(e)
     }
@@ -41,7 +41,7 @@ class GertecModule(
   ) {
     try {
       gertec.scrollPrinterPaper(lines, promise)
-    } catch (e: Exception) {
+    } catch (e: Throwable) {
       e.printStackTrace()
       promise.reject(e)
     }
@@ -54,7 +54,7 @@ class GertecModule(
   ) {
     try {
       gertec.printHtml(html, promise)
-    } catch (e: Exception) {
+    } catch (e: Throwable) {
       e.printStackTrace()
       promise.reject(e)
     }

package/android/src/main/java/com/gertec/NeoSdkLoader.kt

@@ -0,0 +1,94 @@
+package com.gertec
+
+import android.content.Context
+import android.os.Process
+import com.gertec.backend.GertecBackend
+import dalvik.system.BaseDexClassLoader
+import dalvik.system.DexClassLoader
+import java.io.File
+
+/**
+ * Carrega o SDK Gertec Neo (libgedi 2.x) num classloader proprio, so na GPOS780S.
+ *
+ * O app usa a libgedi 1.16 nos demais POS e as duas tem as mesmas classes e o mesmo libgedi.so (JNI por nome,
+ * entao nao da p/ renomear pacote), por isso a Neo vai num dex a parte (assets/gertec-neo, ver gertec-neo/build.sh)
+ * e o libgedi.so dela fica fora de jniLibs, extraido p/ uma pasta que so esse classloader enxerga.
+ */
+internal object NeoSdkLoader {
+  private const val ASSET_DIR = "gertec-neo"
+  private const val ADAPTER_CLASS = "com.gertec.neo.NeoGertecBackend"
+
+  @Synchronized
+  fun load(context: Context): GertecBackend {
+    val abi = if (Process.is64Bit()) "arm64-v8a" else "armeabi-v7a"
+    val assets = context.assets
+    val version = assets.open("$ASSET_DIR/VERSION").bufferedReader().use { it.readText().trim() }
+
+    val root = File(context.codeCacheDir, "$ASSET_DIR/$version-$abi")
+    val jar = File(root, "neo-bridge.jar")
+    val libDir = File(root, "lib")
+    val so = File(libDir, "libgedi.so")
+
+    if (!jar.exists() || !so.exists()) {
+      File(context.codeCacheDir, ASSET_DIR).deleteRecursively()
+      libDir.mkdirs()
+      copyAsset(context, "$ASSET_DIR/neo-bridge.jar", jar)
+      copyAsset(context, "$ASSET_DIR/$abi/libgedi.so", so)
+    }
+    // Android 14+ recusa dex gravavel em DexClassLoader.
+    jar.setReadOnly()
+
+    val parent = GertecBackend::class.java.classLoader
+      ?: throw IllegalStateException("Sem classloader do app para o SDK Gertec Neo")
+    val loader = ChildFirstDexClassLoader(jar.absolutePath, libDir.absolutePath, parent)
+    val adapter = loader.loadClass(ADAPTER_CLASS)
+    return adapter.getConstructor(Context::class.java).newInstance(context.applicationContext) as GertecBackend
+  }
+
+  private fun copyAsset(context: Context, assetPath: String, dest: File) {
+    context.assets.open(assetPath).use { input ->
+      dest.outputStream().use { output -> input.copyTo(output) }
+    }
+  }
+}
+
+/**
+ * Classloader "filho primeiro": as classes do dex da Neo (br.com.gertec.*, gedi.*, ...) tem o mesmo nome das da 1.16
+ * que estao no app, entao procura no dex antes de perguntar ao pai. Plataforma, Kotlin, React Native e a interface
+ * com.gertec.backend continuam vindo do pai, para os tipos trocados entre os dois lados serem os mesmos.
+ */
+internal class ChildFirstDexClassLoader(
+  dexPath: String,
+  libPath: String,
+  parent: ClassLoader
+) : DexClassLoader(dexPath, null, libPath, parent) {
+
+  override fun loadClass(name: String, resolve: Boolean): Class<*> {
+    synchronized(this) {
+      findLoadedClass(name)?.let { return it }
+      if (!isShared(name)) {
+        try {
+          val clazz = findClass(name)
+          if (resolve) resolveClass(clazz)
+          return clazz
+        } catch (_: ClassNotFoundException) {
+          // nao esta no dex da Neo: cai no pai
+        }
+      }
+      return super.loadClass(name, resolve)
+    }
+  }
+
+  // O libgedi.so da Neo tem que vir daqui (nao da 1.16 do app); o resto (ex.: opencv) pode vir do pai.
+  override fun findLibrary(name: String): String? =
+    super.findLibrary(name) ?: (parent as? BaseDexClassLoader)?.findLibrary(name)
+
+  private fun isShared(name: String): Boolean = SHARED_PREFIXES.any { name.startsWith(it) }
+
+  private companion object {
+    val SHARED_PREFIXES = arrayOf(
+      "java.", "javax.", "android.", "androidx.", "dalvik.", "libcore.",
+      "kotlin.", "kotlinx.", "com.facebook.", "com.gertec.backend."
+    )
+  }
+}

package/android/src/main/java/com/gertec/backend/GertecBackend.java

@@ -0,0 +1,20 @@
+package com.gertec.backend;
+
+/**
+ * Contrato entre o modulo e o SDK Gertec "Neo" (libgedi 2.x), que roda num classloader isolado.
+ * A interface e o callback sao carregados pelo classloader do app (pai) e so usam tipos da plataforma,
+ * assim o adaptador carregado do dex da Neo consegue implementar sem depender de classes do React Native.
+ */
+public interface GertecBackend {
+  /** Resolve com o UID do cartao (byte[]). */
+  void scanRfid(GertecCallback callback);
+
+  /** Resolve com Boolean.TRUE. */
+  void cancelScan(GertecCallback callback);
+
+  /** Resolve com Boolean.TRUE. */
+  void scrollPrinterPaper(int lines, GertecCallback callback);
+
+  /** Resolve com Boolean.TRUE. */
+  void printHtml(String html, GertecCallback callback);
+}

package/android/src/main/java/com/gertec/backend/GertecCallback.java

@@ -0,0 +1,7 @@
+package com.gertec.backend;
+
+public interface GertecCallback {
+  void resolve(Object value);
+
+  void reject(String code, String message, Throwable cause);
+}

package/android/src/main/java/com/gertec/utils/MifareGPOS780.kt

@@ -1,5 +1,6 @@
 package com.gertec.utils
 
+import android.util.Log
 import br.com.gertec.easylayer.contactless.MifareClassic
 import com.facebook.react.bridge.Promise
 import com.mesmart.Utils
@@ -33,7 +34,10 @@ class MifareGPOS780 {
           } catch (e: Exception) {
             val msg = e.message?.lowercase().orEmpty()
             val isTimeoutLike = msg.contains("timeout") || msg.contains("polling")
-            if (!isTimeoutLike) throw e
+            if (!isTimeoutLike) {
+              Log.e(TAG, "RFID connect failed: ${e.javaClass.name}: ${e.message}")
+              throw e
+            }
           } finally {
             try { mifare.close() } catch (_: Exception) {}
           }
@@ -46,9 +50,11 @@ class MifareGPOS780 {
           )
           else       -> promise.reject("Timeout to read RFID card!")
         }
-      } catch (e: Exception) {
-        e.printStackTrace()
-        promise.reject(e)
+      } catch (t: Throwable) {
+        // Throwable: falha da lib nativa e Error e, sem isso, a thread morre e a promise nunca resolve.
+        val message = "RFID scan threw ${t.javaClass.name}: ${t.message} (${Utils.deviceContext()})"
+        Log.e(TAG, message, t)
+        promise.reject("GERTEC_RFID_ERROR", message, t)
       } finally {
         try { mifare.close() } catch (_: Exception) {}
         mifare = MifareClassic()
@@ -70,4 +76,8 @@ class MifareGPOS780 {
       promise.reject(e)
     }
   }
+
+  private companion object {
+    const val TAG = "MeSmartGertec"
+  }
 }

package/android/src/main/java/com/gertec/utils/PrinterGPOS780.kt

@@ -1,9 +1,11 @@
 package com.gertec.utils
 
+import android.util.Log
 import br.com.gertec.easylayer.printer.Printer
 import br.com.gertec.easylayer.printer.PrinterError
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
+import com.mesmart.Utils
 
 class PrinterGPOS780(
   private val reactContext: ReactApplicationContext
@@ -12,27 +14,48 @@ class PrinterGPOS780(
     lines: Int,
     promise: Promise
   ) {
-    Printer.getInstance(reactContext.applicationContext, object: Printer.Listener {
-      override fun onPrinterError(printerError: PrinterError?) {
-        promise.reject("Cause: ${printerError?.cause}\\nError code: ${printerError?.code}\\nRequest ID: ${printerError?.requestId}\"")
-      }
-      override fun onPrinterSuccessful(var1: Int) {
-        promise.resolve(true)
-      }
-    }).scrollPaper(lines)
+    try {
+      Printer.getInstance(reactContext.applicationContext, listener(promise, "scrollPaper"))
+        .scrollPaper(lines)
+    } catch (t: Throwable) {
+      reject(promise, "scrollPaper", t)
+    }
   }
 
   fun printHtml(
     html: String,
     promise: Promise
   ) {
-    Printer.getInstance(reactContext.applicationContext, object: Printer.Listener {
-      override fun onPrinterError(printerError: PrinterError?) {
-        promise.reject("Cause: ${printerError?.cause}\\nError code: ${printerError?.code}\\nRequest ID: ${printerError?.requestId}\"")
-      }
-      override fun onPrinterSuccessful(var1: Int) {
-        promise.resolve(true)
-      }
-    }).printHtml(reactContext.applicationContext, html)
+    try {
+      Printer.getInstance(reactContext.applicationContext, listener(promise, "printHtml"))
+        .printHtml(reactContext.applicationContext, html)
+    } catch (t: Throwable) {
+      reject(promise, "printHtml", t)
+    }
+  }
+
+  private fun listener(promise: Promise, operation: String) = object : Printer.Listener {
+    override fun onPrinterError(printerError: PrinterError?) {
+      val message = "Printer $operation failed. Cause: ${printerError?.cause}, " +
+        "error code: ${printerError?.code}, request ID: ${printerError?.requestId} " +
+        "(${Utils.deviceContext()})"
+      Log.e(TAG, message)
+      promise.reject("GERTEC_PRINTER_ERROR", message)
+    }
+
+    override fun onPrinterSuccessful(var1: Int) {
+      promise.resolve(true)
+    }
+  }
+
+  // Throwable (e nao so Exception): falha da lib nativa (UnsatisfiedLinkError, NoClassDefFoundError) e Error.
+  private fun reject(promise: Promise, operation: String, t: Throwable) {
+    val message = "Printer $operation threw ${t.javaClass.name}: ${t.message} (${Utils.deviceContext()})"
+    Log.e(TAG, message, t)
+    promise.reject("GERTEC_PRINTER_ERROR", message, t)
+  }
+
+  private companion object {
+    const val TAG = "MeSmartGertec"
   }
 }

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

@@ -18,11 +18,21 @@ object Utils {
     return Build.MODEL.equals("A910", true)
   }
 
-  /** Cobre GPOS780 e GPOS780S (mesma familia Gertec, mesmo SDK). */
+  /** Cobre GPOS780 e GPOS780S (mesma familia Gertec). */
   fun isGPOS780(): Boolean {
     return Build.MODEL.startsWith("GPOS780", true)
   }
 
+  /** GPOS780S: nao inicializa o GEDI da libgedi 1.16, usa o SDK Neo (ver com.gertec.NeoSdkLoader). */
+  fun isGPOS780S(): Boolean {
+    return Build.MODEL.startsWith("GPOS780S", true)
+  }
+
+  /** Contexto do aparelho p/ mensagens de erro do Gertec (modelo + Android), p/ debugar em campo. */
+  fun deviceContext(): String {
+    return "model=${Build.MODEL}, android=${Build.VERSION.RELEASE} (sdk ${Build.VERSION.SDK_INT})"
+  }
+
   fun isT8(): Boolean {
     return Build.MODEL.equals("T8", true)
   }

package/android/src/main/java/com/tectoy/utils/PrinterT8.kt

@@ -9,11 +9,16 @@ import android.graphics.Typeface
 import android.text.Layout
 import android.text.StaticLayout
 import android.text.TextPaint
+import android.util.Log
 import br.com.stone.posandroid.providers.PosPrintProvider
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.stone.utils.StoneUtils
 import stone.application.interfaces.StoneCallbackInterface
+import java.lang.reflect.Field
+import java.lang.reflect.InvocationHandler
+import java.lang.reflect.InvocationTargetException
+import java.lang.reflect.Proxy
 
 /**
  * Mesmas primitivas da Sunmi, mas acumuladas: o HAL da Tectoy avanca o papel pra corte no fim de
@@ -68,6 +73,7 @@ class PrinterT8(
       return
     }
 
+    guardLateEvents()
     val provider = PosPrintProvider(reactContext)
     job.forEach { provider.addBitmap(it) }
     provider.connectionCallback = object : StoneCallbackInterface {
@@ -87,6 +93,47 @@ class PrinterT8(
     provider.execute()
   }
 
+  /**
+   * O HAL da Tectoy (posandroid-manufacturer-tectoy 2.2.10, SDK Stone 4.20.x) solta o PosPrinter no
+   * fim do job (onFinish -> close -> release) com eventos de status ainda na fila do main looper; o
+   * proximo onInfo chama getPrintStateInfo() com mPosPrinter nulo e o NPE derruba o app. Abre aqui o
+   * gerenciador que o HAL reaproveita no job e embrulha o listener que ele entrega ao PosPrinter no
+   * beginPrint, pra descartar so os eventos que chegam depois do release. Tudo por reflexao: se o
+   * HAL mudar, imprime como antes.
+   */
+  private fun guardLateEvents() {
+    try {
+      val services = Class.forName("com.transire.transireservice.TransireServiceManager")
+        .getMethod("getInstance").invoke(null) ?: return
+      val manager = services.javaClass.getMethod("getPOIPrinterService").invoke(services) ?: return
+      val listenerField = field(manager.javaClass, "eventListener")
+      val listener = listenerField.get(manager) ?: return
+      if (Proxy.isProxyClass(listener.javaClass)) return
+
+      val guard = InvocationHandler { _, method, args ->
+        try {
+          method.invoke(listener, *(args ?: emptyArray<Any?>()))
+        } catch (e: InvocationTargetException) {
+          if (e.cause !is NullPointerException || !isReleased(args?.firstOrNull())) throw e.cause ?: e
+          Log.w(TAG, "Evento ${method.name} da impressora depois do release ignorado")
+          null
+        }
+      }
+      listenerField.set(
+        manager,
+        Proxy.newProxyInstance(listener.javaClass.classLoader, listener.javaClass.interfaces, guard)
+      )
+    } catch (t: Throwable) {
+      Log.w(TAG, "Impressora sem protecao contra eventos tardios do HAL", t)
+    }
+  }
+
+  private fun isReleased(printer: Any?): Boolean =
+    printer != null && runCatching { field(printer.javaClass, "mPosPrinter").get(printer) == null }.getOrDefault(false)
+
+  private fun field(type: Class<*>, name: String): Field =
+    type.getDeclaredField(name).apply { isAccessible = true }
+
   private fun textBlock(
     text: String,
     fontSize: Int,
@@ -133,6 +180,7 @@ class PrinterT8(
       .apply { eraseColor(Color.WHITE) }
 
   companion object {
+    private const val TAG = "PrinterT8"
     private const val PRINT_WIDTH = 384
     private const val DEFAULT_FONT_SIZE = 24
     private const val CALIBRATION_CHARS = 32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-mesmart",
-  "version": "3.0.1",
+  "version": "3.1.0",
   "description": "Native methods for integrating with Sunmi P2-B/P2-A11 POS, Pax A910/A920, Pagbank's Plugpag payment SDK, Stone's payment SDK, and Paystore's payment SDK.",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -27,7 +27,7 @@
     "lint": "eslint \"**/*.{js,ts,tsx}\"",
     "clean": "del-cli android/build example/android/build example/android/app/build lib",
     "prepare": "bob build",
-    "release": "release-it"
+    "release": "bash scripts/release.sh"
   },
   "keywords": [
     "react-native",