@autorunify/capacitor-bleprinter 0.0.1

package/android/src/main/java/com/autorunify/capacitor/bleprinter/BleManager.kt

@@ -0,0 +1,214 @@
+package com.autorunify.capacitor.bleprinter
+
+import android.app.Activity
+import android.bluetooth.BluetoothAdapter
+import android.bluetooth.BluetoothDevice
+import android.bluetooth.BluetoothManager
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.content.pm.PackageManager
+import androidx.lifecycle.MutableLiveData
+import com.autorunify.capacitor.bleprinter.SystemAsyncCall.Companion.PRINTER_STATE_CONNECTED
+import com.autorunify.capacitor.bleprinter.SystemAsyncCall.Companion.PRINTER_STATE_DISCONNECTED
+import com.getcapacitor.JSObject
+import com.getcapacitor.PluginCall
+import no.nordicsemi.android.support.v18.scanner.BluetoothLeScannerCompat
+import no.nordicsemi.android.support.v18.scanner.ScanCallback
+import no.nordicsemi.android.support.v18.scanner.ScanFilter
+import no.nordicsemi.android.support.v18.scanner.ScanResult
+import no.nordicsemi.android.support.v18.scanner.ScanSettings
+
+
+class BleManager {
+    private class StateReceiver : BroadcastReceiver {
+        private val ble: BleManager
+
+        constructor(bleManager: BleManager) {
+            this.ble = bleManager
+        }
+
+        override fun onReceive(context: Context, intent: Intent) {
+            val eventName = "state"
+            val state = intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, BluetoothAdapter.ERROR)
+
+            when (state) {
+                BluetoothAdapter.STATE_ON -> {
+                    ble.notify.notifyListeners(eventName, JSObject().apply {
+                        ble.isConnected.postValue(false)
+                        put("action", "enabled")
+                        put("state", true)
+                    })
+                }
+
+                BluetoothAdapter.STATE_OFF -> {
+                    ble.notify.notifyListeners(eventName, JSObject().apply {
+                        ble.isConnected.postValue(false)
+                        put("action", "enabled")
+                        put("state", false)
+                    })
+                }
+            }
+
+            when (intent.action) {
+                BluetoothDevice.ACTION_ACL_CONNECTED -> {
+                    ble.isConnected.postValue(true)
+                    ble.notify.notifyListeners(eventName, JSObject().apply {
+                        put("action", "connected")
+                        put("state", true)
+                    })
+
+                    ble.async.emit(JSObject(), PRINTER_STATE_CONNECTED)
+                }
+
+                BluetoothDevice.ACTION_ACL_DISCONNECTED -> {
+                    ble.isConnected.postValue(false)
+                    ble.notify.notifyListeners(eventName, JSObject().apply {
+                        put("action", "connected")
+                        put("state", false)
+                    })
+                    ble.async.emit(JSObject(), PRINTER_STATE_DISCONNECTED)
+                }
+            }
+        }
+    }
+
+    private class ScanReceiver : ScanCallback {
+        private val ble: BleManager
+
+        constructor(bleManager: BleManager) {
+            this.ble = bleManager
+        }
+
+        override fun onScanResult(callbackType: Int, result: ScanResult) {
+            val device = BleDevice(result)
+            synchronized(ble.devices) {
+                if (!ble.devices.contains(device)) {
+                    ble.devices.add(device)
+                }
+            }
+        }
+
+        override fun onScanFailed(errorCode: Int) {
+            ble.scan(false)
+        }
+    }
+
+    val notify: BlePrinterPlugin
+    val async: AsyncManager
+
+    private lateinit var context: Context
+    private lateinit var adapter: BluetoothAdapter
+    private lateinit var stateReceiver: StateReceiver
+    private lateinit var scanReceiver: ScanReceiver
+
+    private var isSupported: Boolean = false
+    private var isScanning: Boolean = false
+
+    var filters: MutableList<ScanFilter> = mutableListOf()
+    val devices: MutableList<BleDevice> = mutableListOf()
+    val isConnected = MutableLiveData<Boolean>(false)
+
+    constructor(notify: BlePrinterPlugin, asyncManager: AsyncManager) {
+        this.notify = notify
+        this.async = asyncManager
+    }
+
+    fun load(activity: Activity, context: Context) {
+        this.isSupported =
+            activity.packageManager.hasSystemFeature(PackageManager.FEATURE_BLUETOOTH_LE)
+        if (!this.isSupported) return
+
+        val manager = context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
+        this.adapter = manager.adapter
+        this.context = context
+
+        this.stateReceiver = StateReceiver(this)
+        this.scanReceiver = ScanReceiver(this)
+    }
+
+    fun init() {
+        isConnected.postValue(false)
+        try {
+            val filter = IntentFilter(BluetoothAdapter.ACTION_STATE_CHANGED)
+            filter.addAction(BluetoothDevice.ACTION_ACL_CONNECTED)
+            filter.addAction(BluetoothDevice.ACTION_ACL_DISCONNECTED)
+            context.registerReceiver(this.stateReceiver, filter)
+        } catch (ex: Exception) {
+        }
+    }
+
+    fun kill() {
+        isConnected.postValue(false)
+        try {
+            context.unregisterReceiver(this.stateReceiver)
+        } catch (ex: Exception) {
+        }
+    }
+
+    fun assertFeature(call: PluginCall): Boolean {
+        if (!isSupported) {
+            call.reject("BLE is not supported.")
+            return false
+        }
+
+        return true
+    }
+
+    fun assertAdapter(call: PluginCall): Boolean {
+        if (adapter == null) {
+            call.reject("BLE is not available.")
+            return false
+        }
+
+        return true
+    }
+
+    fun assertEnabled(call: PluginCall): Boolean {
+        if (adapter != null && adapter.isEnabled) {
+            return true
+        }
+
+        call.reject("BLE is not enabled")
+        return false
+    }
+
+    fun assertConnected(call: PluginCall): Boolean {
+        if (isConnected.value == true) return true
+
+        call.reject("BLE is not connected")
+        return false
+    }
+
+    fun isEnabled(): Boolean {
+        if (adapter != null) return adapter.isEnabled
+        return false
+    }
+
+    fun scan(startScan: Boolean) {
+        if (startScan) {
+            val settings = ScanSettings.Builder()
+                .setScanMode(ScanSettings.SCAN_MODE_LOW_LATENCY)
+                .setUseHardwareFilteringIfSupported(false)
+                .setReportDelay(0)
+                .build()
+
+            synchronized(this) {
+                if (isScanning) return
+                isScanning = true
+
+                val scanner = BluetoothLeScannerCompat.getScanner()
+                scanner.startScan(filters, settings, scanReceiver)
+            }
+        } else {
+            synchronized(this) {
+                if (!isScanning) return
+                isScanning = false
+
+                val scanner = BluetoothLeScannerCompat.getScanner()
+                scanner.stopScan(scanReceiver)
+            }
+        }
+    }
+}

