@sincpro/printer-expo 0.1.2 → 1.0.0

package/android/src/main/java/expo/sincpro/managers/BluetoothManager.kt

@@ -1,139 +0,0 @@
-package expo.sincpro.managers
-
-import android.content.Context
-import android.util.Log
-import android.bluetooth.BluetoothAdapter
-import android.bluetooth.BluetoothDevice
-import android.bluetooth.BluetoothManager
-import expo.sincpro.bixolon.BixolonQRPrinter
-
-class BluetoothManager(private val context: Context) {
-    private val TAG = "BluetoothManager"
-    private val bluetoothManager = context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
-    private val bluetoothAdapter = bluetoothManager.adapter
-
-    fun isBluetoothEnabled(): Boolean {
-        return try {
-            val isEnabled = bluetoothAdapter != null && bluetoothAdapter.isEnabled
-            Log.d(TAG, "Bluetooth enabled: $isEnabled")
-            isEnabled
-        } catch (e: Exception) {
-            Log.e(TAG, "Error checking Bluetooth status: ${e.message}")
-            false
-        }
-    }
-
-    fun discoverBluetoothDevices(): List<Map<String, Any>> {
-        try {
-            Log.d(TAG, "Starting Bluetooth device discovery")
-            
-            if (bluetoothAdapter == null) {
-                throw Exception("Bluetooth not supported on this device")
-            }
-            
-            if (!bluetoothAdapter.isEnabled) {
-                throw Exception("Bluetooth is not enabled")
-            }
-            
-            val pairedDevices = bluetoothAdapter.bondedDevices
-            val deviceList = mutableListOf<Map<String, Any>>()
-            
-            for (device in pairedDevices) {
-                val deviceInfo = mapOf(
-                    "name" to (device.name ?: "Unknown Device"),
-                    "address" to device.address,
-                    "type" to when (device.type) {
-                        BluetoothDevice.DEVICE_TYPE_CLASSIC -> "CLASSIC"
-                        BluetoothDevice.DEVICE_TYPE_LE -> "LE"
-                        BluetoothDevice.DEVICE_TYPE_DUAL -> "DUAL"
-                        else -> "UNKNOWN"
-                    },
-                    "isPrinter" to isPrinterDevice(device.name)
-                )
-                deviceList.add(deviceInfo)
-            }
-            
-            Log.d(TAG, "Found ${deviceList.size} Bluetooth devices")
-            return deviceList
-            
-        } catch (e: Exception) {
-            Log.e(TAG, "Error discovering Bluetooth devices: ${e.message}")
-            throw e
-        }
-    }
-
-    fun startBluetoothDiscovery(): Boolean {
-        try {
-            Log.d(TAG, "Starting Bluetooth discovery")
-            
-            if (bluetoothAdapter == null) {
-                throw Exception("Bluetooth not supported on this device")
-            }
-            
-            if (!bluetoothAdapter.isEnabled) {
-                throw Exception("Bluetooth is not enabled")
-            }
-            
-            return if (bluetoothAdapter.startDiscovery()) {
-                Log.d(TAG, "Bluetooth discovery started")
-                true
-            } else {
-                throw Exception("Failed to start Bluetooth discovery")
-            }
-            
-        } catch (e: Exception) {
-            Log.e(TAG, "Error starting Bluetooth discovery: ${e.message}")
-            throw e
-        }
-    }
-
-    fun stopBluetoothDiscovery(): Boolean {
-        try {
-            Log.d(TAG, "Stopping Bluetooth discovery")
-            
-            if (bluetoothAdapter != null && bluetoothAdapter.isDiscovering) {
-                bluetoothAdapter.cancelDiscovery()
-                Log.d(TAG, "Bluetooth discovery stopped")
-            }
-            
-            return true
-            
-        } catch (e: Exception) {
-            Log.e(TAG, "Error stopping Bluetooth discovery: ${e.message}")
-            throw e
-        }
-    }
-
-    fun connectBluetooth(bixolonQRPrinter: BixolonQRPrinter, address: String): Boolean {
-        return try {
-            Log.d(TAG, "Attempting Bluetooth connection to $address using Bixolon SDK")
-            
-            val success = bixolonQRPrinter.connectBluetooth(address)
-            
-            if (success) {
-                Log.d(TAG, "Bluetooth connection established successfully using Bixolon SDK")
-                true
-            } else {
-                Log.e(TAG, "Failed to connect using Bixolon SDK")
-                false
-            }
-            
-        } catch (e: Exception) {
-            Log.e(TAG, "Error connecting via Bluetooth: ${e.message}")
-            false
-        }
-    }
-
-    private fun isPrinterDevice(deviceName: String?): Boolean {
-        if (deviceName == null) return false
-        
-        val printerKeywords = listOf(
-            "printer", "print", "bixolon", "label", "thermal", "receipt",
-            "impresora", "etiqueta", "termica", "ticket", "pos", "terminal"
-        )
-        
-        return printerKeywords.any { keyword ->
-            deviceName.lowercase().contains(keyword.lowercase())
-        }
-    }
-}

