@fedejm/capacitor-esc-pos-printer 0.1.0

package/CapacitorEscPosPrinter.podspec

@@ -0,0 +1,17 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name = 'CapacitorEscPosPrinter'
+  s.version = package['version']
+  s.summary = package['description']
+  s.license = package['license']
+  s.homepage = package['repository']['url']
+  s.author = package['author']
+  s.source = { :git => package['repository']['url'], :tag => s.version.to_s }
+  s.source_files = 'ios/Sources/**/*.{swift,h,m,c,cc,mm,cpp}'
+  s.ios.deployment_target = '14.0'
+  s.dependency 'Capacitor'
+  s.swift_version = '5.1'
+end

package/README.md

@@ -0,0 +1,203 @@
+# capacitor-esc-pos-printer
+
+CapacitorJS wrapper for ESC POS (native) printers.
+
+## Install
+
+```bash
+npm install capacitor-esc-pos-printer
+npx cap sync
+```
+
+## API
+
+<docgen-index>
+
+* [`requestBluetoothEnable()`](#requestbluetoothenable)
+* [`getBluetoothPrinterDevices()`](#getbluetoothprinterdevices)
+* [`createPrinter(...)`](#createprinter)
+* [`disposePrinter(...)`](#disposeprinter)
+* [`isPrinterConnected(...)`](#isprinterconnected)
+* [`connectPrinter(...)`](#connectprinter)
+* [`disconnectPrinter(...)`](#disconnectprinter)
+* [`sendToPrinter(...)`](#sendtoprinter)
+* [`readFromPrinter(...)`](#readfromprinter)
+* [Interfaces](#interfaces)
+* [Enums](#enums)
+
+</docgen-index>
+
+<docgen-api>
+<!--Update the source file JSDoc comments and rerun docgen to update the docs below-->
+
+### requestBluetoothEnable()
+
+```typescript
+requestBluetoothEnable() => Promise<ValueResult<boolean>>
+```
+
+**Returns:** <code>Promise&lt;<a href="#valueresult">ValueResult</a>&lt;boolean&gt;&gt;</code>
+
+--------------------
+
+
+### getBluetoothPrinterDevices()
+
+```typescript
+getBluetoothPrinterDevices() => Promise<BluetoothDevicesResult>
+```
+
+**Returns:** <code>Promise&lt;<a href="#bluetoothdevicesresult">BluetoothDevicesResult</a>&gt;</code>
+
+--------------------
+
+
+### createPrinter(...)
+
+```typescript
+createPrinter(options: CreatePrinterOptions) => Promise<ValueResult<string>>
+```
+
+| Param         | Type                                                                  |
+| ------------- | --------------------------------------------------------------------- |
+| **`options`** | <code><a href="#createprinteroptions">CreatePrinterOptions</a></code> |
+
+**Returns:** <code>Promise&lt;<a href="#valueresult">ValueResult</a>&lt;string&gt;&gt;</code>
+
+--------------------
+
+
+### disposePrinter(...)
+
+```typescript
+disposePrinter(options: WithHashKey) => Promise<ValueResult<boolean>>
+```
+
+| Param         | Type                                                |
+| ------------- | --------------------------------------------------- |
+| **`options`** | <code><a href="#withhashkey">WithHashKey</a></code> |
+
+**Returns:** <code>Promise&lt;<a href="#valueresult">ValueResult</a>&lt;boolean&gt;&gt;</code>
+
+--------------------
+
+
+### isPrinterConnected(...)
+
+```typescript
+isPrinterConnected(options: WithHashKey) => Promise<ValueResult<boolean>>
+```
+
+| Param         | Type                                                |
+| ------------- | --------------------------------------------------- |
+| **`options`** | <code><a href="#withhashkey">WithHashKey</a></code> |
+
+**Returns:** <code>Promise&lt;<a href="#valueresult">ValueResult</a>&lt;boolean&gt;&gt;</code>
+
+--------------------
+
+
+### connectPrinter(...)
+
+```typescript
+connectPrinter(options: WithHashKey) => Promise<void>
+```
+
+| Param         | Type                                                |
+| ------------- | --------------------------------------------------- |
+| **`options`** | <code><a href="#withhashkey">WithHashKey</a></code> |
+
+--------------------
+
+
+### disconnectPrinter(...)
+
+```typescript
+disconnectPrinter(options: WithHashKey) => Promise<void>
+```
+
+| Param         | Type                                                |
+| ------------- | --------------------------------------------------- |
+| **`options`** | <code><a href="#withhashkey">WithHashKey</a></code> |
+
+--------------------
+
+
+### sendToPrinter(...)
+
+```typescript
+sendToPrinter(options: SendToPrinterOptions) => Promise<void>
+```
+
+| Param         | Type                                                                  |
+| ------------- | --------------------------------------------------------------------- |
+| **`options`** | <code><a href="#sendtoprinteroptions">SendToPrinterOptions</a></code> |
+
+--------------------
+
+
+### readFromPrinter(...)
+
+```typescript
+readFromPrinter(options: WithHashKey) => Promise<ValueResult<number[]>>
+```
+
+| Param         | Type                                                |
+| ------------- | --------------------------------------------------- |
+| **`options`** | <code><a href="#withhashkey">WithHashKey</a></code> |
+
+**Returns:** <code>Promise&lt;<a href="#valueresult">ValueResult</a>&lt;number[]&gt;&gt;</code>
+
+--------------------
+
+
+### Interfaces
+
+
+#### ValueResult
+
+| Prop        | Type           |
+| ----------- | -------------- |
+| **`value`** | <code>T</code> |
+
+
+#### BluetoothDevicesResult
+
+| Prop          | Type                                                                                                                |
+| ------------- | ------------------------------------------------------------------------------------------------------------------- |
+| **`devices`** | <code>{ address: string; alias?: string; name: string; bondState: number; type: number; uuids: string[]; }[]</code> |
+
+
+#### CreatePrinterOptions
+
+| Prop                 | Type                                                                    |
+| -------------------- | ----------------------------------------------------------------------- |
+| **`connectionType`** | <code><a href="#printerconnectiontype">PrinterConnectionType</a></code> |
+| **`address`**        | <code>string</code>                                                     |
+
+
+#### WithHashKey
+
+| Prop          | Type                |
+| ------------- | ------------------- |
+| **`hashKey`** | <code>string</code> |
+
+
+#### SendToPrinterOptions
+
+| Prop              | Type                  |
+| ----------------- | --------------------- |
+| **`data`**        | <code>number[]</code> |
+| **`waitingTime`** | <code>number</code>   |
+
+
+### Enums
+
+
+#### PrinterConnectionType
+
+| Members         | Value                    |
+| --------------- | ------------------------ |
+| **`Bluetooth`** | <code>'bluetooth'</code> |
+
+</docgen-api>

package/android/build.gradle

@@ -0,0 +1,58 @@
+ext {
+    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.2'
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.7.0'
+    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.2.1'
+    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.6.1'
+}
+
+buildscript {
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.7.2'
+    }
+}
+
+apply plugin: 'com.android.library'
+
+android {
+    namespace "com.getcapacitor.community.escposprinter"
+    compileSdk project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 35
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 23
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 35
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    lintOptions {
+        abortOnError false
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_21
+        targetCompatibility JavaVersion.VERSION_21
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':capacitor-android')
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    testImplementation "junit:junit:$junitVersion"
+    androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
+    androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,21 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+  xmlns:tools="http://schemas.android.com/tools">
+  <uses-permission android:name="android.permission.BLUETOOTH"
+    android:maxSdkVersion="30" />
+  <uses-permission android:name="android.permission.BLUETOOTH_ADMIN"
+    android:maxSdkVersion="30" />
+  <!-- Uncomment these lines when will use startDiscovery().
+  <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"
+    android:maxSdkVersion="30" />
+  -->
+  <uses-permission android:name="android.permission.BLUETOOTH_SCAN"
+    android:usesPermissionFlags="neverForLocation"
+    tools:targetApi="s" />
+  <uses-permission android:name="android.permission.BLUETOOTH_CONNECT"
+    tools:targetApi="s" />
+
+  <uses-feature android:name="android.hardware.bluetooth"
+    android:required="false" />
+  <uses-feature android:name="android.hardware.bluetooth_le"
+    android:required="false" />
+</manifest>

package/android/src/main/java/com/getcapacitor/community/escposprinter/EscPosPrinterPlugin.java

@@ -0,0 +1,353 @@
+package com.getcapacitor.community.escposprinter;
+
+import android.Manifest;
+import android.annotation.SuppressLint;
+import android.app.Activity;
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothClass;
+import android.bluetooth.BluetoothManager;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.os.Build;
+
+import androidx.activity.result.ActivityResult;
+
+import com.getcapacitor.JSArray;
+import com.getcapacitor.JSObject;
+import com.getcapacitor.PermissionState;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.ActivityCallback;
+import com.getcapacitor.annotation.CapacitorPlugin;
+import com.getcapacitor.annotation.Permission;
+import com.getcapacitor.annotation.PermissionCallback;
+import com.getcapacitor.community.escposprinter.printers.BasePrinter;
+import com.getcapacitor.community.escposprinter.printers.BluetoothPrinter;
+import com.getcapacitor.community.escposprinter.printers.exceptions.PrinterException;
+
+import org.json.JSONException;
+
+import java.lang.reflect.InvocationTargetException;
+import java.util.HashMap;
+import java.util.UUID;
+
+@SuppressWarnings("unused")
+@CapacitorPlugin(
+        name = "EscPosPrinter",
+        permissions = {
+                /*@Permission(
+                        alias = "bluetooth-legacy",
+                        strings = {
+                                Manifest.permission.BLUETOOTH,
+                                Manifest.permission.BLUETOOTH_ADMIN
+                        }
+                ),*/
+                @Permission(
+                        alias = "bluetooth",
+                        strings = {
+                                Manifest.permission.BLUETOOTH_CONNECT,
+                                Manifest.permission.BLUETOOTH_SCAN
+                        }
+                )
+        }
+)
+public class EscPosPrinterPlugin extends Plugin {
+    private BluetoothAdapter bluetoothAdapter;
+    private HashMap<String, BasePrinter> printersMap = new HashMap<>();
+
+    @SuppressWarnings("unused")
+    @PluginMethod
+    public void requestBluetoothEnable(PluginCall call) {
+        if (!assertBluetoothAdapter(call)) {
+            return;
+        }
+        if (bluetoothAdapter.isEnabled()) {
+            var data = new JSObject();
+            data.put("value", true);
+            call.resolve(data);
+        } else {
+            if (!assertBluetoothPermission(call)) {
+                return;
+            }
+            var enableBluetoothIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
+            startActivityForResult(call, enableBluetoothIntent, "requestBluetoothEnableResultCallback");
+        }
+    }
+
+    @ActivityCallback
+    private void requestBluetoothEnableResultCallback(PluginCall call, ActivityResult result) {
+        if (call == null) {
+            return;
+        }
+        var resultCode = result.getResultCode();
+        var data = new JSObject();
+        data.put("value", resultCode == Activity.RESULT_OK);
+        call.resolve(data);
+    }
+
+    @SuppressWarnings("unused")
+    @SuppressLint("MissingPermission")
+    @PluginMethod
+    public void getBluetoothPrinterDevices(PluginCall call) {
+        if (!assertBluetoothAdapter(call) || !assertBluetoothEnabled(call) || !assertBluetoothPermission(call)) {
+            return;
+        }
+
+        var devicesArray = new JSArray();
+        var bondedDevices = bluetoothAdapter.getBondedDevices();
+        if (bondedDevices != null) {
+            for (var device : bondedDevices) {
+                var bluetoothClass = device.getBluetoothClass();
+                var majorClassType = bluetoothClass.getMajorDeviceClass();
+                var deviceType = bluetoothClass.getDeviceClass();
+
+                // From https://inthehand.github.io/html/T_InTheHand_Net_Bluetooth_DeviceClass.htm
+                // 1664 - Imaging printer
+                var isPrinterDevice = majorClassType == BluetoothClass.Device.Major.IMAGING && (deviceType == 1664 || deviceType == BluetoothClass.Device.Major.IMAGING);
+                if (!isPrinterDevice) {
+                    continue;
+                }
+
+                var uuidsArray = new JSArray();
+                var servicesUuids = device.getUuids();
+                if (servicesUuids != null) {
+                    for (var uuid : servicesUuids) {
+                        uuidsArray.put(uuid.toString());
+                    }
+                }
+
+                var deviceObject = new JSObject();
+                devicesArray.put(deviceObject);
+
+                deviceObject.put("address", device.getAddress());
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+                    deviceObject.put("alias", device.getAlias());
+                }
+                deviceObject.put("name", device.getName());
+                deviceObject.put("bondState", device.getBondState());
+                deviceObject.put("type", device.getType());
+                deviceObject.put("uuids", uuidsArray);
+            }
+        }
+
+        var data = new JSObject();
+        data.put("devices", devicesArray);
+        call.resolve(data);
+    }
+
+    @SuppressWarnings("unused")
+    @PluginMethod
+    public void createPrinter(PluginCall call) {
+        var hashKey = UUID.randomUUID().toString();
+        var address = call.getString("address");
+        var connectionType = call.getString("connectionType", "bluetooth");
+
+        BasePrinter printer;
+
+        switch (connectionType) {
+            case "bluetooth": {
+                if (!assertBluetoothAdapter(call)) {
+                    return;
+                }
+
+                // var useLowEnergy = call.getBoolean("le", true) && getContext().getPackageManager().hasSystemFeature(PackageManager.FEATURE_BLUETOOTH_LE);
+                // var secure = call.getBoolean("secure", true);
+
+                printer = new BluetoothPrinter(bluetoothAdapter, address);
+                break;
+            }
+            default: {
+                call.reject("Connection type not known.");
+                return;
+            }
+        }
+
+        printersMap.put(hashKey, printer);
+
+        var data = new JSObject();
+        data.put("value", hashKey);
+        call.resolve(data);
+    }
+
+    @SuppressWarnings("unused")
+    @PluginMethod
+    public void disposePrinter(PluginCall call) {
+        var hashKey = call.getString("hashKey");
+
+        var hasPrinter = printersMap.containsKey(hashKey);
+        if (hasPrinter) {
+            printersMap.remove(hashKey);
+        }
+
+        var data = new JSObject();
+        data.put("value", hasPrinter);
+        call.resolve(data);
+    }
+
+    @SuppressWarnings("unused")
+    @PluginMethod
+    public void isPrinterConnected(PluginCall call) {
+        var printer = getGuardedPrinterByHash(call);
+        if (printer == null) {
+            return;
+        }
+
+        var data = new JSObject();
+        data.put("value", printer.isConnected());
+        call.resolve(data);
+    }
+
+    @SuppressWarnings("unused")
+    @PluginMethod
+    public void connectPrinter(PluginCall call) {
+        var printer = getGuardedPrinterByHash(call);
+        if (printer == null) {
+            return;
+        }
+
+        try {
+            if (printer instanceof BluetoothPrinter && !assertBluetoothEnabled(call) || !assertBluetoothPermission(call)) {
+                return;
+            }
+
+            printer.connect();
+
+            call.resolve();
+        } catch (PrinterException e) {
+            rejectWithPrinterException(call, e);
+        }
+    }
+
+    @SuppressWarnings("unused")
+    @PluginMethod
+    public void disconnectPrinter(PluginCall call) {
+        var printer = getGuardedPrinterByHash(call);
+        if (printer == null) {
+            return;
+        }
+
+        printer.disconnect();
+
+        call.resolve();
+    }
+
+    @SuppressWarnings("unused")
+    @PluginMethod
+    public void sendToPrinter(PluginCall call) {
+        var printer = getGuardedPrinterByHash(call);
+        if (printer == null) {
+            return;
+        }
+
+        var waitingTime = call.getInt("waitingTime", 0);
+        var data = call.getArray("data");
+
+        byte[] bytesArray = new byte[data.length()];
+        for (var i = 0; i < bytesArray.length; i++) {
+            bytesArray[i] = (byte)data.optInt(i);
+        }
+
+        try {
+            printer.send(bytesArray, waitingTime);
+
+            call.resolve();
+        } catch (PrinterException e) {
+            rejectWithPrinterException(call, e);
+        }
+    }
+
+    @SuppressWarnings("unused")
+    @PluginMethod
+    public void readFromPrinter(PluginCall call) {
+        var printer = getGuardedPrinterByHash(call);
+        if (printer == null) {
+            return;
+        }
+
+        // TODO: read like https://github.com/AdoptOpenJDK/openjdk-jdk11/blob/master/src/java.base/share/classes/java/io/InputStream.java
+
+        try {
+            var bytes = printer.read();
+            var bytesArray = new JSArray();
+            for (var i = 0; i < bytes.length; i++) {
+                try {
+                    bytesArray.put(i, bytes[i]);
+                } catch (JSONException e) {
+
+                }
+            }
+
+            var data = new JSObject();
+            data.put("value", bytesArray);
+            call.resolve(data);
+        } catch (PrinterException e) {
+            rejectWithPrinterException(call, e);
+        }
+    }
+
+    private boolean assertBluetoothAdapter(PluginCall call) {
+        if (bluetoothAdapter == null) {
+            var bluetoothAvailable = getContext().getPackageManager().hasSystemFeature(PackageManager.FEATURE_BLUETOOTH);
+            if (bluetoothAvailable) {
+                var bluetoothManager = getContext().getSystemService(BluetoothManager.class);
+                bluetoothAdapter = bluetoothManager.getAdapter();
+            }
+            if (bluetoothAdapter == null) {
+                call.reject("Bluetooth is not available.");
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private boolean assertBluetoothEnabled(PluginCall call) {
+        if (!bluetoothAdapter.isEnabled()) {
+            call.reject("Bluetooth is not enabled.");
+            return false;
+        }
+        return true;
+    }
+
+    private boolean assertBluetoothPermission(PluginCall call) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S && getPermissionState("bluetooth") != PermissionState.GRANTED) {
+            requestPermissionForAlias("bluetooth", call, "bluetoothPermissionCallback");
+            return false;
+        }
+        return true;
+    }
+
+    @PermissionCallback
+    private void bluetoothPermissionCallback(PluginCall call) {
+        if (call == null) {
+            return;
+        }
+        if (getPermissionState("bluetooth") == PermissionState.GRANTED) {
+            var methodName = call.getMethodName();
+            try {
+                var method = this.getClass().getMethod(methodName, PluginCall.class);
+                method.invoke(this, call);
+            } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
+
+            }
+        } else {
+            call.reject("Bluetooth not granted.");
+        }
+    }
+
+    private BasePrinter getGuardedPrinterByHash(PluginCall call) {
+        var hashKey = call.getString("hashKey");
+        var printer = printersMap.get(hashKey);
+        if (printer == null) {
+            call.reject("Printer with " + hashKey + " hash not found.");
+            return null;
+        }
+        return printer;
+    }
+
+    private void rejectWithPrinterException(PluginCall call, PrinterException e) {
+        var data = new JSObject();
+        data.put("code", e.getErrorCode());
+        call.reject(e.getMessage(), data);
+    }
+}