package/android/src/main/java/com/autorunify/capacitor/bleprinter/BlePrinter.kt

@@ -0,0 +1,29 @@
+package com.autorunify.capacitor.bleprinter
+
+import android.graphics.Bitmap
+
+abstract class BlePrinter {
+    protected val scaner: BleManager
+
+    constructor(scanner: BleManager) {
+        this.scaner = scanner
+    }
+
+    protected fun px2mm(px: Double, dpi: Int): Double {
+        return (px * 25.4) / dpi
+    }
+
+    protected fun mm2px(mm: Double, dpi: Int): Double {
+        return (mm * dpi) / 25.4
+    }
+
+    abstract fun init()
+    abstract fun kill()
+
+    abstract suspend fun devices(timeout: Int): MutableList<BleDevice>
+
+    abstract fun connect(address: String)
+    abstract fun disconnect()
+
+    abstract fun printImage(bitmap: Bitmap, width: Int, height: Int)
+}

package/android/src/main/java/com/autorunify/capacitor/bleprinter/BlePrinterPlugin.kt

@@ -0,0 +1,272 @@
+package com.autorunify.capacitor.bleprinter
+
+import android.content.pm.PackageManager
+import android.graphics.Bitmap
+import androidx.core.app.ActivityCompat
+import com.autorunify.capacitor.bleprinter.SystemAsyncCall.Companion.PRINTER_PRINT_FINISHED
+import com.autorunify.capacitor.bleprinter.SystemAsyncCall.Companion.PRINTER_STATE_CONNECTED
+import com.autorunify.capacitor.bleprinter.SystemAsyncCall.Companion.PRINTER_STATE_DISCONNECTED
+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.CapacitorPlugin
+import com.getcapacitor.annotation.Permission
+import com.getcapacitor.annotation.PermissionCallback
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+
+
+@CapacitorPlugin(
+    name = "BlePrinter",
+    permissions = [
+        Permission(
+            strings = [
+                "android.permission.BLUETOOTH",
+                "android.permission.BLUETOOTH_ADMIN",
+                "android.permission.ACCESS_COARSE_LOCATION",
+                "android.permission.ACCESS_FINE_LOCATION",
+            ], alias = "ANDROID_R"
+        ),
+        Permission(
+            strings = [
+                "android.permission.BLUETOOTH_SCAN",
+                "android.permission.BLUETOOTH_CONNECT",
+            ], alias = "ANDROID_S"
+        )]
+)
+class BlePrinterPlugin : Plugin {
+    private var alias: String = "ANDROID_R"
+    private val defaultTimeout = 20
+    private var printer: BlePrinter? = null
+    private val formatter = FormatManager()
+    private val async = AsyncManager()
+    private val ble = BleManager(this, async)
+
+
+    constructor() {
+        if (android.os.Build.VERSION.SDK_INT > android.os.Build.VERSION_CODES.R) {
+            this.alias = "ANDROID_S"
+        }
+    }
+
+    @PermissionCallback
+    @PluginMethod
+    override fun checkPermissions(call: PluginCall) {
+
+        val permissions = super.handle.pluginAnnotation.permissions
+
+        call.resolve(JSObject().apply {
+            permissions.forEach { permission ->
+                if (permission.alias == alias) {
+                    permission.strings.forEach { key ->
+                        val status = ActivityCompat.checkSelfPermission(context, key)
+                        val state = if (status == PackageManager.PERMISSION_DENIED) {
+                            PermissionState.DENIED
+                        } else {
+                            PermissionState.GRANTED
+                        }
+                        put(key, state)
+                    }
+                }
+            }
+        })
+    }
+
+    @PluginMethod
+    override fun requestPermissions(call: PluginCall) {
+        super.requestPermissionForAlias(this.alias, call, "checkPermissions")
+    }
+
+    @PluginMethod
+    fun isBluetoothEnabled(call: PluginCall) {
+        call.resolve(JSObject().apply {
+            put("enabled", ble.isEnabled())
+        })
+    }
+
+    public override fun notifyListeners(eventName: String?, data: JSObject?) {
+        super.notifyListeners(eventName, data)
+    }
+
+    override fun load() {
+        super.load()
+        ble.load(activity, context)
+    }
+
+    fun assertPrinter(call: PluginCall): Boolean {
+        if (printer == null) {
+            call.reject("printer is not init.")
+            return false
+        }
+
+        return true
+    }
+
+    @PluginMethod
+    fun init(call: PluginCall) {
+        if (!this.ble.assertFeature(call)) return
+        if (!this.ble.assertAdapter(call)) return
+        if (!this.ble.assertEnabled(call)) return
+
+        if (printer != null) return call.resolve()
+
+        val manufacturer = call.getString("manufacturer")
+            ?: return call.reject("manufacturer is required")
+
+        try {
+            when (manufacturer) {
+                "DotHanTech" -> printer = DotHanTechPrinter(ble)
+                else -> return call.reject("manufacturer is not supported $manufacturer")
+            }
+
+            ble.init()
+            printer!!.init()
+
+            call.resolve()
+        } catch (ex: Exception) {
+            call.reject(ex.message)
+        }
+    }
+
+    @PluginMethod
+    fun kill(call: PluginCall) {
+        if (!this.ble.assertFeature(call)) return
+        if (!this.ble.assertAdapter(call)) return
+        if (!this.ble.assertEnabled(call)) return
+
+        if (printer == null) return call.resolve()
+
+        ble.kill()
+        printer!!.kill()
+        printer = null
+    }
+
+    @PluginMethod
+    fun devices(call: PluginCall) {
+        if (!this.ble.assertFeature(call)) return
+        if (!this.ble.assertAdapter(call)) return
+        if (!this.ble.assertEnabled(call)) return
+        if (!this.assertPrinter(call)) return
+
+        CoroutineScope(Dispatchers.IO).launch {
+            try {
+                val timeout = call.getInt("timeout", 5000)
+                val devices = printer!!.devices(timeout!!)
+
+                call.resolve(JSObject().apply {
+                    put("devices", JSArray().apply {
+                        devices.forEach { device ->
+                            put(formatter.toJSON(device))
+                        }
+                    })
+                })
+            } catch (ex: Exception) {
+                call.reject(ex.message)
+            }
+        }
+    }
+
+    @PluginMethod
+    fun isConnected(call: PluginCall) {
+        if (!this.ble.assertFeature(call)) return
+        if (!this.ble.assertAdapter(call)) return
+        if (!this.ble.assertEnabled(call)) return
+        if (!this.assertPrinter(call)) return
+
+        call.resolve(JSObject().apply {
+            put("connected", ble.isConnected.value)
+        })
+    }
+
+    @PluginMethod
+    fun connect(call: PluginCall) {
+        if (!this.ble.assertFeature(call)) return
+        if (!this.ble.assertAdapter(call)) return
+        if (!this.ble.assertEnabled(call)) return
+        if (!this.assertPrinter(call)) return
+
+        CoroutineScope(Dispatchers.IO).launch {
+            try {
+                val timeout = call.getInt("timeout", defaultTimeout)
+                val address = call.getString("address")
+                    ?: return@launch call.reject("address is required")
+
+
+                async.on(call, PRINTER_STATE_CONNECTED).timeout(timeout!!)
+                printer?.connect(address)
+            } catch (ex: Exception) {
+                call.reject(ex.message)
+            }
+        }
+    }
+
+    @PluginMethod
+    fun disconnect(call: PluginCall) {
+        if (!this.ble.assertFeature(call)) return
+        if (!this.ble.assertAdapter(call)) return
+        if (!this.ble.assertEnabled(call)) return
+        if (!this.assertPrinter(call)) return
+        if (!this.ble.assertConnected(call)) return
+
+        CoroutineScope(Dispatchers.IO).launch {
+            try {
+                val timeout = call.getInt("timeout", defaultTimeout)
+
+                async.on(call, PRINTER_STATE_DISCONNECTED).timeout(timeout!!)
+                printer?.disconnect()
+            } catch (ex: Exception) {
+                call.reject(ex.message)
+            }
+        }
+    }
+
+    @PluginMethod
+    fun printImage(call: PluginCall) {
+        if (!this.ble.assertFeature(call)) return
+        if (!this.ble.assertAdapter(call)) return
+        if (!this.ble.assertEnabled(call)) return
+        if (!this.assertPrinter(call)) return
+        if (!this.ble.assertConnected(call)) return
+
+        CoroutineScope(Dispatchers.IO).launch {
+            try {
+                val width = call.getInt("width")
+                    ?: return@launch call.reject("width is required")
+                val height = call.getInt("height")
+                    ?: return@launch call.reject("height is required")
+                val imageData = call.getObject("imageData")
+                    ?: return@launch call.reject("imageData is required")
+
+                val colors = IntArray(imageData.length() / 4)
+
+                for (i in 0..<colors.size) {
+                    val R = imageData.getInt((i * 4 + 0).toString())
+                    val G = imageData.getInt((i * 4 + 1).toString())
+                    val B = imageData.getInt((i * 4 + 2).toString())
+                    val A = imageData.getInt((i * 4 + 3).toString())
+
+                    var color = 0
+                    color += ((A and 0xff) shl 24)
+                    color += ((G and 0xff) shl 16)
+                    color += ((B and 0xff) shl 8)
+                    color += ((R and 0xff) shl 0)
+
+                    colors[i] = color
+                }
+
+                async.on(call,PRINTER_PRINT_FINISHED)
+                printer!!.printImage(
+                    Bitmap.createBitmap(colors, width, height, Bitmap.Config.ARGB_8888),
+                    width,
+                    height
+                )
+            } catch (ex: Exception) {
+                call.reject(ex.message)
+            }
+        }
+    }
+}