package/android/src/main/java/expo/sincpro/managers/ConnectionManager.kt

@@ -1,124 +0,0 @@
-package expo.sincpro.managers
-
-import android.util.Log
-import expo.sincpro.bixolon.BixolonQRPrinter
-
-class ConnectionManager(private val bixolonQRPrinter: BixolonQRPrinter) {
-    private val TAG = "ConnectionManager"
-    private var isInitialized = false
-    private var isConnected = false
-    private var currentAddress: String? = null
-    private var currentPort: Int = 0
-
-    fun initialize(): Boolean {
-        return try {
-            Log.d(TAG, "Initializing printer with Bixolon libraries")
-            
-            val bixolonInitialized = bixolonQRPrinter.initialize()
-            
-            if (bixolonInitialized) {
-                isInitialized = true
-                Log.d(TAG, "Printer initialized successfully with Bixolon libraries")
-                true
-            } else {
-                Log.e(TAG, "Failed to initialize Bixolon printer")
-                false
-            }
-        } catch (e: Exception) {
-            Log.e(TAG, "Error initializing printer: ${e.message}")
-            throw e
-        }
-    }
-
-    fun connect(interfaceType: String, address: String, port: Int, bluetoothManager: BluetoothManager): Boolean {
-        return try {
-            Log.d(TAG, "Attempting to connect to printer via $interfaceType at $address:$port")
-            
-            if (!isInitialized) {
-                throw Exception("Printer not initialized. Call initialize() first.")
-            }
-            
-            currentAddress = address
-            currentPort = port
-            
-            var connectionSuccess = false
-            when (interfaceType.lowercase()) {
-                "bluetooth" -> {
-                    Log.d(TAG, "Connecting via Bluetooth to $address")
-                    connectionSuccess = bluetoothManager.connectBluetooth(bixolonQRPrinter, address)
-                }
-                "wifi" -> {
-                    Log.d(TAG, "Connecting via WiFi to $address:$port")
-                    connectionSuccess = bixolonQRPrinter.connectWiFi(address, port)
-                }
-                "usb" -> {
-                    Log.d(TAG, "Connecting via USB")
-                    connectionSuccess = bixolonQRPrinter.connectUSB()
-                }
-                else -> {
-                    throw Exception("Unsupported interface type: $interfaceType")
-                }
-            }
-            
-            if (!connectionSuccess) {
-                throw Exception("Failed to connect via $interfaceType")
-            }
-            
-            isConnected = true
-            Log.d(TAG, "Connected successfully to printer via $interfaceType")
-            
-            try {
-                bixolonQRPrinter.clearAllMemory()
-                Log.d(TAG, "Memory cleared after connection")
-            } catch (e: Exception) {
-                Log.w(TAG, "Warning: Could not clear memory after connection: ${e.message}")
-            }
-            
-            true
-        } catch (e: Exception) {
-            Log.e(TAG, "Error connecting to printer: ${e.message}")
-            throw e
-        }
-    }
-
-    fun disconnect(): Boolean {
-        return try {
-            Log.d(TAG, "Disconnecting from printer")
-            
-            bixolonQRPrinter.disconnect()
-            
-            isConnected = false
-            currentAddress = null
-            currentPort = 0
-            
-            true
-        } catch (e: Exception) {
-            Log.e(TAG, "Error disconnecting from printer: ${e.message}")
-            throw e
-        }
-    }
-
-    fun executeCommand(command: String): Boolean {
-        return try {
-            Log.d(TAG, "Executing direct command: $command")
-            
-            if (!isConnected) {
-                throw Exception("Printer not connected")
-            }
-            
-            val commandBytes = command.toByteArray()
-            
-            Log.d(TAG, "Command '$command' sent successfully to printer")
-            true
-            
-        } catch (e: Exception) {
-            Log.e(TAG, "Error executing command: ${e.message}")
-            throw e
-        }
-    }
-
-    fun isInitialized(): Boolean = isInitialized
-    fun isConnected(): Boolean = isConnected
-    fun getCurrentAddress(): String? = currentAddress
-    fun getCurrentPort(): Int = currentPort
-}

