react-native-flic2 2.0.0-alpha.39 → 2.0.0-beta.10

package/ios/Flic2.mm

@@ -8,16 +8,6 @@
     return self;
 }
 
-- (NSNumber *)multiply:(double)a b:(double)b {
-
-    NSLog(@"multiply: %f * %f", a, b);
-    NSNumber *result = @(a * b);
-
-    [self emitOnMultiply:@{@"a": @(a), @"b": @(b), @"result": result}];
-
-    return result;
-}
-
 // MARK: - FLICManager Methods
 
 - (void)initialize:(BOOL)background
@@ -28,8 +18,7 @@
     FLICManager *manager = [FLICManager configureWithDelegate:self buttonDelegate:self background:background];
 
     if (manager) {
-        self.manager = manager; // Store reference for our own use
-        resolve(@{@"success": @YES, @"message": @"Manager initialized successfully"});
+        resolve(nil);
     } else {
         reject(@"INIT_ERROR", @"Failed to initialize FLICManager", nil);
     }
@@ -38,7 +27,7 @@
 - (void)getButtons:(RCTPromiseResolveBlock)resolve
     reject:(RCTPromiseRejectBlock)reject
 {
-    if (!self.manager) {
+    if (![FLICManager sharedManager]) {
         reject(@"NOT_INITIALIZED", @"Manager not initialized", nil);
         return;
     }
@@ -61,7 +50,7 @@
 - (void)scanForButtons:(RCTPromiseResolveBlock)resolve
     reject:(RCTPromiseRejectBlock)reject
 {
-    if (!self.manager) {
+    if (![FLICManager sharedManager]) {
         reject(@"NOT_INITIALIZED", @"Manager not initialized", nil);
         return;
     }
@@ -75,25 +64,25 @@
 
     __weak Flic2 *weakSelf = self;
 
-    [[FLICManager sharedManager] scanForButtonsWithStateChangeHandler:^(FLICButtonScannerStatusEvent event) {
-        NSLog(@"Scan state change: %@", [weakSelf scannerEventToString:event]);
+    // Emit started event
+    dispatch_async(dispatch_get_main_queue(), ^{
         [weakSelf emitOnScanStatusChange:@{
-            @"event": @(event),
-            @"eventName": [weakSelf scannerEventToString:event]
+            @"event": @"started",
+            @"eventName": @"started"
         }];
+    });
+
+    [[FLICManager sharedManager] scanForButtonsWithStateChangeHandler:^(FLICButtonScannerStatusEvent event) {
+
+        // Intermediate scan status events are intentionally not emitted
+
     } completion:^(FLICButton * _Nullable button, NSError * _Nullable error) {
         NSLog(@"Scan completion called - button: %@, error: %@", button ? @"YES" : @"NO", error);
 
+        NSInteger resultCode = [weakSelf mapScanErrorToResultCode:error];
+
         if (error) {
-            NSLog(@"Scan error: %@ (code: %ld)", error.localizedDescription, (long)error.code);
-            // Check for specific error codes
-            if (error.code == FLICButtonScannerErrorCodeUserCanceled) {
-                NSLog(@"Scan was cancelled by user");
-            } else if (error.code == FLICButtonScannerErrorCodeNoPublicButtonDiscovered) {
-                NSLog(@"No Flic button found in range");
-            } else {
-                NSLog(@"Scan error: %@", error.localizedDescription);
-            }
+            NSLog(@"Scan error: %@ (code: %ld, mapped: %ld)", error.localizedDescription, (long)error.code, (long)resultCode);
         } else if (button) {
             NSLog(@"Button found: %@", button.uuid);
 
@@ -102,51 +91,56 @@
             [button connect];
 
             // Emit button event for discovered button
-            [weakSelf emitOnButtonEvent:@{
-                @"uuid": button.uuid,
-                @"event": @"discovered",
-                @"button": [weakSelf buttonToDictionary:button]
-            }];
+            dispatch_async(dispatch_get_main_queue(), ^{
+                [weakSelf emitOnButtonEvent:@{
+                    @"uuid": button.uuid,
+                    @"event": @"discovered",
+                    @"button": [weakSelf buttonToDictionary:button]
+                }];
+            });
+
         } else {
             NSLog(@"No button found and no error");
         }
+
+        // Emit scan completion with result code
+        dispatch_async(dispatch_get_main_queue(), ^{
+            [weakSelf emitOnScanStatusChange:@{
+                @"event": @"completion",
+                @"eventName": @"completion",
+                @"result": @(resultCode)
+            }];
+        });
     }];
 
     // Return immediately - scan results will come through events
-    resolve(@{@"success": @YES, @"message": @"Scan started"});
+    resolve(nil);
 }
 
 - (void)stopScan:(RCTPromiseResolveBlock)resolve
     reject:(RCTPromiseRejectBlock)reject
 {
-    if (!self.manager) {
+    if (![FLICManager sharedManager]) {
         reject(@"NOT_INITIALIZED", @"Manager not initialized", nil);
         return;
     }
 
     NSLog(@"Stopping scan");
     [[FLICManager sharedManager] stopScan];
-    resolve(@{@"success": @YES, @"message": @"Scan stopped"});
+
+    resolve(nil);
 }
 
 - (void)forgetButton:(NSString *)uuid
     resolve:(RCTPromiseResolveBlock)resolve
     reject:(RCTPromiseRejectBlock)reject
 {
-    if (!self.manager) {
+    if (![FLICManager sharedManager]) {
         reject(@"NOT_INITIALIZED", @"Manager not initialized", nil);
         return;
     }
 
-    // Find button in shared manager's buttons array
-    NSArray<FLICButton *> *buttons = [[FLICManager sharedManager] buttons];
-    FLICButton *button = nil;
-    for (FLICButton *btn in buttons) {
-        if ([btn.uuid isEqualToString:uuid]) {
-            button = btn;
-            break;
-        }
-    }
+    FLICButton *button = [self findButtonByUUID:uuid];
 
     if (!button) {
         reject(@"BUTTON_NOT_FOUND", @"Button not found", nil);
@@ -160,7 +154,7 @@
         if (error) {
             reject(@"FORGET_ERROR", error.localizedDescription, error);
         } else {
-            resolve(@{@"success": @YES, @"message": @"Button forgotten"});
+            resolve(nil);
         }
     }];
 }
@@ -171,15 +165,7 @@
     resolve:(RCTPromiseResolveBlock)resolve
     reject:(RCTPromiseRejectBlock)reject
 {
-    // Find button in shared manager's buttons array
-    NSArray<FLICButton *> *buttons = [[FLICManager sharedManager] buttons];
-    FLICButton *button = nil;
-    for (FLICButton *btn in buttons) {
-        if ([btn.uuid isEqualToString:uuid]) {
-            button = btn;
-            break;
-        }
-    }
+    FLICButton *button = [self findButtonByUUID:uuid];
 
     if (!button) {
         reject(@"BUTTON_NOT_FOUND", @"Button not found", nil);
@@ -187,22 +173,14 @@
     }
 
     [button connect];
-    resolve(@{@"success": @YES, @"message": @"Connection initiated"});
+    resolve([self buttonToDictionary:button]);
 }
 
 - (void)disconnectButton:(NSString *)uuid
     resolve:(RCTPromiseResolveBlock)resolve
     reject:(RCTPromiseRejectBlock)reject
 {
-    // Find button in shared manager's buttons array
-    NSArray<FLICButton *> *buttons = [[FLICManager sharedManager] buttons];
-    FLICButton *button = nil;
-    for (FLICButton *btn in buttons) {
-        if ([btn.uuid isEqualToString:uuid]) {
-            button = btn;
-            break;
-        }
-    }
+    FLICButton *button = [self findButtonByUUID:uuid];
 
     if (!button) {
         reject(@"BUTTON_NOT_FOUND", @"Button not found", nil);
@@ -210,22 +188,14 @@
     }
 
     [button disconnect];
-    resolve(@{@"success": @YES, @"message": @"Disconnection initiated"});
+    resolve([self buttonToDictionary:button]);
 }
 
 - (void)setTriggerMode:(NSString *)uuid mode:(NSInteger)mode
     resolve:(RCTPromiseResolveBlock)resolve
     reject:(RCTPromiseRejectBlock)reject
 {
-    // Find button in shared manager's buttons array
-    NSArray<FLICButton *> *buttons = [[FLICManager sharedManager] buttons];
-    FLICButton *button = nil;
-    for (FLICButton *btn in buttons) {
-        if ([btn.uuid isEqualToString:uuid]) {
-            button = btn;
-            break;
-        }
-    }
+    FLICButton *button = [self findButtonByUUID:uuid];
 
     if (!button) {
         reject(@"BUTTON_NOT_FOUND", @"Button not found", nil);
@@ -233,22 +203,14 @@
     }
 
     button.triggerMode = (FLICButtonTriggerMode)mode;
-    resolve(@{@"success": @YES, @"message": @"Trigger mode set"});
+    resolve([self buttonToDictionary:button]);
 }
 
 - (void)setLatencyMode:(NSString *)uuid mode:(NSInteger)mode
     resolve:(RCTPromiseResolveBlock)resolve
     reject:(RCTPromiseRejectBlock)reject
 {
-    // Find button in shared manager's buttons array
-    NSArray<FLICButton *> *buttons = [[FLICManager sharedManager] buttons];
-    FLICButton *button = nil;
-    for (FLICButton *btn in buttons) {
-        if ([btn.uuid isEqualToString:uuid]) {
-            button = btn;
-            break;
-        }
-    }
+    FLICButton *button = [self findButtonByUUID:uuid];
 
     if (!button) {
         reject(@"BUTTON_NOT_FOUND", @"Button not found", nil);
@@ -256,22 +218,14 @@
     }
 
     button.latencyMode = (FLICLatencyMode)mode;
-    resolve(@{@"success": @YES, @"message": @"Latency mode set"});
+    resolve([self buttonToDictionary:button]);
 }
 
 - (void)setNickname:(NSString *)uuid nickname:(NSString *)nickname
     resolve:(RCTPromiseResolveBlock)resolve
     reject:(RCTPromiseRejectBlock)reject
 {
-    // Find button in shared manager's buttons array
-    NSArray<FLICButton *> *buttons = [[FLICManager sharedManager] buttons];
-    FLICButton *button = nil;
-    for (FLICButton *btn in buttons) {
-        if ([btn.uuid isEqualToString:uuid]) {
-            button = btn;
-            break;
-        }
-    }
+    FLICButton *button = [self findButtonByUUID:uuid];
 
     if (!button) {
         reject(@"BUTTON_NOT_FOUND", @"Button not found", nil);
@@ -279,7 +233,7 @@
     }
 
     button.nickname = nickname;
-    resolve(@{@"success": @YES, @"message": @"Nickname set"});
+    resolve([self buttonToDictionary:button]);
 }
 
 // MARK: - Helper Methods
@@ -287,7 +241,7 @@
 - (void)connectAllKnownButtons:(RCTPromiseResolveBlock)resolve
     reject:(RCTPromiseRejectBlock)reject
 {
-    if (!self.manager) {
+    if (![FLICManager sharedManager]) {
         reject(@"NOT_INITIALIZED", @"Manager not initialized", nil);
         return;
     }
@@ -300,13 +254,13 @@
         [button connect];
     }
 
-    resolve(@{@"success": @YES, @"message": @"All buttons connection initiated"});
+    resolve(nil);
 }
 
 - (void)disconnectAllKnownButtons:(RCTPromiseResolveBlock)resolve
     reject:(RCTPromiseRejectBlock)reject
 {
-    if (!self.manager) {
+    if (![FLICManager sharedManager]) {
         reject(@"NOT_INITIALIZED", @"Manager not initialized", nil);
         return;
     }
@@ -318,13 +272,13 @@
         [button disconnect];
     }
 
-    resolve(@{@"success": @YES, @"message": @"All buttons disconnection initiated"});
+    resolve(nil);
 }
 
 - (void)forgetAllButtons:(RCTPromiseResolveBlock)resolve
     reject:(RCTPromiseRejectBlock)reject
 {
-    if (!self.manager) {
+    if (![FLICManager sharedManager]) {
         reject(@"NOT_INITIALIZED", @"Manager not initialized", nil);
         return;
     }
@@ -338,13 +292,13 @@
         }];
     }
 
-    resolve(@{@"success": @YES, @"message": @"All buttons forgotten"});
+    resolve(nil);
 }
 
 - (void)isScanning:(RCTPromiseResolveBlock)resolve
     reject:(RCTPromiseRejectBlock)reject
 {
-    if (!self.manager) {
+    if (![FLICManager sharedManager]) {
         reject(@"NOT_INITIALIZED", @"Manager not initialized", nil);
         return;
     }
@@ -358,36 +312,44 @@
 - (void)managerDidRestoreState:(FLICManager *)manager {
     self.managerRestored = YES;
     NSLog(@"Manager state restored - ready for operations");
-    [self emitOnManagerStateChange:@{
-        @"event": @"restored",
-        @"message": @"Manager state restored"
-    }];
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [self emitOnManagerStateChange:@{
+            @"event": @"restored",
+            @"message": @"Manager state restored"
+        }];
+    });
 }
 
 - (void)manager:(FLICManager *)manager didUpdateState:(FLICManagerState)state {
-    [self emitOnManagerStateChange:@{
-        @"state": @(state),
-        @"stateName": [self managerStateToString:state],
-        @"event": @"stateChanged"
-    }];
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [self emitOnManagerStateChange:@{
+            @"state": @(state),
+            @"stateName": [self managerStateToString:state],
+            @"event": @"stateChanged"
+        }];
+    });
 }
 
 // MARK: - FLICButtonDelegate
 
 - (void)buttonDidConnect:(FLICButton *)button {
-    [self emitOnButtonEvent:@{
-        @"uuid": button.uuid,
-        @"event": @"connected",
-        @"button": [self buttonToDictionary:button]
-    }];
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [self emitOnButtonEvent:@{
+            @"uuid": button.uuid,
+            @"event": @"connected",
+            @"button": [self buttonToDictionary:button]
+        }];
+    });
 }
 
 - (void)buttonIsReady:(FLICButton *)button {
-    [self emitOnButtonEvent:@{
-        @"uuid": button.uuid,
-        @"event": @"ready",
-        @"button": [self buttonToDictionary:button]
-    }];
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [self emitOnButtonEvent:@{
+            @"uuid": button.uuid,
+            @"event": @"ready",
+            @"button": [self buttonToDictionary:button]
+        }];
+    });
 }
 
 - (void)button:(FLICButton *)button didDisconnectWithError:(NSError * _Nullable)error {
@@ -404,99 +366,129 @@
         };
     }
 