package/android/src/main/java/com/autorunify/capacitor/bleprinter/DotHanTechPrinter.kt

@@ -0,0 +1,120 @@
+package com.autorunify.capacitor.bleprinter
+
+import android.graphics.Bitmap
+import android.os.ParcelUuid
+import android.util.Log
+import com.autorunify.capacitor.bleprinter.SystemAsyncCall.Companion.PRINTER_PRINT_FINISHED
+import com.dothantech.lpapi.LPAPI
+import com.dothantech.printer.IDzPrinter
+import com.getcapacitor.JSObject
+import kotlinx.coroutines.delay
+import no.nordicsemi.android.support.v18.scanner.ScanFilter
+import java.util.UUID
+
+class DotHanTechPrinter : BlePrinter {
+    private class DotHanTechReceiver : LPAPI.Callback {
+        private val printer: DotHanTechPrinter
+
+        constructor(blePrinter: DotHanTechPrinter) {
+            this.printer = blePrinter
+        }
+
+        override fun onProgressInfo(p0: IDzPrinter.ProgressInfo?, p1: Any?) {
+            Log.w("BlePrinter", "onProgressInfo: ${p0?.name}")
+        }
+
+        override fun onStateChange(p0: IDzPrinter.PrinterAddress?, p1: IDzPrinter.PrinterState?) {
+            Log.w("BlePrinter", "onStateChange: ${p0?.shownName} ${p1?.name}")
+        }
+
+        override fun onPrintProgress(
+            p0: IDzPrinter.PrinterAddress?,
+            p1: IDzPrinter.PrintData?,
+            p2: IDzPrinter.PrintProgress?,
+            p3: Any?
+        ) {
+            Log.w("BlePrinter", "onPrintProgress: ${p0?.shownName} ${p2?.name}")
+            if (p2 == IDzPrinter.PrintProgress.Success) {
+                printer.async.emit(JSObject().apply {
+                    put("state", "success")
+                }, PRINTER_PRINT_FINISHED)
+            }
+
+            if (p2 == IDzPrinter.PrintProgress.Failed) {
+                printer.async.emit(JSObject().apply {
+                    put("state", "failed")
+                }, PRINTER_PRINT_FINISHED)
+            }
+        }
+
+        override fun onPrinterDiscovery(p0: IDzPrinter.PrinterAddress?, p1: Any?) {
+            Log.w("BlePrinter", "onPrinterDiscovery: ${p0?.shownName}")
+        }
+    }
+
+    private val async: AsyncManager
+    private val receiver: DotHanTechReceiver = DotHanTechReceiver(this)
+    private lateinit var adapter: LPAPI
+    private val DPI = 300
+
+    constructor(scanner: BleManager) : super(scanner) {
+        this.async = scanner.async
+    }
+
+    override fun init() {
+        this.adapter = LPAPI.Factory.createInstance(receiver)
+    }
+
+    override fun kill() {
+        this.adapter.closePrinter()
+    }
+
+    override suspend fun devices(timeout: Int): MutableList<BleDevice> {
+        this.scaner.scan(false)
+        this.scaner.filters = mutableListOf<ScanFilter>()
+        this.scaner.filters.add(
+            ScanFilter.Builder()
+                .setServiceUuid(ParcelUuid(UUID.fromString("000018f0-0000-1000-8000-00805f9b34fb")))
+                .build()
+
+        )
+
+        this.scaner.devices.clear()
+        this.scaner.scan(true);
+        delay(timeout.toLong())
+
+        this.scaner.scan(false)
+        val _devices: MutableList<BleDevice> = mutableListOf()
+
+        synchronized(scaner.devices) {
+            scaner.devices.forEach { device ->
+                _devices.add(device)
+            }
+        }
+        return _devices
+    }
+
+    override fun connect(address: String) {
+        val _device = scaner.devices.firstOrNull { device -> device.address == address }
+        if (_device == null) return
+
+        val address = IDzPrinter.PrinterAddress(_device.address, IDzPrinter.AddressType.BLE)
+        this.adapter.openPrinterByAddressSync(address)
+        this.adapter.setPrintPageGapType(0)
+    }
+
+    override fun disconnect() {
+        if (this.adapter.isPrinterOpened) {
+            this.adapter.closePrinter()
+        }
+    }
+
+    override fun printImage(bitmap: Bitmap, width: Int, height: Int) {
+        val widthMm = px2mm(width.toDouble(), DPI)
+        val heightMm = px2mm(height.toDouble(), DPI) + 10
+
+        if (!adapter.startJob(widthMm, heightMm, 0)) return
+        if (!adapter.drawBitmapWithThreshold(bitmap, 0.0, 0.0, 0.0, 0.0, 256)) return
+        adapter.commitJob()
+    }
+}

package/android/src/main/java/com/autorunify/capacitor/bleprinter/FormatManager.kt

@@ -0,0 +1,13 @@
+package com.autorunify.capacitor.bleprinter
+
+import com.getcapacitor.JSObject
+
+class FormatManager {
+    fun toJSON(device: BleDevice): JSObject {
+        return JSObject().apply {
+            put("address", device.address)
+            put("name", device.name)
+            put("rssi", device.rssi)
+        }
+    }
+}