seven365-zyprinter 0.0.1

package/Package.swift

@@ -0,0 +1,43 @@
+// swift-tools-version: 5.9
+import PackageDescription
+
+let package = Package(
+    name: "Seven365Zyprinter",
+    platforms: [.iOS(.v14)],
+    products: [
+        .library(
+            name: "Seven365Zyprinter",
+            targets: ["Seven365ZyprinterPlugin"])
+    ],
+    dependencies: [
+        .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", from: "7.0.0")
+    ],
+    targets: [
+        .target(
+            name: "Seven365ZyprinterPlugin",
+            dependencies: [
+                .product(name: "Capacitor", package: "capacitor-swift-pm"),
+                .product(name: "Cordova", package: "capacitor-swift-pm")
+            ],
+            path: "ios/Sources",
+            exclude: [
+                "sources/GCD/Documentation.html"
+            ],
+            sources: [
+                "Plugin/ZyprintPlugin.swift",
+                "Plugin/ZywellSDK.swift",
+                "sources"
+            ],
+            publicHeadersPath: "Plugin",
+            cSettings: [
+                .headerSearchPath("sources"),
+                .headerSearchPath("sources/GCD"),
+                .headerSearchPath("Plugin")
+            ]
+        ),
+        .testTarget(
+            name: "Seven365ZyprinterPluginTests",
+            dependencies: ["Seven365ZyprinterPlugin"],
+            path: "ios/Tests/ExamplePluginTests")
+    ]
+)

package/README.md