package/android/src/main/java/expo/sincpro/managers/PermissionManager.kt

@@ -1,122 +0,0 @@
-package expo.sincpro.managers
-
-import android.app.Activity
-import android.content.Context
-import android.content.pm.PackageManager
-import android.os.Build
-import android.util.Log
-import androidx.core.app.ActivityCompat
-import androidx.core.content.ContextCompat
-
-class PermissionManager(private val context: Context) {
-    private val TAG = "PermissionManager"
-
-    fun requestBluetoothPermissions(currentActivity: Activity?): Boolean {
-        try {
-            Log.d(TAG, "Requesting Bluetooth permissions")
-            
-            if (currentActivity == null) {
-                Log.w(TAG, "No current activity available for permission request")
-                return false
-            }
-            
-            val permissions = mutableListOf<String>()
-            
-            if (ContextCompat.checkSelfPermission(context, android.Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
-                permissions.add(android.Manifest.permission.ACCESS_FINE_LOCATION)
-            }
-            
-            if (ContextCompat.checkSelfPermission(context, android.Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
-                permissions.add(android.Manifest.permission.ACCESS_COARSE_LOCATION)
-            }
-            
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-                if (ContextCompat.checkSelfPermission(context, android.Manifest.permission.BLUETOOTH_SCAN) != PackageManager.PERMISSION_GRANTED) {
-                    permissions.add(android.Manifest.permission.BLUETOOTH_SCAN)
-                }
-                if (ContextCompat.checkSelfPermission(context, android.Manifest.permission.BLUETOOTH_CONNECT) != PackageManager.PERMISSION_GRANTED) {
-                    permissions.add(android.Manifest.permission.BLUETOOTH_CONNECT)
-                }
-            }
-            
-            if (permissions.isEmpty()) {
-                Log.d(TAG, "All permissions already granted")
-                return true
-            }
-            
-            Log.d(TAG, "Requesting permissions: ${permissions.joinToString()}")
-            
-            ActivityCompat.requestPermissions(
-                currentActivity,
-                permissions.toTypedArray(),
-                1001
-            )
-            
-            return true
-            
-        } catch (e: Exception) {
-            Log.e(TAG, "Error requesting Bluetooth permissions: ${e.message}")
-            return false
-        }
-    }
-
-    fun checkBluetoothPermissions(): Map<String, Boolean> {
-        try {
-            Log.d(TAG, "Checking Bluetooth permissions")
-            
-            val results = mutableMapOf<String, Boolean>()
-            
-            results["ACCESS_FINE_LOCATION"] = ContextCompat.checkSelfPermission(
-                context, 
-                android.Manifest.permission.ACCESS_FINE_LOCATION
-            ) == PackageManager.PERMISSION_GRANTED
-            
-            results["ACCESS_COARSE_LOCATION"] = ContextCompat.checkSelfPermission(
-                context, 
-                android.Manifest.permission.ACCESS_COARSE_LOCATION
-            ) == PackageManager.PERMISSION_GRANTED
-            
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-                results["BLUETOOTH_SCAN"] = ContextCompat.checkSelfPermission(
-                    context, 
-                    android.Manifest.permission.BLUETOOTH_SCAN
-                ) == PackageManager.PERMISSION_GRANTED
-                
-                results["BLUETOOTH_CONNECT"] = ContextCompat.checkSelfPermission(
-                    context, 
-                    android.Manifest.permission.BLUETOOTH_CONNECT
-                ) == PackageManager.PERMISSION_GRANTED
-            }
-            
-            return results
-            
-        } catch (e: Exception) {
-            Log.e(TAG, "Error checking Bluetooth permissions: ${e.message}")
-            throw e
-        }
-    }
-
-    fun hasRequiredPermissions(): Boolean {
-        val hasLocationPermission = ContextCompat.checkSelfPermission(
-            context, 
-            android.Manifest.permission.ACCESS_FINE_LOCATION
-        ) == PackageManager.PERMISSION_GRANTED
-        
-        var hasBluetoothPermissions = true
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-            val hasScanPermission = ContextCompat.checkSelfPermission(
-                context, 
-                android.Manifest.permission.BLUETOOTH_SCAN
-            ) == PackageManager.PERMISSION_GRANTED
-            
-            val hasConnectPermission = ContextCompat.checkSelfPermission(
-                context, 
-                android.Manifest.permission.BLUETOOTH_CONNECT
-            ) == PackageManager.PERMISSION_GRANTED
-            
-            hasBluetoothPermissions = hasScanPermission && hasConnectPermission
-        }
-        
-        return hasLocationPermission && hasBluetoothPermissions
-    }
-}