react-native-bluetooth-escpos-printer-fork 0.0.17 → 0.0.18

package/README.md

@@ -28,6 +28,21 @@ Link the plugin to your RN project
 react-native link react-native-bluetooth-escpos-printer
 ```
 
+### Step3 (iOS only) ###
+Add Bluetooth permissions to your `Info.plist`:
+
+```xml
+<key>NSBluetoothAlwaysUsageDescription</key>
+<string>This app needs Bluetooth to discover and connect to printers</string>
+<key>NSBluetoothPeripheralUsageDescription</key>
+<string>This app needs Bluetooth to connect to printer peripherals</string>
+```
+
+**Note:** 
+- For iOS 13+, `NSBluetoothAlwaysUsageDescription` is required.
+- For iOS 12 and below, `NSBluetoothPeripheralUsageDescription` is required.
+- It's recommended to include both for maximum compatibility.
+
 ### Manual linking (Android) ###
 Ensure your build files match the following requirements:
 
@@ -73,8 +88,12 @@ async function, checks whether Bluetooth service is enabled.
             });
 ```
 
-* enableBluetooth ==> ``` diff + ANDROID ONLY ```
-async function, enables the bluetooth service, returns the devices information already bound and paired.  ``` diff - IOS would just resovle with nil ```
+* enableBluetooth ==>
+async function, enables the bluetooth service, returns the devices information already bound and paired.
+
+**Platform differences:**
+- **Android:** If Bluetooth is off, shows system dialog to enable it. Returns array of paired devices after enabling (or immediately if already enabled).
+- **iOS:** Cannot programmatically enable Bluetooth (must be done in Settings by user). Returns empty array `[]` since iOS Core Bluetooth doesn't have a "paired devices" concept. Use `scanDevices()` to discover available devices.
 
 ```javascript
 BluetoothManager.enableBluetooth().then((r)=>{
@@ -94,8 +113,12 @@ BluetoothManager.enableBluetooth().then((r)=>{
            });
 ```
 
-* disableBluetooth ==>  ``` diff + ANDROID ONLY ```
-async function ,disables the bluetooth service. ``` diff - IOS would just resovle with nil ```
+* disableBluetooth ==>
+async function, disables the bluetooth service.
+
+**Platform differences:**
+- **Android:** Programmatically disables Bluetooth and stops any active connections.
+- **iOS:** Cannot programmatically disable Bluetooth (must be done in Settings or Control Center by user). This method resolves successfully but does nothing on iOS.
 
 ```javascript
 BluetoothManager.disableBluetooth().then(()=>{
@@ -139,6 +162,36 @@ BluetoothManager.scanDevices()
             });
 ```
 
+**Device Information Structure:**
+
+Each device object returned contains:
+- `name` (string): Device name
+- `address` (string): Device MAC address (Android) or UUID (iOS)
+- `deviceClass` (number): Bluetooth device class
+- `majorDeviceClass` (number): Major device class category
+- `rssi` (number, iOS only): Signal strength indicator
+
+**Filtering for Printers:**
+
+To identify printer devices, check the `majorDeviceClass`:
+```javascript
+const MAJOR_CLASS_IMAGING = 1536; // 0x0600 - Printers, scanners, cameras
+const DEVICE_CLASS_PRINTER = 1664; // 0x0680 - Specifically printers
+
+// Filter found devices to show only printers
+const printers = ss.found.filter(device => 
+    device.majorDeviceClass === MAJOR_CLASS_IMAGING || 
+    device.deviceClass === DEVICE_CLASS_PRINTER
+);
+```
+
+**Platform differences:**
+- **Android:** Device classes are provided by the OS based on the device's Bluetooth profile
+- **iOS:** Device classes are inferred from:
+  1. Advertised service UUIDs (SPP, ESC/POS services)
+  2. Device name patterns (contains "print", "pos", "thermal", "receipt", etc.)
+  3. If no printer indicators are found, device is marked as "unknown" (class 7936)
+
 * connect ==>
 async function, connects the specified device, if not bound, bound dailog prompts.
 
@@ -162,8 +215,10 @@ async function, connects the specified device, if not bound, bound dailog prompt
 * unpair ==>
 async function, disconnects and unpairs the specified devices
 