@@ -0,0 +1,186 @@
+# seven365-zyprinter
+
+plugin for integration of zyprinter
+
+## Install
+
+```bash
+npm install seven365-zyprinter
+npx cap sync
+```
+
+## API
+
+<docgen-index>
+
+* [`echo(...)`](#echo)
+* [`discoverPrinters()`](#discoverprinters)
+* [`discoverBluetoothPrinters()`](#discoverbluetoothprinters)
+* [`discoverWiFiPrinters(...)`](#discoverwifiprinters)
+* [`connectToPrinter(...)`](#connecttoprinter)
+* [`disconnectFromPrinter(...)`](#disconnectfromprinter)
+* [`printText(...)`](#printtext)
+* [`printReceipt(...)`](#printreceipt)
+* [`getPrinterStatus(...)`](#getprinterstatus)
+* [Interfaces](#interfaces)
+* [Type Aliases](#type-aliases)
+
+</docgen-index>
+
+<docgen-api>
+<!--Update the source file JSDoc comments and rerun docgen to update the docs below-->
+
+### echo(...)
+
+```typescript
+echo(options: { value: string; }) => Promise<{ value: string; }>
+```
+
+| Param         | Type                            |
+| ------------- | ------------------------------- |
+| **`options`** | <code>{ value: string; }</code> |
+
+**Returns:** <code>Promise&lt;{ value: string; }&gt;</code>
+
+--------------------
+
+
+### discoverPrinters()
+
+```typescript
+discoverPrinters() => Promise<{ printers: ZyPrinter[]; }>
+```
+
+**Returns:** <code>Promise&lt;{ printers: ZyPrinter[]; }&gt;</code>
+
+--------------------
+
+
+### discoverBluetoothPrinters()
+
+```typescript
+discoverBluetoothPrinters() => Promise<{ printers: ZyPrinter[]; }>
+```
+
+**Returns:** <code>Promise&lt;{ printers: ZyPrinter[]; }&gt;</code>
+
+--------------------
+
+
+### discoverWiFiPrinters(...)
+
+```typescript
+discoverWiFiPrinters(options?: { networkRange?: string | undefined; } | undefined) => Promise<{ printers: ZyPrinter[]; }>
+```
+
+| Param         | Type                                    |
+| ------------- | --------------------------------------- |
+| **`options`** | <code>{ networkRange?: string; }</code> |
+
+**Returns:** <code>Promise&lt;{ printers: ZyPrinter[]; }&gt;</code>
+
+--------------------
+
+
+### connectToPrinter(...)
+
+```typescript
+connectToPrinter(options: { identifier: string; }) => Promise<{ connected: boolean; }>
+```
+
+| Param         | Type                                 |
+| ------------- | ------------------------------------ |
+| **`options`** | <code>{ identifier: string; }</code> |
+
+**Returns:** <code>Promise&lt;{ connected: boolean; }&gt;</code>
+
+--------------------
+
+
+### disconnectFromPrinter(...)
+
+```typescript
+disconnectFromPrinter(options: { identifier: string; }) => Promise<{ disconnected: boolean; }>
+```
+
+| Param         | Type                                 |
+| ------------- | ------------------------------------ |
+| **`options`** | <code>{ identifier: string; }</code> |
+
+**Returns:** <code>Promise&lt;{ disconnected: boolean; }&gt;</code>
+
+--------------------
+
+
+### printText(...)
+
+```typescript
+printText(options: { text: string; identifier: string; }) => Promise<{ success: boolean; }>
+```
+
+| Param         | Type                                               |
+| ------------- | -------------------------------------------------- |
+| **`options`** | <code>{ text: string; identifier: string; }</code> |
+
+**Returns:** <code>Promise&lt;{ success: boolean; }&gt;</code>
+
+--------------------
+
+
+### printReceipt(...)
+
+```typescript
+printReceipt(options: { template: Record<string, any>; identifier: string; }) => Promise<{ success: boolean; }>
+```
+
+| Param         | Type                                                                                            |
+| ------------- | ----------------------------------------------------------------------------------------------- |
+| **`options`** | <code>{ template: <a href="#record">Record</a>&lt;string, any&gt;; identifier: string; }</code> |
+
+**Returns:** <code>Promise&lt;{ success: boolean; }&gt;</code>
+
+--------------------
+
+
+### getPrinterStatus(...)
+
+```typescript
+getPrinterStatus(options: { identifier: string; }) => Promise<{ status: string; paperStatus: string; connected: boolean; }>
+```
+
+| Param         | Type                                 |
+| ------------- | ------------------------------------ |
+| **`options`** | <code>{ identifier: string; }</code> |
+
+**Returns:** <code>Promise&lt;{ status: string; paperStatus: string; connected: boolean; }&gt;</code>
+
+--------------------
+
+
+### Interfaces
+
+
+#### ZyPrinter
+
+| Prop                 | Type                                        |
+| -------------------- | ------------------------------------------- |
+| **`identifier`**     | <code>string</code>                         |
+| **`model`**          | <code>string</code>                         |
+| **`status`**         | <code>string</code>                         |
+| **`connectionType`** | <code>'bluetooth' \| 'wifi' \| 'usb'</code> |
+| **`ipAddress`**      | <code>string</code>                         |
+| **`port`**           | <code>number</code>                         |
+| **`rssi`**           | <code>number</code>                         |
+
+
+### Type Aliases
+
+
+#### Record
+
+Construct a type with a set of properties K of type T
+
+<code>{
 [P in K]: T;
 }</code>
+
+</docgen-api>
+# seven365-zyprinter-sdk

package/Seven365Zyprinter.podspec

@@ -0,0 +1,27 @@
+Pod::Spec.new do |s|
+  s.name = 'Seven365Zyprinter'
+  s.version = '0.0.1'
+  s.summary = 'Capacitor plugin for Zywell/Zyprint thermal printer integration'
+  s.license = 'MIT'
+  s.homepage = 'https://github.com/Seven365-Pte-Ltd/plateful-pos-mobile'
+  s.author = 'joelralph'
+  s.source = { :git => 'https://github.com/Seven365-Pte-Ltd/plateful-pos-mobile', :tag => s.version.to_s }
+  s.source_files = 'ios/Sources/**/*.{swift,h,m,c,cc,mm,cpp}'
+  s.exclude_files = 'ios/Sources/sources/POSWIFIManagerAsync.{h,m}'
+  s.ios.deployment_target  = '14.0'
+  s.dependency 'Capacitor'
+  s.swift_version = '5.1'
+  
+  # Framework dependencies
+  s.frameworks = 'CoreBluetooth', 'SystemConfiguration', 'CFNetwork'
+  
+  # Public headers for Objective-C SDK - expose to Swift
+  s.public_header_files = 'ios/Sources/sources/**/*.h'
+
+  
+  # Explicitly disable bridging header (not supported in frameworks)
+  s.pod_target_xcconfig = {
+    'SWIFT_OBJC_BRIDGING_HEADER' => '',
+    'DEFINES_MODULE' => 'YES'
+  }
+end

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.mycompany.plugins.example"
+    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,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/com/mycompany/plugins/example/Example.java

@@ -0,0 +1,342 @@
+package com.mycompany.plugins.example;
+
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothSocket;
+import android.content.Context;
+import android.util.Log;
+import android.os.Handler;
+import android.os.Looper;
+
+import com.getcapacitor.JSArray;
+import com.getcapacitor.JSObject;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.net.Socket;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+
+public class Zyprint {
+
+    private static final String TAG = "Zyprint";
+    private Map<String, PrinterConnection> connectedPrinters = new HashMap<>();
+    private Handler mainHandler = new Handler(Looper.getMainLooper());
+
+    // Callback interfaces
+    public interface PrinterDiscoveryCallback {
+        void onPrintersFound(JSArray printers);
+        void onError(String error);
+    }
+
+    public interface ConnectionCallback {
+        void onConnected();
+        void onError(String error);
+    }
+
+    public interface DisconnectionCallback {
+        void onDisconnected();
+        void onError(String error);
+    }
+
+    public interface PrintCallback {
+        void onSuccess();
+        void onError(String error);
+    }
+
+    public interface StatusCallback {
+        void onStatus(String status, String paperStatus, boolean connected);
+        void onError(String error);
+    }
+
+    public String echo(String value) {
+        Log.i(TAG, "Echo: " + value);
+        return value;
+    }
+
+    public void discoverPrinters(PrinterDiscoveryCallback callback) {
+        new Thread(() -> {
+            try {
+                JSArray printers = new JSArray();
+                
+                // Discover Bluetooth printers
+                BluetoothAdapter bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
+                if (bluetoothAdapter != null && bluetoothAdapter.isEnabled()) {
+                    Set<BluetoothDevice> pairedDevices = bluetoothAdapter.getBondedDevices();
+                    
+                    for (BluetoothDevice device : pairedDevices) {
+                        // Filter for printer devices (you may need to adjust this based on Zywell printer naming)
+                        if (device.getName() != null && 
+                            (device.getName().toLowerCase().contains("zywell") ||
+                             device.getName().toLowerCase().contains("zyprint") ||
+                             device.getName().toLowerCase().contains("printer"))) {
+                            
+                            JSObject printer = new JSObject();
+                            printer.put("identifier", device.getAddress());
+                            printer.put("model", device.getName());
+                            printer.put("status", device.getBondState() == BluetoothDevice.BOND_BONDED ? "ready" : "offline");
+                            printers.put(printer);
+                        }
+                    }
+                }
+                
+                mainHandler.post(() -> callback.onPrintersFound(printers));
+                
+            } catch (Exception e) {
+                Log.e(TAG, "Error discovering printers", e);
+                mainHandler.post(() -> callback.onError("Discovery failed: " + e.getMessage()));
+            }
+        }).start();
+    }
+
+    public void connectToPrinter(String identifier, ConnectionCallback callback) {
+        new Thread(() -> {
+            try {
+                PrinterConnection connection = new PrinterConnection();
+                
+                // Try to connect via Bluetooth
+                BluetoothAdapter bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
+                if (bluetoothAdapter != null) {
+                    BluetoothDevice device = bluetoothAdapter.getRemoteDevice(identifier);
+                    
+                    if (connection.connectBluetooth(device)) {
+                        connectedPrinters.put(identifier, connection);
+                        mainHandler.post(callback::onConnected);
+                        return;
+                    }
+                }
+                
+                // If Bluetooth fails, try WiFi (if identifier is an IP address)
+                if (identifier.matches("\\d+\\.\\d+\\.\\d+\\.\\d+")) {
+                    if (connection.connectWiFi(identifier, 9100)) {
+                        connectedPrinters.put(identifier, connection);
+                        mainHandler.post(callback::onConnected);
+                        return;
+                    }
+                }
+                
+                mainHandler.post(() -> callback.onError("Connection failed"));
+                
+            } catch (Exception e) {
+                Log.e(TAG, "Error connecting to printer", e);
+                mainHandler.post(() -> callback.onError("Connection failed: " + e.getMessage()));
+            }
+        }).start();
+    }
+
+    public void disconnectFromPrinter(String identifier, DisconnectionCallback callback) {
+        PrinterConnection connection = connectedPrinters.get(identifier);
+        if (connection != null) {
+            connection.disconnect();
+            connectedPrinters.remove(identifier);
+            callback.onDisconnected();
+        } else {
+            callback.onError("Printer not connected");
+        }
+    }
+
+    public void printText(String text, String identifier, PrintCallback callback) {
+        PrinterConnection connection = connectedPrinters.get(identifier);
+        if (connection == null) {
+            callback.onError("Printer not connected");
+            return;
+        }
+
+        new Thread(() -> {
+            try {
+                byte[] data = formatTextForPrinter(text);
+                if (connection.sendData(data)) {
+                    mainHandler.post(callback::onSuccess);
+                } else {
+                    mainHandler.post(() -> callback.onError("Print failed"));
+                }
+            } catch (Exception e) {
+                Log.e(TAG, "Error printing text", e);
+                mainHandler.post(() -> callback.onError("Print failed: " + e.getMessage()));
+            }
+        }).start();
+    }
+
+    public void printReceipt(JSObject template, String identifier, PrintCallback callback) {
+        PrinterConnection connection = connectedPrinters.get(identifier);
+        if (connection == null) {
+            callback.onError("Printer not connected");
+            return;
+        }
+
+        new Thread(() -> {
+            try {
+                byte[] data = formatReceiptForPrinter(template);
+                if (connection.sendData(data)) {
+                    mainHandler.post(callback::onSuccess);
+                } else {
+                    mainHandler.post(() -> callback.onError("Print failed"));
+                }
+            } catch (Exception e) {
+                Log.e(TAG, "Error printing receipt", e);
+                mainHandler.post(() -> callback.onError("Print failed: " + e.getMessage()));
+            }
+        }).start();
+    }
+
+    public void getPrinterStatus(String identifier, StatusCallback callback) {
+        PrinterConnection connection = connectedPrinters.get(identifier);
+        if (connection == null) {
+            callback.onStatus("offline", "unknown", false);
+            return;
+        }
+
+        new Thread(() -> {
+            try {
+                // Send status command (this would be specific to Zywell protocol)
+                byte[] statusCommand = {0x10, 0x04, 0x01}; // Example status command
+                
+                if (connection.sendData(statusCommand)) {
+                    // In a real implementation, you'd read the response and parse it
+                    mainHandler.post(() -> callback.onStatus("ready", "ok", true));
+                } else {
+                    mainHandler.post(() -> callback.onStatus("error", "unknown", true));
+                }
+            } catch (Exception e) {
+                Log.e(TAG, "Error getting printer status", e);
+                mainHandler.post(() -> callback.onError("Status check failed: " + e.getMessage()));
+            }
+        }).start();
+    }
+
+    private byte[] formatTextForPrinter(String text) {
+        try {
+            // ESC/POS commands for text printing
+            byte[] initPrinter = {0x1B, 0x40}; // ESC @
+            byte[] textBytes = text.getBytes("UTF-8");
+            byte[] lineFeed = {0x0A, 0x0A, 0x0A}; // Line feeds
+            byte[] cutPaper = {0x1D, 0x56, 0x41, 0x10}; // Cut command
+            
+            byte[] result = new byte[initPrinter.length + textBytes.length + lineFeed.length + cutPaper.length];
+            int offset = 0;
+            
+            System.arraycopy(initPrinter, 0, result, offset, initPrinter.length);
+            offset += initPrinter.length;
+            
+            System.arraycopy(textBytes, 0, result, offset, textBytes.length);
+            offset += textBytes.length;
+            
+            System.arraycopy(lineFeed, 0, result, offset, lineFeed.length);
+            offset += lineFeed.length;
+            
+            System.arraycopy(cutPaper, 0, result, offset, cutPaper.length);
+            
+            return result;
+        } catch (Exception e) {
+            Log.e(TAG, "Error formatting text", e);
+            return new byte[0];
+        }
+    }
+
+    private byte[] formatReceiptForPrinter(JSObject template) {
+        try {
+            StringBuilder receiptText = new StringBuilder();
+            
+            // Initialize printer
+            receiptText.append("\u001B@"); // ESC @
+            
+            // Center align
+            receiptText.append("\u001B\u0061\u0001"); // ESC a 1
+            
+            // Header
+            if (template.has("header")) {
+                receiptText.append(template.getString("header")).append("\n\n");
+            }
+            
+            // Left align for items
+            receiptText.append("\u001B\u0061\u0000"); // ESC a 0
+            
+            // Items
+            if (template.has("items")) {
+                JSArray items = template.getJSArray("items");
+                for (int i = 0; i < items.length(); i++) {
+                    JSObject item = items.getJSObject(i);
+                    String name = item.optString("name", "");
+                    String price = item.optString("price", "");
+                    receiptText.append(name).append("\t").append(price).append("\n");
+                }
+            }
+            
+            // Total
+            if (template.has("total")) {
+                receiptText.append("\nTotal: ").append(template.getString("total")).append("\n");
+            }
+            
+            // Line feeds and cut
+            receiptText.append("\n\n\n");
+            receiptText.append("\u001D\u0056\u0041\u0010"); // Cut command
+            
+            return receiptText.toString().getBytes("UTF-8");
+        } catch (Exception e) {
+            Log.e(TAG, "Error formatting receipt", e);
+            return new byte[0];
+        }
+    }
+
+    private static class PrinterConnection {
+        private BluetoothSocket bluetoothSocket;
+        private Socket wifiSocket;
+        private OutputStream outputStream;
+
+        public boolean connectBluetooth(BluetoothDevice device) {
+            try {
+                // UUID for printer service (this might need to be specific to Zywell)
+                UUID uuid = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");
+                bluetoothSocket = device.createRfcommSocketToServiceRecord(uuid);
+                bluetoothSocket.connect();
+                outputStream = bluetoothSocket.getOutputStream();
+                return true;
+            } catch (Exception e) {
+                Log.e(TAG, "Bluetooth connection failed", e);
+                return false;
+            }
+        }
+
+        public boolean connectWiFi(String ipAddress, int port) {
+            try {
+                wifiSocket = new Socket(ipAddress, port);
+                outputStream = wifiSocket.getOutputStream();
+                return true;
+            } catch (Exception e) {
+                Log.e(TAG, "WiFi connection failed", e);
+                return false;
+            }
+        }
+
+        public boolean sendData(byte[] data) {
+            try {
+                if (outputStream != null) {
+                    outputStream.write(data);
+                    outputStream.flush();
+                    return true;
+                }
+            } catch (IOException e) {
+                Log.e(TAG, "Error sending data", e);
+            }
+            return false;
+        }
+
+        public void disconnect() {
+            try {
+                if (outputStream != null) {
+                    outputStream.close();
+                }
+                if (bluetoothSocket != null) {
+                    bluetoothSocket.close();
+                }
+                if (wifiSocket != null) {
+                    wifiSocket.close();
+                }
+            } catch (IOException e) {
+                Log.e(TAG, "Error disconnecting", e);
+            }
+        }
+    }
+}