react-native-printer-imin 0.4.2 → 0.5.0

package/android/src/main/java/com/printerimin/PrinterIminModule.java

@@ -6,12 +6,13 @@ import com.bumptech.glide.load.engine.DiskCacheStrategy;
 
 import android.graphics.Bitmap;
 import android.graphics.Typeface;
+import android.os.RemoteException;
 import android.graphics.BitmapFactory;
 import android.os.Build;
 import android.util.Log;
 
 import androidx.annotation.NonNull;
-
+import androidx.annotation.Nullable;
 
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.Promise;
@@ -24,17 +25,16 @@ import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.WritableMap;
 
 import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
 
 
-import com.imin.library.SystemPropManager;
+import com.imin.printer.INeoPrinterCallback;
 import com.imin.printer.PrinterHelper;
 import com.imin.printerlib.Callback;
 import com.imin.printerlib.IminPrintUtils;
 
-
 import java.util.ArrayList;
 import java.util.Arrays;
-
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -44,30 +44,51 @@ import org.json.JSONObject;
 
 import org.json.JSONException;
 
+
+import java.lang.RuntimeException;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.BroadcastReceiver;
+
 @ReactModule(name = PrinterIminModule.NAME)
 public class PrinterIminModule extends ReactContextBaseJavaModule {
   private final ReactApplicationContext reactContext;
   public static final String NAME = "PrinterImin";
   private IminPrintUtils iminPrintUtils;
-  private IminPrintUtils.PrintConnectType connectType = IminPrintUtils.PrintConnectType.SPI;
+  private String[] modelArry = {"W27_Pro", "I23M01", "I23M02", "I23D01", "D4-503 Pro", "D4-504 Pro", "D4-505 Pro", "MS2-11", "MS2-12", "MS1-15"};
+  private static final String ACTION_PRITER_STATUS_CHANGE = "com.imin.printerservice.PRITER_STATUS_CHANGE";
+  private static final String ACTION_POGOPIN_STATUS_CHANGE = "com.imin.printerservice.PRITER_CONNECT_STATUS_CHANGE";
+  private String sdkVersion = "1.0.0";
+  private static final String ACTION_PRITER_STATUS = "status";
+  private IminPrintUtils.PrintConnectType connectType = IminPrintUtils.PrintConnectType.USB;
+  private static final String TAG = "IminPrinterReactNativePlugin";
+  private BroadcastReceiver mBroadcastReceiver;
 
   public PrinterIminModule(ReactApplicationContext reactContext) {
     super(reactContext);
     this.reactContext = reactContext;
-    if (Build.MODEL.equals("W27_Pro") || Build.MODEL.equals("I23D01") || Build.MODEL.equals("I23M01") || Build.MODEL.equals("I23M02")) {
+    List<String> modelList = Arrays.asList(modelArry);
+    if (modelList.contains(Build.MODEL)) {
       //初始化 2.0 的 SDK。
       PrinterHelper.getInstance().initPrinterService(reactContext);
+      sdkVersion = "2.0.0";
     } else {
       //初始化 1.0 SDK
+
       iminPrintUtils = IminPrintUtils.getInstance(reactContext);
-      String deviceModel = SystemPropManager.getModel();
+      String deviceModel = Utils.getInstance().getModel();
       if (deviceModel.contains("M2-203") || deviceModel.contains("M2-202") || deviceModel.contains("M2-Pro")) {
         connectType = IminPrintUtils.PrintConnectType.SPI;
       } else {
         connectType = IminPrintUtils.PrintConnectType.USB;
       }
+      iminPrintUtils.setIsOpenLog(IminPrintUtils.isOpenLog == 1 ? 0 : 1);
       iminPrintUtils.resetDevice();
+      sdkVersion = "1.0.0";
     }
+    initializeBroadcastReceiver();
   }
 
   @Override
@@ -76,12 +97,22 @@ public class PrinterIminModule extends ReactContextBaseJavaModule {
     return NAME;
   }
 
+  private void sendEvent(ReactContext reactContext, String eventName, @Nullable WritableMap params) {
+
+    try {
+      reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class).emit(eventName, params);
+    } catch (RuntimeException e) {
+      Log.e(TAG, "java.lang.RuntimeException: Trying to invoke JS before CatalystInstance has been set!", e);
+    }
+  }
 
   @ReactMethod
   public void initPrinter(final Promise promise) {
     try {
       if (iminPrintUtils != null) {
         iminPrintUtils.initPrinter(connectType);
+      } else {
+        PrinterHelper.getInstance().initPrinter(reactContext.getPackageName(), null);
       }
       promise.resolve(true);
     } catch (Exception e) {
@@ -91,24 +122,37 @@ public class PrinterIminModule extends ReactContextBaseJavaModule {
 
   @ReactMethod
   public void getPrinterStatus(final Promise promise) {
-    WritableMap payload = Arguments.createMap();
-    if (iminPrintUtils != null) {
-      if (connectType.equals(IminPrintUtils.PrintConnectType.SPI)) {
-        iminPrintUtils.getPrinterStatus(connectType, new Callback() {
-          @Override
-          public void callback(int status) {
-            payload.putString("message", getPrinterStatusText(status));
-            payload.putString("code", String.format("%d", status));
-            promise.resolve(payload);
-          }
-        });
+    try {
+      WritableMap payload = Arguments.createMap();
+      if (iminPrintUtils != null) {
+        if (connectType.equals(IminPrintUtils.PrintConnectType.SPI)) {
+          iminPrintUtils.getPrinterStatus(connectType, new Callback() {
+            @Override
+            public void callback(int status) {
+              payload.putString("message", Utils.getInstance().getPrinterStatusText(status));
+              payload.putString("code", String.format("%d", status));
+              promise.resolve(payload);
+            }
+          });
+        } else {
+          int status = iminPrintUtils.getPrinterStatus(connectType);
+          payload.putString("message", Utils.getInstance().getPrinterStatusText(status));
+          payload.putString("code", String.format("%d", status));
+          promise.resolve(payload);
+        }
       } else {
-        int status = iminPrintUtils.getPrinterStatus(connectType);
-        payload.putString("message", getPrinterStatusText(status));
+        int status = PrinterHelper.getInstance().getPrinterStatus();
+        payload.putString("message", Utils.getInstance().getPrinterStatusText(status));
         payload.putString("code", String.format("%d", status));
         promise.resolve(payload);
       }
+      payload.putString("message", "sdsd");
+      payload.putString("code", "1");
+      promise.resolve(payload);
+    } catch (Exception e) {
+      promise.reject("getPrinterStatus_failed", e.getMessage());
     }
+
   }
 
   @ReactMethod
@@ -191,7 +235,9 @@ public class PrinterIminModule extends ReactContextBaseJavaModule {
   public void printText(String text, final Promise promise) {
     try {
       if (iminPrintUtils != null) {
-        iminPrintUtils.printText(text);
+        iminPrintUtils.printText(text + "\n");
+      } else {
+        PrinterHelper.getInstance().printText(text + "\n", null);
       }
       promise.resolve(null);
     } catch (Exception e) {
@@ -228,6 +274,8 @@ public class PrinterIminModule extends ReactContextBaseJavaModule {
     try {
       if (iminPrintUtils != null) {
         iminPrintUtils.printAndLineFeed();
+      } else {
+        PrinterHelper.getInstance().printAndLineFeed();
       }
       promise.resolve(null);
     } catch (Exception e) {
@@ -240,6 +288,8 @@ public class PrinterIminModule extends ReactContextBaseJavaModule {
     try {
       if (iminPrintUtils != null) {
         iminPrintUtils.printAndFeedPaper(height);
+      } else {
+        PrinterHelper.getInstance().printAndFeedPaper(height);
       }
       promise.resolve(null);
     } catch (Exception e) {
@@ -259,14 +309,21 @@ public class PrinterIminModule extends ReactContextBaseJavaModule {
         String textColumn = col.getString("text");
         int widthColumn = col.getInt("width");
         int alignColumn = col.getInt("align");
+         Log.d(TAG, "printColumnsText: colsText" + textColumn);
         int fontSizeColumn = col.getInt("fontSize");
         colsText[i] = textColumn;
         colsWidth[i] = widthColumn;
         colsAlign[i] = alignColumn;
         colsFontSize[i] = fontSizeColumn;
       }
+       Log.d(TAG, "printColumnsText: colsText" + colsText);
+       Log.d(TAG, "printColumnsText: colsWidth" + colsWidth);
+       Log.d(TAG, "printColumnsText: colsAlign" + colsAlign);
+       Log.d(TAG, "printColumnsText: colsFontSize" + colsFontSize);
       if (iminPrintUtils != null) {
         iminPrintUtils.printColumnsText(colsText, colsWidth, colsAlign, colsFontSize);
+      } else {
+        PrinterHelper.getInstance().printColumnsText(colsText, colsWidth, colsAlign, colsFontSize, null);
       }
       promise.resolve(null);
     } catch (Exception e) {
@@ -279,6 +336,8 @@ public class PrinterIminModule extends ReactContextBaseJavaModule {
     try {
       if (iminPrintUtils != null) {
         iminPrintUtils.setPageFormat(style);
+      } else {
+        PrinterHelper.getInstance().setPageFormat(style);
       }
       promise.resolve(null);
     } catch (Exception e) {
@@ -291,6 +350,8 @@ public class PrinterIminModule extends ReactContextBaseJavaModule {
     try {
       if (iminPrintUtils != null) {
         iminPrintUtils.partialCut();
+      } else {
+        PrinterHelper.getInstance().partialCut();
       }
       promise.resolve(null);
     } catch (Exception e) {
@@ -298,6 +359,18 @@ public class PrinterIminModule extends ReactContextBaseJavaModule {
     }
   }
 
+  @ReactMethod
+  public void fullCut(final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        PrinterHelper.getInstance().fullCut();
+      }
+      promise.resolve(null);
+    } catch (Exception e) {
+      promise.reject("fullCut_failed", e.getMessage());
+    }
+  }
+
   @ReactMethod
   public void printSingleBitmap(ReadableMap config, final Promise promise) {
     try {
@@ -306,7 +379,6 @@ public class PrinterIminModule extends ReactContextBaseJavaModule {
         int width = config.getInt("width");
         int height = config.getInt("height");
         Bitmap image = Glide.with(reactContext).asBitmap().load(url).diskCacheStrategy(DiskCacheStrategy.NONE).skipMemoryCache(true).submit(width, height).get();
-        Log.d("printSingleBitmap", "image:" + image);
         if (image.isRecycled()) {
           return;
         }
@@ -317,10 +389,16 @@ public class PrinterIminModule extends ReactContextBaseJavaModule {
           } else {
             iminPrintUtils.printSingleBitmap(image);
           }
+        } else {
+          if (config.hasKey("align")) {
+            int align = config.getInt("align");
+            PrinterHelper.getInstance().printBitmapWithAlign(image, align, null);
+          } else {
+            PrinterHelper.getInstance().printBitmap(image, null);
+          }
         }
       } else {
         Bitmap image = Glide.with(reactContext).asBitmap().load(url).diskCacheStrategy(DiskCacheStrategy.NONE).skipMemoryCache(true).submit().get();
-        Log.d("printSingleBitmap", "image:" + image);
         if (image.isRecycled()) {
           return;
         }
@@ -331,10 +409,15 @@ public class PrinterIminModule extends ReactContextBaseJavaModule {
           } else {
             iminPrintUtils.printSingleBitmap(image);
           }
+        } else {
+          if (config.hasKey("align")) {
+            int align = config.getInt("align");
+            PrinterHelper.getInstance().printBitmapWithAlign(image, align, null);
+          } else {
+            PrinterHelper.getInstance().printBitmap(image, null);
+          }
         }
       }
-
-
       promise.resolve(null);
     } catch (Exception e) {
       promise.reject("printSingleBitmap_failed", e.getMessage());
@@ -344,14 +427,16 @@ public class PrinterIminModule extends ReactContextBaseJavaModule {
   @ReactMethod
   public void printMultiBitmap(ReadableMap config, final Promise promise) {
     try {
-      Log.d("printMultiBitmap", "config:" + config.getArray("urls"));
       ReadableArray urls = config.getArray("urls");
       ArrayList<Bitmap> bitmaps = new ArrayList<Bitmap>();
       if (config.hasKey("width") && config.hasKey("height")) {
         int width = config.getInt("width");
         int height = config.getInt("height");
         for (int i = 0; i < urls.size(); i++) {
-          bitmaps.add(Glide.with(reactContext).asBitmap().load(urls.getString(i)).diskCacheStrategy(DiskCacheStrategy.NONE).skipMemoryCache(true).submit(width, height).get());
+          Bitmap image = Glide.with(reactContext).asBitmap().load(urls.getString(i)).diskCacheStrategy(DiskCacheStrategy.NONE).skipMemoryCache(true).submit(width, height).get();
+          if (!image.isRecycled()) {
+            bitmaps.add(image);
+          }
         }
         if (iminPrintUtils != null) {
           if (config.hasKey("align")) {
@@ -360,10 +445,20 @@ public class PrinterIminModule extends ReactContextBaseJavaModule {
           } else {
             iminPrintUtils.printMultiBitmap(bitmaps, 0);
           }
+        } else {
+          if (config.hasKey("align")) {
+            int align = config.getInt("align");
+            PrinterHelper.getInstance().printMultiBitmapWithAlign(bitmaps, align, null);
+          } else {
+            PrinterHelper.getInstance().printMultiBitmap(bitmaps, null);
+          }
         }
       } else {
         for (int i = 0; i < urls.size(); i++) {
-          bitmaps.add(Glide.with(reactContext).asBitmap().load(urls.getString(i)).diskCacheStrategy(DiskCacheStrategy.NONE).skipMemoryCache(true).submit().get());
+          Bitmap image = Glide.with(reactContext).asBitmap().load(urls.getString(i)).diskCacheStrategy(DiskCacheStrategy.NONE).skipMemoryCache(true).submit().get();
+          if (!image.isRecycled()) {
+            bitmaps.add(image);
+          }
         }
         if (iminPrintUtils != null) {
           if (config.hasKey("align")) {
@@ -372,11 +467,15 @@ public class PrinterIminModule extends ReactContextBaseJavaModule {
           } else {
             iminPrintUtils.printMultiBitmap(bitmaps, 0);
           }
+        } else {
+          if (config.hasKey("align")) {
+            int align = config.getInt("align");
+            PrinterHelper.getInstance().printMultiBitmapWithAlign(bitmaps, align, null);
+          } else {
+            PrinterHelper.getInstance().printMultiBitmap(bitmaps, null);
+          }
         }
       }
-      // // if (image.isRecycled()) {
-      // //   return;
-      // // }
       promise.resolve(null);
     } catch (Exception e) {
       promise.reject("printMultiBitmap_failed", e.getMessage());
@@ -394,7 +493,6 @@ public class PrinterIminModule extends ReactContextBaseJavaModule {
         if (image.isRecycled()) {
           return;
         }
-        Log.d("printSingleBitmap", "image:" + image);
         if (iminPrintUtils != null) {
           iminPrintUtils.printSingleBitmapBlackWhite(image);
         }
@@ -403,8 +501,6 @@ public class PrinterIminModule extends ReactContextBaseJavaModule {
         if (image.isRecycled()) {
           return;
         }
-        Log.d("printSingleBitmap", "image:" + image);
-
         if (iminPrintUtils != null) {
           iminPrintUtils.printSingleBitmapBlackWhite(image);
         }
@@ -420,6 +516,8 @@ public class PrinterIminModule extends ReactContextBaseJavaModule {
     try {
       if (iminPrintUtils != null) {
         iminPrintUtils.setQrCodeSize(qrSize);
+      } else {
+        PrinterHelper.getInstance().setQrCodeSize(qrSize);
       }
       promise.resolve(null);
     } catch (Exception e) {
@@ -432,6 +530,8 @@ public class PrinterIminModule extends ReactContextBaseJavaModule {
     try {
       if (iminPrintUtils != null) {
         iminPrintUtils.setLeftMargin(margin);
+      } else {
+        PrinterHelper.getInstance().setLeftMargin(margin);
       }
       promise.resolve(null);
     } catch (Exception e) {
@@ -444,6 +544,8 @@ public class PrinterIminModule extends ReactContextBaseJavaModule {
     try {
       if (iminPrintUtils != null) {
         iminPrintUtils.setBarCodeWidth(width);
+      } else {
+        PrinterHelper.getInstance().setBarCodeWidth(width);
       }
       promise.resolve(null);
     } catch (Exception e) {
@@ -456,6 +558,8 @@ public class PrinterIminModule extends ReactContextBaseJavaModule {
     try {
       if (iminPrintUtils != null) {
         iminPrintUtils.setBarCodeHeight(height);
+      } else {
+        PrinterHelper.getInstance().setBarCodeHeight(height);
       }
       promise.resolve(null);
     } catch (Exception e) {
@@ -468,6 +572,8 @@ public class PrinterIminModule extends ReactContextBaseJavaModule {
     try {
       if (iminPrintUtils != null) {
         iminPrintUtils.setBarCodeContentPrintPos(position);
+      } else {
+        PrinterHelper.getInstance().setBarCodeContentPrintPos(position);
       }
       promise.resolve(null);
     } catch (Exception e) {
@@ -487,6 +593,20 @@ public class PrinterIminModule extends ReactContextBaseJavaModule {
         } else {
           iminPrintUtils.printBarCode(barCodeType, barCodeContent);
         }
+      } else {
+        if (config.hasKey("align")) {
+          int barCodeAlign = config.getInt("align");
+          if (config.hasKey("position") && config.hasKey("height") && config.hasKey("width")) {
+            int position = config.getInt("position");
+            int height = config.getInt("height");
+            int width = config.getInt("width");
+            PrinterHelper.getInstance().printBarCodeWithFull(barCodeContent, barCodeType, width, height, barCodeAlign, position, null);
+          } else {
+            PrinterHelper.getInstance().printBarCodeWithAlign(barCodeContent, barCodeType, barCodeAlign, null);
+          }
+        } else {
+          PrinterHelper.getInstance().printBarCode(barCodeContent, barCodeType, null);
+        }
       }
       promise.resolve(null);
     } catch (Exception e) {
@@ -500,6 +620,8 @@ public class PrinterIminModule extends ReactContextBaseJavaModule {
     try {
       if (iminPrintUtils != null) {
         iminPrintUtils.setDoubleQRSize(size);
+      } else {
+        PrinterHelper.getInstance().setDoubleQRSize(size);
       }
       promise.resolve(null);
     } catch (Exception e) {
@@ -512,6 +634,8 @@ public class PrinterIminModule extends ReactContextBaseJavaModule {
     try {
       if (iminPrintUtils != null) {
         iminPrintUtils.setDoubleQR1Level(level);
+      } else {
+        PrinterHelper.getInstance().setDoubleQR1Level(level);
       }
       promise.resolve(null);
     } catch (Exception e) {
@@ -524,6 +648,8 @@ public class PrinterIminModule extends ReactContextBaseJavaModule {
     try {
       if (iminPrintUtils != null) {
         iminPrintUtils.setDoubleQR2Level(level);
+      } else {
+        PrinterHelper.getInstance().setDoubleQR2Level(level);
       }
       promise.resolve(null);
     } catch (Exception e) {
@@ -536,6 +662,8 @@ public class PrinterIminModule extends ReactContextBaseJavaModule {
     try {
       if (iminPrintUtils != null) {
         iminPrintUtils.setDoubleQR1MarginLeft(leftMargin);
+      } else {
+        PrinterHelper.getInstance().setDoubleQR1MarginLeft(leftMargin);
       }
       promise.resolve(null);
     } catch (Exception e) {
@@ -548,6 +676,8 @@ public class PrinterIminModule extends ReactContextBaseJavaModule {
     try {
       if (iminPrintUtils != null) {
         iminPrintUtils.setDoubleQR2MarginLeft(leftMargin);
+      } else {
+        PrinterHelper.getInstance().setDoubleQR2MarginLeft(leftMargin);
       }
       promise.resolve(null);
     } catch (Exception e) {
@@ -560,6 +690,8 @@ public class PrinterIminModule extends ReactContextBaseJavaModule {
     try {
       if (iminPrintUtils != null) {
         iminPrintUtils.setQrCodeErrorCorrectionLev(level);
+      } else {
+        PrinterHelper.getInstance().setQrCodeErrorCorrectionLev(level);
       }
       promise.resolve(null);
     } catch (Exception e) {
@@ -572,6 +704,8 @@ public class PrinterIminModule extends ReactContextBaseJavaModule {
     try {
       if (iminPrintUtils != null) {
         iminPrintUtils.setDoubleQR1Version(version);
+      } else {
+        PrinterHelper.getInstance().setDoubleQR1Version(version);
       }
       promise.resolve(null);
     } catch (Exception e) {
@@ -584,6 +718,8 @@ public class PrinterIminModule extends ReactContextBaseJavaModule {
     try {
       if (iminPrintUtils != null) {
         iminPrintUtils.setDoubleQR2Version(version);
+      } else {
+        PrinterHelper.getInstance().setDoubleQR2Version(version);
       }
       promise.resolve(null);
     } catch (Exception e) {
@@ -595,15 +731,27 @@ public class PrinterIminModule extends ReactContextBaseJavaModule {
   public void printQrCode(ReadableMap config, final Promise promise) {
     try {
       String qrStr = config.getString("data");
-      if (iminPrintUtils != null) {
-        if (config.hasKey("align")) {
-          int align = config.getInt("align");
+      if (config.hasKey("align")) {
+        int align = config.getInt("align");
+        if (iminPrintUtils != null) {
           iminPrintUtils.printQrCode(qrStr, align);
         } else {
+          if (config.hasKey("qrSize") && config.hasKey("level")) {
+            int qrSize = config.getInt("qrSize");
+            int qrLevel = config.getInt("level");
+            PrinterHelper.getInstance().printQRCodeWithFull(qrStr, qrSize, qrLevel, align, null);
+          } else {
+            PrinterHelper.getInstance().printQrCodeWithAlign(qrStr, align, null);
+          }
+        }
+      } else {
+        if (iminPrintUtils != null) {
           iminPrintUtils.printQrCode(qrStr);
+        } else {
+          PrinterHelper.getInstance().printQrCode(qrStr, null);
         }
-        promise.resolve(null);
       }
+      promise.resolve(null);
     } catch (Exception e) {
       promise.reject("printQrCode_failed", e.getMessage());
     }
@@ -616,6 +764,8 @@ public class PrinterIminModule extends ReactContextBaseJavaModule {
       String qrCode2Text = config.getString("qrCode2Text");
       if (iminPrintUtils != null) {
         iminPrintUtils.printDoubleQR(qrCode1Text, qrCode2Text);
+      } else {
+        PrinterHelper.getInstance().printDoubleQR(qrCode1Text, qrCode2Text, null);
       }
       promise.resolve(null);
     } catch (Exception e) {
@@ -625,17 +775,20 @@ public class PrinterIminModule extends ReactContextBaseJavaModule {
 
   @ReactMethod
   public void openCashBox(final Promise promise) {
-     try {
-       if (iminPrintUtils != null) {
-         iminPrintUtils.openCashBox();
-       }
-       promise.resolve(null);
-     } catch (Exception e) {
+    try {
+      if (iminPrintUtils != null) {
+        Utils.getInstance().opencashBox();
+      } else {
+        PrinterHelper.getInstance().openDrawer();
+      }
+      promise.resolve(null);
+    } catch (Exception e) {
       promise.reject("openCashBox_failed", e.getMessage());
     }
 
   }
 
+
   @ReactMethod
   public void setInitIminPrinter(boolean isDefault, final Promise promise) {
     try {
@@ -654,32 +807,828 @@ public class PrinterIminModule extends ReactContextBaseJavaModule {
       if (iminPrintUtils != null) {
         iminPrintUtils.resetDevice();
       }
+      promise.resolve(null);
     } catch (Exception e) {
       promise.reject("resetDevice_failed", e.getMessage());
     }
   }
 
-  private String getPrinterStatusText(int code) {
-    if (code == 0) {
-      return "Printer is normal!";
-    } else if (code == 1) {
-      return "The printer and call library do not match!";
-    } else if (code == 3) {
-      return "Print head open!";
-    } else if (code == 4) {
-      return "The cutter is not reset!!";
-    } else if (code == 5) {
-      return "Overheated!";
-    } else if (code == 6) {
-      return "Black label error!";
-    } else if (code == 7) {
-      return "Paper Jam!";
-    } else if (code == 8) {
-      return "Paper Out!";
-    } else if (code == 99) {
-      return "Other errors!";
-    } else {
-      return "Printer is not connected or powered on!";
+  @ReactMethod
+  public void printerSelfChecking(final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        PrinterHelper.getInstance().printerSelfChecking(null);
+      }
+      promise.resolve(null);
+    } catch (Exception e) {
+      promise.reject("printerSelfChecking_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void printSingleBitmapColorChart(ReadableMap config, final Promise promise) {
+    try {
+      String url = config.getString("url");
+      if (config.hasKey("width") && config.hasKey("height")) {
+        int width = config.getInt("width");
+        int height = config.getInt("height");
+        Bitmap image = Glide.with(reactContext).asBitmap().load(url).diskCacheStrategy(DiskCacheStrategy.NONE).skipMemoryCache(true).submit(width, height).get();
+        if (image.isRecycled()) {
+          return;
+        }
+        if (iminPrintUtils == null) {
+          if (config.hasKey("align")) {
+            int align = config.getInt("align");
+            PrinterHelper.getInstance().printBitmapColorChartWithAlign(image, align, null);
+          } else {
+            PrinterHelper.getInstance().printBitmapColorChart(image, null);
+          }
+        }
+      } else {
+        Bitmap image = Glide.with(reactContext).asBitmap().load(url).diskCacheStrategy(DiskCacheStrategy.NONE).skipMemoryCache(true).submit().get();
+        if (image.isRecycled()) {
+          return;
+        }
+        if (iminPrintUtils == null) {
+          if (config.hasKey("align")) {
+            int align = config.getInt("align");
+            PrinterHelper.getInstance().printBitmapColorChartWithAlign(image, align, null);
+          } else {
+            PrinterHelper.getInstance().printBitmapColorChart(image, null);
+          }
+        }
+      }
+      promise.resolve(null);
+    } catch (Exception e) {
+      promise.reject("printSingleBitmap_failed", e.getMessage());
+    }
+  }
+
+
+  @ReactMethod
+  public void sendRAWData(ReadableArray bytes, final Promise promise) {
+    try {
+      // 处理接收到的 Uint8Array 数据
+      byte[] rawData = new byte[bytes.size()];
+      for (int i = 0; i < bytes.size(); i++) {
+        rawData[i] = (byte) bytes.getInt(i);
+      }
+      if (iminPrintUtils == null) {
+        PrinterHelper.getInstance().sendRAWData(rawData, null);
+      }
+      promise.resolve(null);
+    } catch (Exception e) {
+      promise.reject("sendRAWData_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void printColumnsString(ReadableArray cols, final Promise promise) {
+    try {
+      String[] colsText = new String[cols.size()];
+      int[] colsWidth = new int[cols.size()];
+      int[] colsAlign = new int[cols.size()];
+      int[] colsFontSize = new int[cols.size()];
+      for (int i = 0; i < cols.size(); i++) {
+        ReadableMap col = cols.getMap(i);
+        String textColumn = col.getString("text");
+        int widthColumn = col.getInt("width");
+        int alignColumn = col.getInt("align");
+        int fontSizeColumn = col.getInt("fontSize");
+        colsText[i] = textColumn;
+        colsWidth[i] = widthColumn;
+        colsAlign[i] = alignColumn;
+        colsFontSize[i] = fontSizeColumn;
+      }
+      if (iminPrintUtils == null) {
+        PrinterHelper.getInstance().printColumnsString(colsText, colsWidth, colsAlign, colsFontSize, null);
+      }
+      promise.resolve(null);
+    } catch (Exception e) {
+      promise.reject("printColumnsString_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void unBindService(final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        PrinterHelper.getInstance().deInitPrinterService(reactContext);
+      }
+    } catch (Exception e) {
+      promise.reject("unBindService_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void initPrinterParams(final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        PrinterHelper.getInstance().initPrinterParams();
+      }
+      promise.resolve(null);
+    } catch (Exception e) {
+      promise.reject("initPrinterParams_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void getFontCodepage(final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        List<String> fontCodepage = PrinterHelper.getInstance().getFontCodepage();
+        promise.resolve(fontCodepage);
+      } else {
+        promise.resolve(null);
+      }
+    } catch (Exception e) {
+      promise.reject("getFontCodepage_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void setFontCodepage(int codepage, final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        PrinterHelper.getInstance().setFontCodepage(codepage);
+      }
+      promise.resolve(null);
+    } catch (Exception e) {
+      promise.reject("setFontCodepage_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void getCurCodepage(final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        String curCodepage = PrinterHelper.getInstance().getCurCodepage();
+        promise.resolve(curCodepage);
+      } else {
+        promise.resolve(null);
+      }
+    } catch (Exception e) {
+      promise.reject("getCurCodepage_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void getEncodeList(final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        List<String> encodeList = PrinterHelper.getInstance().getEncodeList();
+        promise.resolve(encodeList);
+      } else {
+        promise.resolve(null);
+      }
+    } catch (Exception e) {
+      promise.reject("getEncodeList_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void setPrinterEncode(int encode, final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        PrinterHelper.getInstance().setPrinterEncode(encode);
+      }
+      promise.resolve(null);
+    } catch (Exception e) {
+      promise.reject("setPrinterEncode_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void getCurEncode(final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        String curEncode = PrinterHelper.getInstance().getCurEncode();
+        promise.resolve(curEncode);
+      } else {
+        promise.resolve(null);
+      }
+    } catch (Exception e) {
+      promise.reject("getCurEncode_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void getPrinterDensityList(final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        List<String> printerDensityList = PrinterHelper.getInstance().getPrinterDensityList();
+        promise.resolve(printerDensityList);
+      } else {
+        promise.resolve(null);
+      }
+    } catch (Exception e) {
+      promise.reject("getPrinterDensityList_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void setPrinterDensity(int density, final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        PrinterHelper.getInstance().setPrinterDensity(density);
+      }
+      promise.resolve(null);
+    } catch (Exception e) {
+      promise.reject("setPrinterDensity_failed", e.getMessage());
     }
   }
+
+  @ReactMethod
+  public void getPrinterDensity(final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        promise.resolve(PrinterHelper.getInstance().getPrinterDensity());
+      } else {
+        promise.resolve(null);
+      }
+
+    } catch (Exception e) {
+      promise.reject("getPrinterDensity_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void getPrinterSpeedList(final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        List<String> printerSpeedList = PrinterHelper.getInstance().getPrinterSpeedList();
+        promise.resolve(printerSpeedList);
+      } else {
+        promise.resolve(null);
+      }
+
+    } catch (Exception e) {
+      promise.reject("getPrinterSpeedList_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void setPrinterSpeed(int speed, final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        PrinterHelper.getInstance().setPrinterSpeed(speed);
+      }
+      promise.resolve(null);
+    } catch (Exception e) {
+      promise.reject("setPrinterSpeed_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void getPrinterSpeed(final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        int printerSpeed = PrinterHelper.getInstance().getPrinterSpeed();
+        promise.resolve(printerSpeed);
+      } else {
+        promise.resolve(null);
+      }
+    } catch (Exception e) {
+      promise.reject("getPrinterSpeed_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void getPrinterPaperTypeList(final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        List<String> printerPaperTypeList = PrinterHelper.getInstance().getPrinterPaperTypeList();
+        promise.resolve(printerPaperTypeList);
+      } else {
+        promise.resolve(null);
+      }
+    } catch (Exception e) {
+      promise.reject("getPrinterPaperTypeList_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void getPrinterPaperType(final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        promise.resolve(PrinterHelper.getInstance().getPrinterPaperType());
+      } else {
+        promise.resolve(null);
+      }
+    } catch (Exception e) {
+      promise.reject("getPrinterPaperType_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void getPrinterSerialNumber(final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        PrinterHelper.getInstance().getPrinterSerialNumber(new INeoPrinterCallback() {
+          @Override
+          public void onRunResult(boolean isSuccess) throws RemoteException {
+          }
+
+          @Override
+          public void onReturnString(String s) throws RemoteException {
+            promise.resolve(s);
+          }
+
+          @Override
+          public void onRaiseException(int code, String msg) throws RemoteException {
+          }
+
+          @Override
+          public void onPrintResult(int code, String msg) throws RemoteException {
+          }
+        });
+      } else {
+        promise.resolve(null);
+      }
+    } catch (Exception e) {
+      promise.reject("getPrinterSerialNumber_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void getPrinterModelName(final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        PrinterHelper.getInstance().getPrinterModelName(new INeoPrinterCallback() {
+          @Override
+          public void onRunResult(boolean isSuccess) throws RemoteException {
+          }
+
+          @Override
+          public void onReturnString(String s) throws RemoteException {
+            promise.resolve(s);
+          }
+
+          @Override
+          public void onRaiseException(int code, String msg) throws RemoteException {
+          }
+
+          @Override
+          public void onPrintResult(int code, String msg) throws RemoteException {
+          }
+        });
+      } else {
+        promise.resolve(null);
+      }
+    } catch (Exception e) {
+      promise.reject("getPrinterModelName_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void getPrinterThermalHead(final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        PrinterHelper.getInstance().getPrinterThermalHead(new INeoPrinterCallback() {
+          @Override
+          public void onRunResult(boolean isSuccess) throws RemoteException {
+          }
+
+          @Override
+          public void onReturnString(String s) throws RemoteException {
+            promise.resolve(s);
+          }
+
+          @Override
+          public void onRaiseException(int code, String msg) throws RemoteException {
+          }
+
+          @Override
+          public void onPrintResult(int code, String msg) throws RemoteException {
+          }
+        });
+      } else {
+        promise.resolve(null);
+      }
+    } catch (Exception e) {
+      promise.reject("getPrinterThermalHead_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void getPrinterFirmwareVersion(final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        PrinterHelper.getInstance().getPrinterFirmwareVersion(new INeoPrinterCallback() {
+          @Override
+          public void onRunResult(boolean isSuccess) throws RemoteException {
+          }
+
+          @Override
+          public void onReturnString(String s) throws RemoteException {
+            promise.resolve(s);
+          }
+
+          @Override
+          public void onRaiseException(int code, String msg) throws RemoteException {
+          }
+
+          @Override
+          public void onPrintResult(int code, String msg) throws RemoteException {
+          }
+        });
+      } else {
+        promise.resolve(null);
+      }
+    } catch (Exception e) {
+      promise.reject("getPrinterFirmwareVersion_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void getPrinterHardwareVersion(final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        PrinterHelper.getInstance().getPrinterHardwareVersion(new INeoPrinterCallback() {
+          @Override
+          public void onRunResult(boolean isSuccess) throws RemoteException {
+          }
+
+          @Override
+          public void onReturnString(String s) throws RemoteException {
+            promise.resolve(s);
+          }
+
+          @Override
+          public void onRaiseException(int code, String msg) throws RemoteException {
+          }
+
+          @Override
+          public void onPrintResult(int code, String msg) throws RemoteException {
+          }
+        });
+      } else {
+        promise.resolve(null);
+      }
+    } catch (Exception e) {
+      promise.reject("getPrinterHardwareVersion_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void getPrinterPaperDistance(final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        PrinterHelper.getInstance().getPrinterPaperDistance(new INeoPrinterCallback() {
+          @Override
+          public void onRunResult(boolean isSuccess) throws RemoteException {
+          }
+
+          @Override
+          public void onReturnString(String s) throws RemoteException {
+            promise.resolve(s);
+          }
+
+          @Override
+          public void onRaiseException(int code, String msg) throws RemoteException {
+          }
+
+          @Override
+          public void onPrintResult(int code, String msg) throws RemoteException {
+          }
+        });
+      } else {
+        promise.resolve(null);
+      }
+    } catch (Exception e) {
+      promise.reject("getPrinterPaperDistance_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void getPrinterCutTimes(final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        PrinterHelper.getInstance().getPrinterCutTimes(new INeoPrinterCallback() {
+          @Override
+          public void onRunResult(boolean isSuccess) throws RemoteException {
+          }
+
+          @Override
+          public void onReturnString(String s) throws RemoteException {
+            promise.resolve(s);
+          }
+
+          @Override
+          public void onRaiseException(int code, String msg) throws RemoteException {
+          }
+
+          @Override
+          public void onPrintResult(int code, String msg) throws RemoteException {
+          }
+        });
+      } else {
+        promise.resolve(null);
+      }
+    } catch (Exception e) {
+      promise.reject("getPrinterCutTimes_failed", e.getMessage());
+    }
+  }
+
+
+  @ReactMethod
+  public void getPrinterMode(final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        promise.resolve(PrinterHelper.getInstance().getPrinterMode());
+      } else {
+        promise.resolve(null);
+      }
+    } catch (Exception e) {
+      promise.reject("getPrinterMode_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void getDrawerStatus(final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        promise.resolve(PrinterHelper.getInstance().getDrawerStatus());
+      } else {
+        promise.resolve(null);
+      }
+    } catch (Exception e) {
+      promise.reject("getDrawerStatus_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void getOpenDrawerTimes(final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        promise.resolve(PrinterHelper.getInstance().getOpenDrawerTimes());
+      } else {
+        promise.resolve(null);
+      }
+    } catch (Exception e) {
+      promise.reject("getOpenDrawerTimes_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void getServiceVersion(final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        promise.resolve(PrinterHelper.getInstance().getServiceVersion());
+      } else {
+        promise.resolve(null);
+      }
+    } catch (Exception e) {
+      promise.reject("getServiceVersion_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void getUsbPrinterVidPid(final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        promise.resolve(PrinterHelper.getInstance().getUsbPrinterVidPid());
+      } else {
+        promise.resolve(null);
+      }
+    } catch (Exception e) {
+      promise.reject("getUsbPrinterVidPid_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void getUsbDevicesName(final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        promise.resolve(PrinterHelper.getInstance().getUsbDevicesName());
+      } else {
+        promise.resolve(null);
+      }
+    } catch (Exception e) {
+      promise.reject("getUsbDevicesName_failed", e.getMessage());
+    }
+  }
+
+
+  @ReactMethod
+  public void setCodeAlignment(int align, final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        PrinterHelper.getInstance().setCodeAlignment(align);
+      }
+      promise.resolve(null);
+    } catch (Exception e) {
+      promise.reject("setCodeAlignment_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void setTextBitmapTypeface(int typeface, final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        switch (typeface) {
+          case 1:
+            PrinterHelper.getInstance().setTextBitmapTypeface("Typeface.MONOSPACE");
+            break;
+          case 2:
+            PrinterHelper.getInstance().setTextBitmapTypeface("Typeface.DEFAULT_BOLD");
+            break;
+          case 3:
+            PrinterHelper.getInstance().setTextBitmapTypeface("Typeface.SANS_SERIF");
+            break;
+          case 4:
+            PrinterHelper.getInstance().setTextBitmapTypeface("Typeface.SERIF");
+            break;
+          default:
+            PrinterHelper.getInstance().setTextBitmapTypeface("Typeface.DEFAULT");
+            break;
+        }
+      }
+      promise.resolve(null);
+    } catch (Exception e) {
+      promise.reject("setTextBitmapTypeface_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void setTextBitmapSize(int size, final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        PrinterHelper.getInstance().setTextBitmapSize(size);
+      }
+      promise.resolve(null);
+    } catch (Exception e) {
+      promise.reject("setTextBitmapSize_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void setTextBitmapStyle(int style, final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        PrinterHelper.getInstance().setTextBitmapStyle(style);
+      }
+      promise.resolve(null);
+    } catch (Exception e) {
+      promise.reject("setTextBitmapStyle_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void setTextBitmapStrikeThru(boolean strikeThru, final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        PrinterHelper.getInstance().setTextBitmapStrikeThru(strikeThru);
+      }
+      promise.resolve(null);
+    } catch (Exception e) {
+      promise.reject("setTextBitmapStrikeThru_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void setTextBitmapUnderline(boolean haveUnderline, final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        PrinterHelper.getInstance().setTextBitmapUnderline(haveUnderline);
+      }
+      promise.resolve(null);
+    } catch (Exception e) {
+      promise.reject("setTextBitmapUnderline_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void setTextBitmapLineSpacing(float lineHeight, final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        PrinterHelper.getInstance().setTextBitmapLineSpacing(lineHeight);
+      }
+      promise.resolve(null);
+    } catch (Exception e) {
+      promise.reject("setTextBitmapLineSpacing_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void setTextBitmapLetterSpacing(float space, final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        PrinterHelper.getInstance().setTextBitmapLetterSpacing(space);
+      }
+      promise.resolve(null);
+    } catch (Exception e) {
+      promise.reject("setTextBitmapLetterSpacing_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void setTextBitmapAntiWhite(boolean antiWhite, final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        PrinterHelper.getInstance().setTextBitmapAntiWhite(antiWhite);
+      }
+      promise.resolve(null);
+    } catch (Exception e) {
+      promise.reject("setTextBitmapAntiWhite_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void printTextBitmap(ReadableMap config, final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        String text = config.getString("text");
+        if (config.hasKey("align")) {
+          int align = config.getInt("align");
+          PrinterHelper.getInstance().printTextBitmapWithAli(text + "\n", align, null);
+        } else {
+          PrinterHelper.getInstance().printTextBitmap(text + "\n", null);
+        }
+      }
+      promise.resolve(null);
+    } catch (Exception e) {
+      promise.reject("printTextBitmap_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void enterPrinterBuffer(boolean isClean, final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        PrinterHelper.getInstance().enterPrinterBuffer(isClean);
+      }
+      promise.resolve(null);
+    } catch (Exception e) {
+      promise.reject("enterPrinterBuffer_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void commitPrinterBuffer(final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        PrinterHelper.getInstance().commitPrinterBuffer(null);
+      }
+      promise.resolve(null);
+    } catch (Exception e) {
+      promise.reject("commitPrinterBuffer_failed", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void exitPrinterBuffer(boolean isCommit, final Promise promise) {
+    try {
+      if (iminPrintUtils == null) {
+        PrinterHelper.getInstance().exitPrinterBuffer(isCommit);
+      }
+      promise.resolve(null);
+    } catch (Exception e) {
+      promise.reject("exitPrinterBuffer_failed", e.getMessage());
+    }
+  }
+
+  private BroadcastReceiver createChargingStateBroadcastReceiver() {
+    return new BroadcastReceiver() {
+      @Override
+      public void onReceive(Context context, Intent intent) {
+        int status = intent.getIntExtra(ACTION_PRITER_STATUS, -1);
+        Log.d(TAG, "打印机状态：" + intent.getAction());
+        // 发送事件到React Native
+        if (intent.getAction().equals(ACTION_PRITER_STATUS_CHANGE)) {
+          WritableMap result = Arguments.createMap();
+          WritableMap payload = Arguments.createMap();
+          payload.putString("message", Utils.getInstance().getPrinterStatusText(status));
+          payload.putString("code", String.format("%d", status));
+          result.putMap("eventData", payload);
+          result.putString("eventName", "printer_status");
+          sendEvent(reactContext, "eventBroadcast", result);
+        }
+      }
+    };
+  }
+
+  private void initializeBroadcastReceiver() {
+    IntentFilter intentFilter = new IntentFilter();
+    mBroadcastReceiver = createChargingStateBroadcastReceiver();
+    intentFilter.addAction(ACTION_PRITER_STATUS_CHANGE);
+    intentFilter.addAction(ACTION_POGOPIN_STATUS_CHANGE);
+    getReactApplicationContext().registerReceiver(mBroadcastReceiver, intentFilter);
+  }
+
+  @ReactMethod
+  public void addListener(String eventName) {
+  }
+
+  @ReactMethod
+  public void removeListeners(Integer count) {
+  }
+
+  @Override
+  public Map<String, Object> getConstants() {
+    final Map<String, Object> constants = new HashMap<>();
+    constants.put("SDK_VERSION_IMIN", sdkVersion);
+    return constants;
+  }
+
 }