+**Note for iOS:** Due to iOS security restrictions, this method can only disconnect the device but cannot programmatically unpair it. The device will remain paired at the iOS system level. Users must unpair manually from iOS Settings > Bluetooth if needed. On Android, full unpair functionality is supported.
+
 ```javascript
-     BluetoothManager.connect(rowData.address)
+     BluetoothManager.unpaire(rowData.address)
      .then((s)=>{
         //success here
      },

package/android/.classpath

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-11/"/>
+	<classpathentry kind="con" path="org.eclipse.buildship.core.gradleclasspathcontainer"/>
+	<classpathentry kind="output" path="bin/default"/>
+</classpath>

package/android/.gradle/buildOutputCleanup/cache.properties

@@ -0,0 +1,2 @@
+#Sat Jan 31 21:27:45 CET 2026
+gradle.version=6.1.1

package/android/.project

@@ -5,6 +5,11 @@
 	<projects>
 	</projects>
 	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
 		<buildCommand>
 			<name>org.eclipse.buildship.core.gradleprojectbuilder</name>
 			<arguments>
@@ -12,6 +17,18 @@
 		</buildCommand>
 	</buildSpec>
 	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
 		<nature>org.eclipse.buildship.core.gradleprojectnature</nature>
 	</natures>
+	<filteredResources>
+		<filter>
+			<id>1769891269456</id>
+			<name></name>
+			<type>30</type>
+			<matcher>
+				<id>org.eclipse.core.resources.regexFilterMatcher</id>
+				<arguments>node_modules|\.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__</arguments>
+			</matcher>
+		</filter>
+	</filteredResources>
 </projectDescription>

package/android/.settings/org.eclipse.buildship.core.prefs

@@ -1,2 +1,13 @@
+arguments=--init-script /Users/lukaszprivate/.local/share/opencode/bin/jdtls/config_mac/org.eclipse.osgi/59/0/.cp/gradle/init/init.gradle
+auto.sync=false
+build.scans.enabled=false
+connection.gradle.distribution=GRADLE_DISTRIBUTION(WRAPPER)
 connection.project.dir=
 eclipse.preferences.version=1
+gradle.user.home=
+java.home=/Library/Java/JavaVirtualMachines/zulu-11.jdk/Contents/Home
+jvm.arguments=
+offline.mode=false
+override.workspace.settings=true
+show.console.view=true
+show.executions.view=true

package/android/.settings/org.eclipse.jdt.core.prefs

@@ -0,0 +1,4 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=11
+org.eclipse.jdt.core.compiler.compliance=11
+org.eclipse.jdt.core.compiler.source=11

package/ios/PrintImageBleWriteDelegate.m

@@ -12,7 +12,7 @@
 
 
 - (void) didWriteDataToBle: (BOOL)success
-{NSLog(@"PrintImageBleWriteDelete diWriteDataToBle: %d",success?1:0);
+{
     if(success){
         if(_now == -1){
              if(_pendingResolve) {_pendingResolve(nil); _pendingResolve=nil;}
@@ -43,19 +43,10 @@
 {
     @synchronized (self) {
      NSInteger sizePerLine = (int)(_width/8);
-   // do{
-//        if(sizePerLine+_now>=[_toPrint length]){
-//            sizePerLine = [_toPrint length] - _now;
-//        }
-       // if(sizePerLine>0){
-            NSData *subData = [_toPrint subdataWithRange:NSMakeRange(_now, sizePerLine)];
-            NSLog(@"Write data:%@",subData);
-            [RNBluetoothManager writeValue:subData withDelegate:self];
-        //}
+        NSData *subData = [_toPrint subdataWithRange:NSMakeRange(_now, sizePerLine)];
+        [RNBluetoothManager writeValue:subData withDelegate:self];
         _now = _now+sizePerLine;
         [NSThread sleepForTimeInterval:0.01f];
-        
     }
-    //}while(_now<[_toPrint length]);
 }
 @end

package/ios/RNBluetoothEscposPrinter.m

@@ -560,6 +560,7 @@ RCT_EXPORT_METHOD(printEscPosCommands:(NSString *)base64encodeStr
     if(RNBluetoothManager.isConnected){
         @try{
             NSData *decoded = [[NSData alloc] initWithBase64EncodedString:base64encodeStr options:0];
+            
             pendingResolve = resolve;
             pendingReject = reject;
             [RNBluetoothManager writeValue:decoded withDelegate:self];

package/ios/RNBluetoothManager.h

@@ -19,6 +19,7 @@
 @property (nonatomic,copy) RCTPromiseResolveBlock scanResolveBlock;
 @property (nonatomic,copy) RCTPromiseRejectBlock scanRejectBlock;
 @property (strong,nonatomic) NSMutableDictionary <NSString *,CBPeripheral *> *foundDevices;
+@property (strong,nonatomic) NSMutableDictionary <NSString *,NSDictionary *> *foundDevicesMetadata;
 @property (strong,nonatomic) NSString *waitingConnect;
 @property (nonatomic,copy) RCTPromiseResolveBlock connectResolveBlock;
 @property (nonatomic,copy) RCTPromiseRejectBlock connectRejectBlock;

package/ios/RNBluetoothManager.m

@@ -21,23 +21,104 @@ static NSArray<CBUUID *> *supportServices = nil;
 static NSDictionary *writeableCharactiscs = nil;
 bool hasListeners;
 static CBPeripheral *connected;
+static CBCharacteristic *cachedWriteCharacteristic = nil; // Cache the writable characteristic
 static RNBluetoothManager *instance;
 static NSObject<WriteDataToBleDelegate> *writeDataDelegate;// delegate of write data resule;
 static NSData *toWrite;
 static NSTimer *timer;
 
+-(instancetype)init {
+    if (self = [super init]) {
+        // Initialize CBCentralManager eagerly so it's ready when methods are called
+        // This triggers the centralManagerDidUpdateState callback immediately
+        [self centralManager];
+        [self initSupportServices];
+    }
+    return self;
+}
+
 +(Boolean)isConnected{
     return !(connected==nil);
 }
 
+// Helper method to write data with automatic chunking for BLE MTU limits
++(BOOL)writeDataWithChunking:(NSData *)data 
+               toCharacteristic:(CBCharacteristic *)characteristic 
+                   onPeripheral:(CBPeripheral *)peripheral {
+    CBCharacteristicWriteType writeType = (characteristic.properties & CBCharacteristicPropertyWriteWithoutResponse) 
+        ? CBCharacteristicWriteWithoutResponse 
+        : CBCharacteristicWriteWithResponse;
+    
+    // BLE has MTU limitations - need to chunk data if it's too large
+    // The minimum BLE MTU is 23 bytes, with 3 bytes overhead, leaving 20 bytes usable
+    // maximumWriteValueLengthForType often returns incorrect values for WriteWithoutResponse
+    // so we force a conservative chunk size
+    NSUInteger maxWriteLength = 20; // Safe default that works with all BLE devices
+    
+    NSUInteger dataLength = [data length];
+    
+    if(dataLength <= maxWriteLength) {
+        // Data fits in one write - no chunking needed
+        [peripheral writeValue:data forCharacteristic:characteristic type:writeType];
+        return YES;
+    } else {
+        // Need to chunk the data
+        NSLog(@"BLE chunking: %lu bytes -> %lu byte chunks", dataLength, maxWriteLength);
+        NSUInteger offset = 0;
+        BOOL allSuccess = YES;
+        NSUInteger chunkCount = 0;
+        
+        while(offset < dataLength && allSuccess) {
+            NSUInteger chunkSize = MIN(maxWriteLength, dataLength - offset);
+            NSData *chunk = [data subdataWithRange:NSMakeRange(offset, chunkSize)];
+            
+            @try {
+                [peripheral writeValue:chunk forCharacteristic:characteristic type:writeType];
+                chunkCount++;
+                
+                // Small delay between chunks to avoid overwhelming the device
+                if(writeType == CBCharacteristicWriteWithoutResponse) {
+                    [NSThread sleepForTimeInterval:0.01]; // 10ms delay
+                }
+            }
+            @catch(NSException *e) {
+                NSLog(@"BLE chunk write error at offset %lu: %@", offset, e);
+                allSuccess = NO;
+            }
+            
+            offset += chunkSize;
+        }
+        
+        if(allSuccess) {
+            NSLog(@"BLE chunking complete: %lu chunks sent", chunkCount);
+        }
+        return allSuccess;
+    }
+}
+
 +(void)writeValue:(NSData *) data withDelegate:(NSObject<WriteDataToBleDelegate> *) delegate
 {
     @try{
         writeDataDelegate = delegate;
         toWrite = data;
         connected.delegate = instance;
-        [connected discoverServices:supportServices];
-//    [connected writeValue:data forCharacteristic:[writeableCharactiscs objectForKey:supportServices[0]] type:CBCharacteristicWriteWithoutResponse];
+        
+        // If we have a cached writable characteristic, use it directly
+        if(cachedWriteCharacteristic && connected){
+            // Use helper method to write with chunking
+            BOOL success = [RNBluetoothManager writeDataWithChunking:toWrite 
+                                                    toCharacteristic:cachedWriteCharacteristic 
+                                                        onPeripheral:connected];
+            
+            if(writeDataDelegate) [writeDataDelegate didWriteDataToBle:success];
+            toWrite = nil;
+            return;
+        }
+        
+        // No cached characteristic, need to discover services first
+        NSLog(@"No cached characteristic, discovering services...");
+        // Discover all services (not just SPP which is for Classic BT, not BLE)
+        [connected discoverServices:nil];
     }
     @catch(NSException *e){
         NSLog(@"error in writing data to %@,issue:%@",connected,e);
@@ -119,7 +200,11 @@ RCT_EXPORT_METHOD(isBluetoothEnabled:(RCTPromiseResolveBlock)resolve
 RCT_EXPORT_METHOD(enableBluetooth:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 {
-    resolve(nil);
+    // iOS doesn't allow programmatic Bluetooth enabling
+    // Bluetooth must be enabled from Settings by the user
+    // Return empty array to match Android's return type (array of paired devices)
+    // Since iOS Core Bluetooth doesn't have "paired devices" concept, we return empty array
+    resolve(@[]);
 }
 //disableBluetooth
 RCT_EXPORT_METHOD(disableBluetooth:(RCTPromiseResolveBlock)resolve
@@ -141,15 +226,50 @@ RCT_EXPORT_METHOD(scanDevices:(RCTPromiseResolveBlock)resolve
         }
         self.scanResolveBlock = resolve;
         self.scanRejectBlock = reject;
+        
+        // Initialize metadata dictionary if needed
+        if(!self.foundDevicesMetadata){
+            self.foundDevicesMetadata = [[NSMutableDictionary alloc] init];
+        }
+        
         if(connected && connected.identifier){
-            NSDictionary *idAndName =@{@"address":connected.identifier.UUIDString,@"name":connected.name?connected.name:@""};
-            NSDictionary *peripheralStored = @{connected.identifier.UUIDString:connected};
+            NSString *name = connected.name ? connected.name : @"";
+            NSString *address = connected.identifier.UUIDString;
+            
+            // Create device info with device class for connected device
+            NSMutableDictionary *deviceInfo = [[NSMutableDictionary alloc] init];
+            [deviceInfo setObject:address forKey:@"address"];
+            [deviceInfo setObject:name forKey:@"name"];
+            [deviceInfo setObject:@(0) forKey:@"rssi"];  // Unknown RSSI for already connected device
+            
+            // Try to infer if it's a printer from the name
+            BOOL isPrinter = NO;
+            NSString *upperName = name.uppercaseString;
+            if ([upperName containsString:@"PRINT"] || 
+                [upperName containsString:@"POS"] ||
+                [upperName containsString:@"ESCPOS"] ||
+                [upperName containsString:@"THERMAL"] ||
+                [upperName containsString:@"RECEIPT"]) {
+                isPrinter = YES;
+            }
+            
+            if (isPrinter) {
+                [deviceInfo setObject:@(1536) forKey:@"majorDeviceClass"];  // Imaging
+                [deviceInfo setObject:@(1664) forKey:@"deviceClass"];       // Printer
+            } else {
+                [deviceInfo setObject:@(7936) forKey:@"majorDeviceClass"];  // Unknown
+                [deviceInfo setObject:@(7936) forKey:@"deviceClass"];       // Unknown
+            }
+            
+            NSDictionary *peripheralStored = @{address:connected};
             if(!self.foundDevices){
                 self.foundDevices = [[NSMutableDictionary alloc] init];
             }
             [self.foundDevices addEntriesFromDictionary:peripheralStored];
+            [self.foundDevicesMetadata setObject:deviceInfo forKey:address];
+            
             if(hasListeners){
-                [self sendEventWithName:EVENT_DEVICE_FOUND body:@{@"device":idAndName}];
+                [self sendEventWithName:EVENT_DEVICE_FOUND body:@{@"device":deviceInfo}];
             }
         }
         [self.centralManager scanForPeripheralsWithServices:nil options:@{CBCentralManagerScanOptionAllowDuplicatesKey:@NO}];
@@ -183,6 +303,13 @@ RCT_EXPORT_METHOD(connect:(NSString *)address
                   rejecter:(RCTPromiseRejectBlock)reject)
 {
     NSLog(@"Trying to connect....%@",address);
+    
+    // Check if Bluetooth is ready
+    if(!self.centralManager || self.centralManager.state!=CBManagerStatePoweredOn){
+        reject(@"BLUETOOTH_NOT_READY",@"Bluetooth is not enabled or not ready. Please enable Bluetooth and try again.",nil);
+        return;
+    }
+    
     [self callStop];
     if(connected){
         NSString *connectedAddress =connected.identifier.UUIDString;
@@ -205,6 +332,13 @@ RCT_EXPORT_METHOD(connect:(NSString *)address
         // Callbacks:
         //    centralManager:didConnectPeripheral:
         //    centralManager:didFailToConnectPeripheral:error:
+        
+        // Set connection timeout (30 seconds)
+        if(timer && timer.isValid){
+            [timer invalidate];
+            timer = nil;
+        }
+        timer = [NSTimer scheduledTimerWithTimeInterval:30 target:self selector:@selector(handleConnectTimeout) userInfo:nil repeats:NO];
     }else{
           //starts the scan.
         _waitingConnect = address;
@@ -212,32 +346,125 @@ RCT_EXPORT_METHOD(connect:(NSString *)address
         [self.centralManager scanForPeripheralsWithServices:nil options:@{CBCentralManagerScanOptionAllowDuplicatesKey:@NO}];
         //Callbacks:
         //centralManager:didDiscoverPeripheral:advertisementData:RSSI:
+        
+        // Set scan + connection timeout (30 seconds)
+        if(timer && timer.isValid){
+            [timer invalidate];
+            timer = nil;
+        }
+        timer = [NSTimer scheduledTimerWithTimeInterval:30 target:self selector:@selector(handleConnectTimeout) userInfo:nil repeats:NO];
+    }
+}
+//disconnect(address)
+RCT_EXPORT_METHOD(disconnect:(NSString *)address
+                  findEventsWithResolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    NSLog(@"Trying to disconnect device: %@",address);
+    
+    // Check if Bluetooth is ready
+    if(!self.centralManager || self.centralManager.state!=CBManagerStatePoweredOn){
+        reject(@"BLUETOOTH_NOT_READY",@"Bluetooth is not enabled or not ready.",nil);
+        return;
+    }
+    
+    if(connected && [connected.identifier.UUIDString isEqualToString:address]){
+        [self.centralManager cancelPeripheralConnection:connected];
+        // Note: disconnection is async, but we resolve immediately like Android does
+        // The didDisconnectPeripheral callback will handle setting connected = nil
+        resolve(address);
+    } else {
+        // Device not connected or different device
+        NSLog(@"Device not connected or different device: %@",address);
+        resolve(address);
     }
 }
 //unpaire(address)
+RCT_EXPORT_METHOD(unpaire:(NSString *)address
+                  findEventsWithResolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    NSLog(@"Trying to unpair/disconnect device: %@",address);
+    if(connected && [connected.identifier.UUIDString isEqualToString:address]){
+        [self.centralManager cancelPeripheralConnection:connected];
+        // Note: Core Bluetooth on iOS doesn't support programmatic unpairing
+        // The connection will be cancelled, but the device remains paired at OS level
+        // Users must unpair manually from iOS Settings if needed
+        connected = nil;
+        resolve(address);
+    } else {
+        // Device not connected, just resolve
+        NSLog(@"Device not connected, nothing to unpair: %@",address);
+        resolve(address);
+    }
+}
+
 
+-(void)handleConnectTimeout{
+    NSLog(@"Connection timeout - device not found or unable to connect");
+    if(self.centralManager.isScanning){
+        [self.centralManager stopScan];
+    }
+    if(self.connectRejectBlock){
+        RCTPromiseRejectBlock rjBlock = self.connectRejectBlock;
+        rjBlock(@"CONNECTION_TIMEOUT",@"Could not connect to device - timeout after 30 seconds",nil);
+        self.connectRejectBlock = nil;
+        self.connectResolveBlock = nil;
+    }
+    _waitingConnect = nil;
+    if(timer && timer.isValid){
+        [timer invalidate];
+        timer = nil;
+    }
+}
 
 -(void)callStop{
     if(self.centralManager.isScanning){
         [self.centralManager stopScan];
         NSMutableArray *devices = [[NSMutableArray alloc] init];
         for(NSString *key in self.foundDevices){
-            NSLog(@"insert found devies:%@ =>%@",key,[self.foundDevices objectForKey:key]);
-            NSString *name = [self.foundDevices objectForKey:key].name;
-            if(!name){
-                name = @"";
+            NSLog(@"insert found devices:%@ =>%@",key,[self.foundDevices objectForKey:key]);
+            
+            // Get stored metadata if available, otherwise create basic info
+            NSDictionary *deviceInfo = [self.foundDevicesMetadata objectForKey:key];
+            if (deviceInfo) {
+                [devices addObject:deviceInfo];
+            } else {
+                // Fallback if metadata wasn't stored (shouldn't happen with new code)
+                NSString *name = [self.foundDevices objectForKey:key].name;
+                if(!name){
+                    name = @"";
+                }
+                [devices addObject:@{
+                    @"address":key,
+                    @"name":name,
+                    @"deviceClass":@(7936),      // Unknown device class
+                    @"majorDeviceClass":@(7936)  // Unknown major device class
+                }];
             }
-            [devices addObject:@{@"address":key,@"name":name}];
         }
+        
+        // Create result object matching Android format: {"paired": [...], "found": [...]}
+        // Empty paired devices array (iOS doesn't have "paired" concept like Android)
+        NSMutableDictionary *result = [[NSMutableDictionary alloc] init];
+        [result setObject:@[] forKey:@"paired"];
+        [result setObject:devices forKey:@"found"];
+        
+        // Convert the entire result to a JSON string (matching Android's behavior)
         NSError *error = nil;
-        NSData* jsonData = [NSJSONSerialization dataWithJSONObject:devices options:NSJSONWritingPrettyPrinted error:&error];
-        NSString * jsonStr = [[NSString alloc] initWithData:jsonData encoding:NSUTF8StringEncoding];
+        NSData* resultJsonData = [NSJSONSerialization dataWithJSONObject:result options:0 error:&error];
+        NSString *resultJsonStr = [[NSString alloc] initWithData:resultJsonData encoding:NSUTF8StringEncoding];
+        
         if(hasListeners){
-            [self sendEventWithName:EVENT_DEVICE_DISCOVER_DONE body:@{@"found":jsonStr,@"paired":@"[]"}];
+            // For events, send separate paired and found strings
+            NSData* foundJsonData = [NSJSONSerialization dataWithJSONObject:devices options:0 error:&error];
+            NSString *foundJsonStr = [[NSString alloc] initWithData:foundJsonData encoding:NSUTF8StringEncoding];
+            [self sendEventWithName:EVENT_DEVICE_DISCOVER_DONE body:@{@"found":foundJsonStr,@"paired":@"[]"}];
         }
         if(self.scanResolveBlock){
             RCTPromiseResolveBlock rsBlock = self.scanResolveBlock;
-            rsBlock(@{@"found":jsonStr,@"paired":@"[]"});
+            // Return single JSON string: "{\"paired\":[],\"found\":[...]}"
+            rsBlock(resultJsonStr);
             self.scanResolveBlock = nil;
         }
     }
@@ -251,9 +478,11 @@ RCT_EXPORT_METHOD(connect:(NSString *)address
 - (void) initSupportServices
 {
     if(!supportServices){
-        CBUUID *issc = [CBUUID UUIDWithString: @"49535343-FE7D-4AE5-8FA9-9FAFD205E455"];
-        supportServices = [NSArray arrayWithObject:issc];/*ISSC*/
-        writeableCharactiscs = @{issc:@"49535343-8841-43F4-A8D4-ECBE34729BB3"};
+        // Use standard SPP (Serial Port Profile) UUID - same as Android
+        CBUUID *spp = [CBUUID UUIDWithString: @"00001101-0000-1000-8000-00805F9B34FB"];
+        supportServices = [NSArray arrayWithObject:spp];
+        // SPP uses the same UUID for service and characteristic
+        writeableCharactiscs = @{spp:@"00001101-0000-1000-8000-00805F9B34FB"};
     }
 }
 
@@ -284,19 +513,108 @@ RCT_EXPORT_METHOD(connect:(NSString *)address
  * CBCentralManagerDelegate
  **/
 - (void)centralManagerDidUpdateState:(CBCentralManager *)central{
-    NSLog(@"%ld",(long)central.state);
+    NSString *stateString;
+    switch (central.state) {
+        case CBManagerStateUnknown:
+            stateString = @"Unknown";
+            break;
+        case CBManagerStateResetting:
+            stateString = @"Resetting";
+            break;
+        case CBManagerStateUnsupported:
+            stateString = @"Unsupported";
+            break;
+        case CBManagerStateUnauthorized:
+            stateString = @"Unauthorized";
+            break;
+        case CBManagerStatePoweredOff:
+            stateString = @"PoweredOff";
+            break;
+        case CBManagerStatePoweredOn:
+            stateString = @"PoweredOn";
+            break;
+        default:
+            stateString = @"Unknown";
+            break;
+    }
+    NSLog(@"Bluetooth State Changed: %@ (%ld)", stateString, (long)central.state);
 }
 
 - (void)centralManager:(CBCentralManager *)central didDiscoverPeripheral:(CBPeripheral *)peripheral advertisementData:(NSDictionary<NSString *, id> *)advertisementData RSSI:(NSNumber *)RSSI{
     NSLog(@"did discover peripheral: %@",peripheral);
-    NSDictionary *idAndName =@{@"address":peripheral.identifier.UUIDString,@"name":peripheral.name?peripheral.name:@""};
+    
+    // Extract device information with enhanced metadata
+    NSMutableDictionary *deviceInfo = [[NSMutableDictionary alloc] init];
+    [deviceInfo setObject:peripheral.identifier.UUIDString forKey:@"address"];
+    [deviceInfo setObject:(peripheral.name ? peripheral.name : @"") forKey:@"name"];
+    
+    // Add RSSI for signal strength
+    [deviceInfo setObject:RSSI forKey:@"rssi"];
+    
+    // Try to infer device class from advertising data
+    // iOS BLE doesn't expose Classic Bluetooth device class, but we can make educated guesses
+    NSInteger deviceClass = 0;
+    NSInteger majorDeviceClass = 0;
+    
+    // Check if device advertises printer-related services
+    NSArray *serviceUUIDs = advertisementData[CBAdvertisementDataServiceUUIDsKey];
+    BOOL isPrinter = NO;
+    
+    if (serviceUUIDs && serviceUUIDs.count > 0) {
+        for (CBUUID *uuid in serviceUUIDs) {
+            NSString *uuidString = uuid.UUIDString.uppercaseString;
+            // Serial Port Profile (SPP) UUID - common for printers
+            // Also check for other printer-related service UUIDs
+            if ([uuidString isEqualToString:@"00001101-0000-1000-8000-00805F9B34FB"] ||
+                [uuidString isEqualToString:@"49535343-FE7D-4AE5-8FA9-9FAFD205E455"] ||
+                [uuidString containsString:@"18F0"]) {
+                isPrinter = YES;
+                break;
+            }
+        }
+    }
+    
+    // Check device name for printer keywords
+    NSString *name = peripheral.name ? peripheral.name.uppercaseString : @"";
+    if ([name containsString:@"PRINT"] || 
+        [name containsString:@"POS"] ||
+        [name containsString:@"ESCPOS"] ||
+        [name containsString:@"THERMAL"] ||
+        [name containsString:@"RECEIPT"]) {
+        isPrinter = YES;
+    }
+    
+    if (isPrinter) {
+        // Android Bluetooth Class values for printers:
+        // Major Device Class: 0x0600 (Imaging - printers, scanners, cameras, etc.)
+        // Device Class: 0x000680 (Imaging/Printer)
+        majorDeviceClass = 1536;  // 0x0600 in decimal
+        deviceClass = 1664;       // 0x0680 in decimal
+    } else {
+        // Unknown/Unclassified device
+        // Major Device Class: 0x1F00 (Uncategorized)
+        majorDeviceClass = 7936;  // 0x1F00 in decimal
+        deviceClass = 7936;
+    }
+    
+    [deviceInfo setObject:@(deviceClass) forKey:@"deviceClass"];
+    [deviceInfo setObject:@(majorDeviceClass) forKey:@"majorDeviceClass"];
+    
+    // Store the peripheral object for connection
     NSDictionary *peripheralStored = @{peripheral.identifier.UUIDString:peripheral};
     if(!self.foundDevices){
         self.foundDevices = [[NSMutableDictionary alloc] init];
     }
     [self.foundDevices addEntriesFromDictionary:peripheralStored];
+    
+    // Store device metadata for later retrieval
+    if(!self.foundDevicesMetadata){
+        self.foundDevicesMetadata = [[NSMutableDictionary alloc] init];
+    }
+    [self.foundDevicesMetadata setObject:deviceInfo forKey:peripheral.identifier.UUIDString];
+    
     if(hasListeners){
-        [self sendEventWithName:EVENT_DEVICE_FOUND body:@{@"device":idAndName}];
+        [self sendEventWithName:EVENT_DEVICE_FOUND body:@{@"device":deviceInfo}];
     }
     if(_waitingConnect && [_waitingConnect isEqualToString: peripheral.identifier.UUIDString]){
         [self.centralManager connectPeripheral:peripheral options:nil];
@@ -308,10 +626,24 @@ RCT_EXPORT_METHOD(connect:(NSString *)address
     NSLog(@"did connected: %@",peripheral);
     connected = peripheral;
     NSString *pId = peripheral.identifier.UUIDString;
+    
+    // Set peripheral delegate to receive service/characteristic callbacks
+    peripheral.delegate = self;
+    
     if(_waitingConnect && [_waitingConnect isEqualToString: pId] && self.connectResolveBlock){
-        NSLog(@"Predefined the support services, stop to looking up services.");
-//        peripheral.delegate=self;
-//        [peripheral discoverServices:nil];
+        // Cancel connection timeout timer if it's running
+        if(timer && timer.isValid){
+            [timer invalidate];
+            timer = nil;
+        }
+        
+        // Pre-discover services to prepare for future write operations
+        // This matches Android's behavior where the connection is fully ready after connect
+        // Pass nil to discover ALL services (not just SPP which is for Classic BT, not BLE)
+        NSLog(@"Pre-discovering all services for faster write operations...");
+        [peripheral discoverServices:nil];
+        
+        // Resolve promise immediately (iOS BLE connects fast, service discovery happens async)
         self.connectResolveBlock(nil);
         _waitingConnect = nil;
         self.connectRejectBlock = nil;
@@ -324,6 +656,9 @@ RCT_EXPORT_METHOD(connect:(NSString *)address
 }
 
 - (void)centralManager:(CBCentralManager *)central didDisconnectPeripheral:(CBPeripheral *)peripheral error:(nullable NSError *)error{
+    // Clear cached characteristic when disconnecting
+    cachedWriteCharacteristic = nil;
+    
     if(!connected && _waitingConnect && [_waitingConnect isEqualToString:peripheral.identifier.UUIDString]){
         if(self.connectRejectBlock){
             RCTPromiseRejectBlock rjBlock = self.connectRejectBlock;
@@ -345,6 +680,9 @@ RCT_EXPORT_METHOD(connect:(NSString *)address
 }
 
 - (void)centralManager:(CBCentralManager *)central didFailToConnectPeripheral:(CBPeripheral *)peripheral error:(nullable NSError *)error{
+    // Clear cached characteristic when connection fails
+    cachedWriteCharacteristic = nil;
+    
     if(self.connectRejectBlock){
         RCTPromiseRejectBlock rjBlock = self.connectRejectBlock;
         rjBlock(@"",@"",error);
@@ -412,38 +750,59 @@ RCT_EXPORT_METHOD(connect:(NSString *)address
  */
 - (void)peripheral:(CBPeripheral *)peripheral didDiscoverCharacteristicsForService:(CBService *)service error:(nullable NSError *)error{
     if(toWrite && connected
-       && [connected.identifier.UUIDString isEqualToString:peripheral.identifier.UUIDString]
-       && [service.UUID.UUIDString isEqualToString:supportServices[0].UUIDString]){
+       && [connected.identifier.UUIDString isEqualToString:peripheral.identifier.UUIDString]){
         if(error){
-            NSLog(@"Discrover charactoreristics error:%@",error);
+            NSLog(@"Discover characteristics error:%@",error);
            if(writeDataDelegate)
            {
                [writeDataDelegate didWriteDataToBle:false];
                return;
            }
         }
+        
+        // Try to write to any service that has writable characteristics
+        // Don't filter by supportServices - many BLE printers use custom UUIDs
+        NSLog(@"Checking service %@ for writable characteristics...", service.UUID.UUIDString);
+        
+        // Auto-detect writable characteristic by checking properties
         for(CBCharacteristic *cc in service.characteristics){
-            NSLog(@"Characterstic found: %@ in service: %@" ,cc,service.UUID.UUIDString);
-            if([cc.UUID.UUIDString isEqualToString:[writeableCharactiscs objectForKey: supportServices[0]]]){
+            NSLog(@"Characteristic found: %@ in service: %@" ,cc,service.UUID.UUIDString);
+            
+            // Check if characteristic supports write operations
+            BOOL canWrite = (cc.properties & CBCharacteristicPropertyWrite) || 
+                           (cc.properties & CBCharacteristicPropertyWriteWithoutResponse);
+            
+            if(canWrite){
                 @try{
-                    [connected writeValue:toWrite forCharacteristic:cc type:CBCharacteristicWriteWithoutResponse];
-                   if(writeDataDelegate) [writeDataDelegate didWriteDataToBle:true];
-                    if(toWrite){
-                        NSLog(@"Value wrote: %lu",[toWrite length]);
-                    }
+                    NSLog(@"Writing %lu bytes to characteristic %@ in service %@",[toWrite length], cc.UUID.UUIDString, service.UUID.UUIDString);
+                    
+                    // Use helper method to write with chunking
+                    BOOL success = [RNBluetoothManager writeDataWithChunking:toWrite 
+                                                            toCharacteristic:cc 
+                                                                onPeripheral:connected];
+                    
+                    // Cache this characteristic for future writes
+                    cachedWriteCharacteristic = cc;
+                    NSLog(@"Cached characteristic %@ for future writes", cc.UUID.UUIDString);
+                    
+                    if(writeDataDelegate) [writeDataDelegate didWriteDataToBle:success];
+                    toWrite = nil; // Clear the write buffer
+                    return; // Success, exit after first successful write
                 }
                 @catch(NSException *e){
-                    NSLog(@"ERRO IN WRITE VALUE: %@",e);
-                      [writeDataDelegate didWriteDataToBle:false];
+                    NSLog(@"ERROR IN WRITE VALUE: %@",e);
+                    [writeDataDelegate didWriteDataToBle:false];
                 }
             }
         }
         
-        
+        // If we get here, no writable characteristic was found in this service
+        NSLog(@"No writable characteristic found in service: %@", service.UUID.UUIDString);
+        // Don't call didWriteDataToBle:false here - there might be other services to check
     }
     
     if(error){
-        NSLog(@"Discrover charactoreristics error:%@",error);
+        NSLog(@"Discover characteristics error:%@",error);
         return;
     }
     

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-bluetooth-escpos-printer-fork",
-  "version": "0.0.17",
+  "version": "0.0.18",
   "description": "React-Native plugin for the bluetooth ESC/POS printers.",
   "main": "index.js",
   "scripts": {