@m430/capacitor-label-printer 0.1.0

package/android/src/main/java/com/m430/capacitor/labelprinter/LabelPrinterPlugin.java

@@ -0,0 +1,273 @@
+package com.m430.capacitor.labelprinter;
+
+import android.Manifest;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Build;
+import android.provider.Settings;
+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 java.util.ArrayList;
+import java.util.List;
+
+@CapacitorPlugin(
+    name = "LabelPrinter",
+    permissions = {
+        @Permission(alias = "bluetoothConnect", strings = { Manifest.permission.BLUETOOTH_CONNECT }),
+        @Permission(alias = "bluetoothScan", strings = { Manifest.permission.BLUETOOTH_SCAN })
+    }
+)
+public class LabelPrinterPlugin extends Plugin {
+    private static final String BLUETOOTH_CONNECT_ALIAS = "bluetoothConnect";
+    private static final String BLUETOOTH_SCAN_ALIAS = "bluetoothScan";
+    private static final String[] DISCOVERY_PERMISSION_ALIASES = new String[] {
+        BLUETOOTH_CONNECT_ALIAS,
+        BLUETOOTH_SCAN_ALIAS
+    };
+    private static final String[] CONNECTION_PERMISSION_ALIASES = new String[] { BLUETOOTH_CONNECT_ALIAS };
+    private static final String PERMISSION_DENIED_CODE = "PERMISSION_DENIED";
+    private AndroidPrinterManager manager;
+
+    @Override
+    public void load() {
+        manager = new AndroidPrinterManager(new VendorAndroidDeviceCatalog(getContext()), new AndroidStatusMapper());
+    }
+
+    @PluginMethod
+    public void isSupported(PluginCall call) {
+        JSObject result = new JSObject();
+        result.put("supported", true);
+        call.resolve(result);
+    }
+
+    @PluginMethod
+    @Override
+    public void checkPermissions(PluginCall call) {
+        call.resolve(buildPermissionResult(currentBluetoothConnectState(), currentBluetoothScanState()));
+    }
+
+    @PluginMethod
+    public void ensurePermissions(PluginCall call) {
+        if (hasPermissionAliases(DISCOVERY_PERMISSION_ALIASES)) {
+            call.resolve(buildPermissionResult(currentBluetoothConnectState(), currentBluetoothScanState()));
+            return;
+        }
+
+        if (!requiresNearbyDevicesPermission()) {
+            call.resolve(buildPermissionResult(PermissionState.GRANTED, PermissionState.GRANTED));
+            return;
+        }
+
+        requestPermissionForAliases(DISCOVERY_PERMISSION_ALIASES, call, "ensurePermissionsCallback");
+    }
+
+    @PluginMethod
+    public void discoverDevices(PluginCall call) {
+        if (!hasPermissionAliases(DISCOVERY_PERMISSION_ALIASES)) {
+            if (!requiresNearbyDevicesPermission()) {
+                performDiscoverDevices(call);
+                return;
+            }
+
+            requestPermissionForAliases(DISCOVERY_PERMISSION_ALIASES, call, "discoverDevicesPermissionCallback");
+            return;
+        }
+
+        performDiscoverDevices(call);
+    }
+
+    @PluginMethod
+    public void connect(PluginCall call) {
+        if (!hasPermissionAliases(CONNECTION_PERMISSION_ALIASES)) {
+            if (!requiresNearbyDevicesPermission()) {
+                performConnect(call);
+                return;
+            }
+
+            requestPermissionForAliases(CONNECTION_PERMISSION_ALIASES, call, "connectPermissionCallback");
+            return;
+        }
+
+        performConnect(call);
+    }
+
+    @PluginMethod
+    public void disconnect(PluginCall call) {
+        manager.disconnect();
+        call.resolve();
+    }
+
+    @PluginMethod
+    public void getConnectionState(PluginCall call) {
+        call.resolve(manager.getConnectionState());
+    }
+
+    @PluginMethod
+    public void print(PluginCall call) {
+        if (!hasPermissionAliases(CONNECTION_PERMISSION_ALIASES)) {
+            rejectPermissionCall(call);
+            return;
+        }
+
+        String payload = call.getString("payload", "");
+        String language = call.getString("language", "tspl");
+        Integer copiesValue = call.getInt("copies", 1);
+        int copies = copiesValue != null ? copiesValue : 1;
+        try {
+            manager.print(payload, language, copies);
+            call.resolve();
+        } catch (Exception exception) {
+            call.reject(exception.getMessage(), exception);
+        }
+    }
+
+    @PluginMethod
+    public void getStatus(PluginCall call) {
+        call.resolve(manager.getStatus());
+    }
+
+    @PluginMethod
+    public void openAppSettings(PluginCall call) {
+        Intent intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
+        intent.setData(Uri.fromParts("package", getContext().getPackageName(), null));
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        getContext().startActivity(intent);
+        call.resolve();
+    }
+
+    @PermissionCallback
+    private void ensurePermissionsCallback(PluginCall call) {
+        call.resolve(buildPermissionResult(currentBluetoothConnectState(), currentBluetoothScanState()));
+    }
+
+    @PermissionCallback
+    private void discoverDevicesPermissionCallback(PluginCall call) {
+        if (!hasPermissionAliases(DISCOVERY_PERMISSION_ALIASES)) {
+            rejectPermissionCall(call);
+            return;
+        }
+
+        performDiscoverDevices(call);
+    }
+
+    @PermissionCallback
+    private void connectPermissionCallback(PluginCall call) {
+        if (!hasPermissionAliases(CONNECTION_PERMISSION_ALIASES)) {
+            rejectPermissionCall(call);
+            return;
+        }
+
+        performConnect(call);
+    }
+
+    private void performDiscoverDevices(PluginCall call) {
+        JSArray prefixesArray = call.getArray("namePrefixes");
+        List<String> prefixes = new ArrayList<>();
+        if (prefixesArray != null) {
+            for (int index = 0; index < prefixesArray.length(); index++) {
+                String item = prefixesArray.optString(index, null);
+                if (item != null) {
+                    prefixes.add(item);
+                }
+            }
+        }
+
+        try {
+            JSObject result = new JSObject();
+            result.put("devices", manager.getBondedDevices(prefixes));
+            call.resolve(result);
+        } catch (Exception exception) {
+            call.reject(exception.getMessage(), exception);
+        }
+    }
+
+    private void performConnect(PluginCall call) {
+        try {
+            manager.connect(call.getString("deviceId"));
+            call.resolve();
+        } catch (Exception exception) {
+            call.reject(exception.getMessage(), exception);
+        }
+    }
+
+    private void rejectPermissionCall(PluginCall call) {
+        call.reject(
+            "需要附近设备权限才能扫描、连接和打印蓝牙标签机",
+            PERMISSION_DENIED_CODE,
+            buildPermissionResult(currentBluetoothConnectState(), currentBluetoothScanState())
+        );
+    }
+
+    private boolean requiresNearbyDevicesPermission() {
+        return Build.VERSION.SDK_INT >= Build.VERSION_CODES.S;
+    }
+
+    private PermissionState currentBluetoothConnectState() {
+        if (!requiresNearbyDevicesPermission()) {
+            return PermissionState.GRANTED;
+        }
+        return getPermissionState(BLUETOOTH_CONNECT_ALIAS);
+    }
+
+    private PermissionState currentBluetoothScanState() {
+        if (!requiresNearbyDevicesPermission()) {
+            return PermissionState.GRANTED;
+        }
+        return getPermissionState(BLUETOOTH_SCAN_ALIAS);
+    }
+
+    private boolean hasPermissionAliases(String[] aliases) {
+        if (!requiresNearbyDevicesPermission()) {
+            return true;
+        }
+        for (String alias : aliases) {
+            if (getPermissionState(alias) != PermissionState.GRANTED) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private static PermissionState aggregateBluetoothState(PermissionState bluetoothConnect, PermissionState bluetoothScan) {
+        if (bluetoothConnect == PermissionState.DENIED || bluetoothScan == PermissionState.DENIED) {
+            return PermissionState.DENIED;
+        }
+        if (
+            bluetoothConnect == PermissionState.PROMPT_WITH_RATIONALE ||
+            bluetoothScan == PermissionState.PROMPT_WITH_RATIONALE
+        ) {
+            return PermissionState.PROMPT_WITH_RATIONALE;
+        }
+        if (bluetoothConnect == PermissionState.PROMPT || bluetoothScan == PermissionState.PROMPT) {
+            return PermissionState.PROMPT;
+        }
+        return PermissionState.GRANTED;
+    }
+
+    private static boolean canPrompt(PermissionState state) {
+        return state == PermissionState.PROMPT || state == PermissionState.PROMPT_WITH_RATIONALE;
+    }
+
+    private static JSObject buildPermissionResult(PermissionState bluetoothConnect, PermissionState bluetoothScan) {
+        PermissionState bluetooth = aggregateBluetoothState(bluetoothConnect, bluetoothScan);
+
+        JSObject permissions = new JSObject();
+        permissions.put("bluetoothConnect", bluetoothConnect.toString());
+        permissions.put("bluetoothScan", bluetoothScan.toString());
+        permissions.put("bluetooth", bluetooth.toString());
+
+        JSObject result = new JSObject();
+        result.put("granted", bluetooth == PermissionState.GRANTED);
+        result.put("canPrompt", canPrompt(bluetooth));
+        result.put("shouldOpenSettings", bluetooth != PermissionState.GRANTED && !canPrompt(bluetooth));
+        result.put("permissions", permissions);
+        return result;
+    }
+}

package/android/src/main/java/com/m430/capacitor/labelprinter/VendorAndroidDeviceCatalog.java

@@ -0,0 +1,81 @@
+package com.m430.capacitor.labelprinter;
+
+import android.annotation.SuppressLint;
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothDevice;
+import android.content.Context;
+import com.getcapacitor.JSArray;
+import com.getcapacitor.JSObject;
+import com.printer.psdk.device.bluetooth.Bluetooth;
+import java.util.List;
+import java.util.Set;
+
+final class VendorAndroidDeviceCatalog implements AndroidPrinterManager.DeviceCatalog {
+    private final Context appContext;
+    private final Bluetooth bluetooth;
+    private final BluetoothAdapter adapter;
+
+    VendorAndroidDeviceCatalog(Context context) {
+        appContext = context.getApplicationContext();
+        bluetooth = Bluetooth.getInstance();
+        bluetooth.initialize(appContext);
+        adapter = BluetoothAdapter.getDefaultAdapter();
+    }
+
+    @Override
+    @SuppressLint("MissingPermission")
+    public JSArray discover(List<String> prefixes) {
+        JSArray devices = new JSArray();
+        if (adapter == null || !bluetooth.hasConnectPermission(appContext)) {
+            return devices;
+        }
+
+        Set<BluetoothDevice> bonded = adapter.getBondedDevices();
+        for (BluetoothDevice device : bonded) {
+            if (!matchesPrefix(device.getName(), prefixes)) {
+                continue;
+            }
+
+            JSObject item = new JSObject();
+            item.put("id", device.getAddress());
+            item.put("name", device.getName());
+            item.put("address", device.getAddress());
+            item.put("transport", "classic");
+            item.put("bonded", true);
+            devices.put(item);
+        }
+
+        return devices;
+    }
+
+    @Override
+    @SuppressLint("MissingPermission")
+    public AndroidPrinterManager.PrinterSession openSession(String deviceId) {
+        if (adapter == null || deviceId == null || !bluetooth.hasConnectPermission(appContext)) {
+            return null;
+        }
+
+        for (BluetoothDevice device : adapter.getBondedDevices()) {
+            if (deviceId.equalsIgnoreCase(device.getAddress())) {
+                return new VendorAndroidPrinterSession(bluetooth, device);
+            }
+        }
+
+        return null;
+    }
+
+    private boolean matchesPrefix(String value, List<String> prefixes) {
+        if (value == null) {
+            return false;
+        }
+        if (prefixes == null || prefixes.isEmpty()) {
+            return true;
+        }
+        for (String prefix : prefixes) {
+            if (value.startsWith(prefix)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

package/android/src/main/java/com/m430/capacitor/labelprinter/VendorAndroidPrinterSession.java

@@ -0,0 +1,189 @@
+package com.m430.capacitor.labelprinter;
+
+import android.annotation.SuppressLint;
+import android.bluetooth.BluetoothDevice;
+import com.printer.psdk.device.adapter.ConnectedDevice;
+import com.printer.psdk.device.adapter.ReadOptions;
+import com.printer.psdk.device.adapter.types.WroteReporter;
+import com.printer.psdk.frame.father.args.common.Raw;
+import com.printer.psdk.device.bluetooth.Bluetooth;
+import com.printer.psdk.device.bluetooth.ConnectListener;
+import com.printer.psdk.device.bluetooth.Connection;
+import com.printer.psdk.tspl.GenericTSPL;
+import com.printer.psdk.tspl.TSPL;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+
+final class VendorAndroidPrinterSession implements AndroidPrinterManager.PrinterSession {
+    private final Connection connection;
+    private final TsplTransport tsplTransport;
+    private final VendorConnectListener listener = new VendorConnectListener();
+
+    VendorAndroidPrinterSession(Bluetooth bluetooth, BluetoothDevice device) {
+        connection = bluetooth.createConnectionClassic(device, listener);
+        tsplTransport = new SdkTsplTransport(connection);
+    }
+
+    VendorAndroidPrinterSession(Connection connection, TsplTransport tsplTransport) {
+        this.connection = connection;
+        this.tsplTransport = tsplTransport;
+    }
+
+    @Override
+    public void connect() throws IOException {
+        if (connection == null) {
+            throw new IOException("unable to create classic bluetooth connection");
+        }
+
+        boolean success = connection.connect(null);
+        if (!success || !connection.isConnected()) {
+            throw new IOException(listener.lastErrorMessage != null ? listener.lastErrorMessage : "connect failed");
+        }
+    }
+
+    @Override
+    public void disconnect() {
+        if (connection != null) {
+            connection.disconnect();
+        }
+    }
+
+    @Override
+    public boolean isConnected() {
+        return connection != null && connection.isConnected();
+    }
+
+    @Override
+    public String getConnectionState() {
+        if (connection == null) {
+            return "disconnected";
+        }
+
+        switch (connection.getState()) {
+            case Connection.STATE_CONNECTING:
+            case Connection.STATE_PAIRING:
+            case Connection.STATE_PAIRED:
+                return "connecting";
+            case Connection.STATE_CONNECTED:
+                return "connected";
+            default:
+                return "disconnected";
+        }
+    }
+
+    @Override
+    @SuppressLint("MissingPermission")
+    public String getDeviceName() {
+        if (connection == null || connection.getDevice() == null) {
+            return null;
+        }
+        return connection.getDevice().getName();
+    }
+
+    public void print(byte[] payload) throws IOException {
+        print("tspl", payload);
+    }
+
+    @Override
+    public void print(String language, byte[] payload) throws IOException {
+        if (connection == null) {
+            throw new IOException("printer connection is unavailable");
+        }
+        if (isTsplLanguage(language)) {
+            tsplTransport.send(payload);
+            return;
+        }
+        connection.write(payload);
+    }
+
+    @Override
+    public byte[] queryStatus() throws IOException {
+        if (connection == null) {
+            return null;
+        }
+        return tsplTransport.queryStatus();
+    }
+
+    interface TsplTransport {
+        void send(byte[] payload) throws IOException;
+
+        byte[] queryStatus() throws IOException;
+    }
+
+    static final class SdkTsplTransport implements TsplTransport {
+        private final Connection connection;
+
+        SdkTsplTransport(Connection connection) {
+            this.connection = connection;
+        }
+
+        @Override
+        public void send(byte[] payload) throws IOException {
+            String[] commands = splitCommands(payload);
+            if (commands.length == 0) {
+                throw new IOException("tspl payload does not contain any printable commands");
+            }
+
+            GenericTSPL tspl = TSPL.generic(connection);
+            for (String command : commands) {
+                tspl.raw(Raw.builder().command(command, StandardCharsets.UTF_8).build());
+            }
+            requireReporterOk(tspl.write(), "failed to write tspl payload");
+        }
+
+        @Override
+        public byte[] queryStatus() throws IOException {
+            GenericTSPL tspl = TSPL.generic(connection).state();
+            requireReporterOk(tspl.write(), "failed to query printer status");
+            return tspl.read(ReadOptions.builder().timeout(1500).build());
+        }
+
+        static String[] splitCommands(byte[] payload) {
+            return new String(payload, StandardCharsets.UTF_8)
+                .replace("\r\n", "\n")
+                .replace('\r', '\n')
+                .lines()
+                .map(String::trim)
+                .filter(command -> !command.isEmpty())
+                .toArray(String[]::new);
+        }
+
+        private static void requireReporterOk(WroteReporter reporter, String fallbackMessage) throws IOException {
+            if (reporter.isOk()) {
+                return;
+            }
+
+            throw new IOException(
+                reporter.getException() != null ? reporter.getException().getMessage() : fallbackMessage,
+                reporter.getException()
+            );
+        }
+    }
+
+    private static boolean isTsplLanguage(String language) {
+        return language == null || language.trim().isEmpty() || "tspl".equalsIgnoreCase(language);
+    }
+
+    private static final class VendorConnectListener implements ConnectListener {
+        private String lastErrorMessage;
+
+        @Override
+        public void onConnectSuccess(ConnectedDevice connectedDevice) {
+            lastErrorMessage = null;
+        }
+
+        @Override
+        public void onConnectFail(String errMsg, Throwable throwable) {
+            if (throwable != null && throwable.getMessage() != null) {
+                lastErrorMessage = errMsg + ": " + throwable.getMessage();
+                return;
+            }
+            lastErrorMessage = errMsg;
+        }
+
+        @Override
+        public void onConnectionStateChanged(BluetoothDevice device, int state) {
+            // 状态直接从 Connection.getState() 读取，这里无需额外处理。
+        }
+    }
+}

package/capacitor-label-printer.podspec

@@ -0,0 +1,21 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+repository_url = package.dig('repository', 'url').to_s.sub(/^git\+/, '')
+homepage_url = repository_url.sub(/\.git$/, '')
+
+Pod::Spec.new do |s|
+  s.name = 'M430CapacitorLabelPrinter'
+  s.version = package['version']
+  s.summary = package['description']
+  s.license = package['license']
+  s.homepage = homepage_url
+  s.author = package['author']
+  s.source = { git: repository_url, tag: s.version.to_s }
+  s.source_files = 'ios/Plugin/**/*.{swift,h,m,mm}'
+  s.vendored_frameworks = 'ios/VendorFrameworks/*.framework', 'ios/VendorFrameworks/*.xcframework'
+  s.preserve_paths = 'ios/VendorFrameworks/**/*'
+  s.ios.deployment_target = '13.0'
+  s.dependency 'Capacitor'
+  s.swift_version = '5.9'
+end