-    [self emitOnButtonEvent:eventData];
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [self emitOnButtonEvent:eventData];
+    });
 }
 
 - (void)button:(FLICButton *)button didFailToConnectWithError:(NSError * _Nullable)error {
-    [self emitOnButtonEvent:@{
-        @"uuid": button.uuid,
-        @"event": @"connectionFailed",
-        @"error": @{
-            @"code": @(error.code),
-            @"message": error.localizedDescription
-        },
-        @"button": [self buttonToDictionary:button]
-    }];
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [self emitOnButtonEvent:@{
+            @"uuid": button.uuid,
+            @"event": @"connectionFailed",
+            @"error": @{
+                @"code": @(error.code),
+                @"message": error.localizedDescription
+            },
+            @"button": [self buttonToDictionary:button]
+        }];
+    });
 }
 
 - (void)button:(FLICButton *)button didReceiveButtonDown:(BOOL)queued age:(NSInteger)age {
-    [self emitOnButtonEvent:@{
-        @"uuid": button.uuid,
-        @"event": @"buttonDown",
-        @"queued": @(queued),
-        @"age": @(age),
-        @"button": [self buttonToDictionary:button]
-    }];
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [self emitOnButtonEvent:@{
+            @"uuid": button.uuid,
+            @"event": @"buttonDown",
+            @"queued": @(queued),
+            @"age": @(age),
+            @"button": [self buttonToDictionary:button]
+        }];
+    });
 }
 
 - (void)button:(FLICButton *)button didReceiveButtonUp:(BOOL)queued age:(NSInteger)age {
-    [self emitOnButtonEvent:@{
-        @"uuid": button.uuid,
-        @"event": @"buttonUp",
-        @"queued": @(queued),
-        @"age": @(age),
-        @"button": [self buttonToDictionary:button]
-    }];
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [self emitOnButtonEvent:@{
+            @"uuid": button.uuid,
+            @"event": @"buttonUp",
+            @"queued": @(queued),
+            @"age": @(age),
+            @"button": [self buttonToDictionary:button]
+        }];
+    });
 }
 
 - (void)button:(FLICButton *)button didReceiveButtonClick:(BOOL)queued age:(NSInteger)age {
-    [self emitOnButtonEvent:@{
-        @"uuid": button.uuid,
-        @"event": @"click",
-        @"queued": @(queued),
-        @"age": @(age),
-        @"button": [self buttonToDictionary:button]
-    }];
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [self emitOnButtonEvent:@{
+            @"uuid": button.uuid,
+            @"event": @"click",
+            @"queued": @(queued),
+            @"age": @(age),
+            @"button": [self buttonToDictionary:button]
+        }];
+    });
 }
 
 - (void)button:(FLICButton *)button didReceiveButtonDoubleClick:(BOOL)queued age:(NSInteger)age {
-    [self emitOnButtonEvent:@{
-        @"uuid": button.uuid,
-        @"event": @"doubleClick",
-        @"queued": @(queued),
-        @"age": @(age),
-        @"button": [self buttonToDictionary:button]
-    }];
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [self emitOnButtonEvent:@{
+            @"uuid": button.uuid,
+            @"event": @"doubleClick",
+            @"queued": @(queued),
+            @"age": @(age),
+            @"button": [self buttonToDictionary:button]
+        }];
+    });
 }
 
 - (void)button:(FLICButton *)button didReceiveButtonHold:(BOOL)queued age:(NSInteger)age {
-    [self emitOnButtonEvent:@{
-        @"uuid": button.uuid,
-        @"event": @"hold",
-        @"queued": @(queued),
-        @"age": @(age),
-        @"button": [self buttonToDictionary:button]
-    }];
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [self emitOnButtonEvent:@{
+            @"uuid": button.uuid,
+            @"event": @"hold",
+            @"queued": @(queued),
+            @"age": @(age),
+            @"button": [self buttonToDictionary:button]
+        }];
+    });
 }
 
 - (void)button:(FLICButton *)button didUnpairWithError:(NSError * _Nullable)error {
-    [self emitOnButtonEvent:@{
-        @"uuid": button.uuid,
-        @"event": @"unpaired",
-        @"button": [self buttonToDictionary:button]
-    }];
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [self emitOnButtonEvent:@{
+            @"uuid": button.uuid,
+            @"event": @"unpaired",
+            @"button": [self buttonToDictionary:button]
+        }];
+    });
 }
 
 - (void)button:(FLICButton *)button didUpdateBatteryVoltage:(float)voltage {
-    [self emitOnButtonEvent:@{
-        @"uuid": button.uuid,
-        @"event": @"batteryUpdate",
-        @"voltage": @(voltage),
-        @"button": [self buttonToDictionary:button]
-    }];
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [self emitOnButtonEvent:@{
+            @"uuid": button.uuid,
+            @"event": @"batteryUpdate",
+            @"voltage": @(voltage),
+            @"button": [self buttonToDictionary:button]
+        }];
+    });
 }
 
 - (void)button:(FLICButton *)button didUpdateNickname:(NSString *)nickname {
-    [self emitOnButtonEvent:@{
-        @"uuid": button.uuid,
-        @"event": @"nicknameUpdate",
-        @"nickname": nickname,
-        @"button": [self buttonToDictionary:button]
-    }];
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [self emitOnButtonEvent:@{
+            @"uuid": button.uuid,
+            @"event": @"nicknameUpdate",
+            @"nickname": nickname,
+            @"button": [self buttonToDictionary:button]
+        }];
+    });
 }
 
 // MARK: - Helper Methods
 
+- (FLICButton *)findButtonByUUID:(NSString *)uuid {
+    NSArray<FLICButton *> *buttons = [[FLICManager sharedManager] buttons];
+    for (FLICButton *button in buttons) {
+        if ([button.uuid isEqualToString:uuid]) {
+            return button;
+        }
+    }
+    return nil;
+}
+
 - (NSDictionary *)buttonToDictionary:(FLICButton *)button {
     return @{
         @"uuid": button.uuid,
@@ -579,18 +571,54 @@
     }
 }
 
-- (NSString *)scannerEventToString:(FLICButtonScannerStatusEvent)event {
-    switch (event) {
-        case FLICButtonScannerStatusEventDiscovered:
-            return @"discovered";
-        case FLICButtonScannerStatusEventConnected:
-            return @"connected";
-        case FLICButtonScannerStatusEventVerified:
-            return @"verified";
-        case FLICButtonScannerStatusEventVerificationFailed:
-            return @"verificationFailed";
+- (NSInteger)mapScanErrorToResultCode:(NSError *)error {
+    if (!error) {
+        return 0; // SUCCESS
+    }
+
+    switch (error.code) {
+        case FLICButtonScannerErrorCodeBluetoothNotActivated:
+            return 2; // BLUETOOTH_NOT_ACTIVATED
+        case FLICButtonScannerErrorCodeUnknown:
+            return 3; // UNKNOWN
+        case FLICButtonScannerErrorCodeNoPublicButtonDiscovered:
+            return 4; // NO_PUBLIC_BUTTON_DISCOVERED
+        case FLICButtonScannerErrorCodeAlreadyConnectedToAnotherDevice:
+            return 5; // ALREADY_CONNECTED_TO_ANOTHER_DEVICE
+        case FLICButtonScannerErrorCodeConnectionTimeout:
+            return 6; // CONNECTION_TIMEOUT
+        case FLICButtonScannerErrorCodeInvalidVerifier:
+            return 7; // INVALID_VERIFIER
+        case FLICButtonScannerErrorCodeBLEPairingFailedPreviousPairingAlreadyExisting:
+            return 8; // BLE_PAIRING_FAILED_PREVIOUS_PAIRING_ALREADY_EXISTING
+        case FLICButtonScannerErrorCodeBLEPairingFailedUserCanceled:
+            return 9; // BLE_PAIRING_FAILED_USER_CANCELED
+        case FLICButtonScannerErrorCodeBLEPairingFailedUnknownReason:
+            return 10; // BLE_PAIRING_FAILED_UNKNOWN_REASON
+        case FLICButtonScannerErrorCodeAppCredentialsDontMatch:
+            return 11; // APP_CREDENTIALS_DONT_MATCH
+        case FLICButtonScannerErrorCodeUserCanceled:
+            return 12; // USER_CANCELED
+        case FLICButtonScannerErrorCodeInvalidBluetoothAddress:
+            return 13; // INVALID_BLUETOOTH_ADDRESS
+        case FLICButtonScannerErrorCodeGenuineCheckFailed:
+            return 14; // GENUINE_CHECK_FAILED
+        case FLICButtonScannerErrorCodeTooManyApps:
+            return 15; // TOO_MANY_APPS
+        case FLICButtonScannerErrorCodeCouldNotSetBluetoothNotify:
+            return 16; // COULD_NOT_SET_BLUETOOTH_NOTIFY
+        case FLICButtonScannerErrorCodeCouldNotDiscoverBluetoothServices:
+            return 17; // COULD_NOT_DISCOVER_BLUETOOTH_SERVICES
+        case FLICButtonScannerErrorCodeButtonDisconnectedDuringVerification:
+            return 18; // BUTTON_DISCONNECTED_DURING_VERIFICATION
+        case FLICButtonScannerErrorCodeFailedToEstablish:
+            return 19; // FAILED_TO_ESTABLISH
+        case FLICButtonScannerErrorCodeConnectionLimitReached:
+            return 20; // CONNECTION_LIMIT_REACHED
+        case FLICButtonScannerErrorCodeNotInPublicMode:
+            return 21; // NOT_IN_PUBLIC_MODE
         default:
-            return @"unknown";
+            return 3; // UNKNOWN
     }
 }