react-native-flic2 0.3.26 → 2.0.0-alpha.39

package/ios/Flic2.mm

@@ -0,0 +1,610 @@
+#import "Flic2.h"
+#import <React/RCTBridgeModule.h>
+
+@implementation Flic2
+
+- (instancetype)init {
+    self = [super init];
+    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
+    resolve:(RCTPromiseResolveBlock)resolve
+    reject:(RCTPromiseRejectBlock)reject
+{
+    // Configure the shared manager (this is the correct way)
+    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"});
+    } else {
+        reject(@"INIT_ERROR", @"Failed to initialize FLICManager", nil);
+    }
+}
+
+- (void)getButtons:(RCTPromiseResolveBlock)resolve
+    reject:(RCTPromiseRejectBlock)reject
+{
+    if (!self.manager) {
+        reject(@"NOT_INITIALIZED", @"Manager not initialized", nil);
+        return;
+    }
+
+    if (!self.managerRestored) {
+        reject(@"NOT_RESTORED", @"Manager not restored yet. Wait for managerDidRestoreState", nil);
+        return;
+    }
+
+    NSArray<FLICButton *> *buttons = [[FLICManager sharedManager] buttons];
+    NSMutableArray *buttonDicts = [[NSMutableArray alloc] init];
+
+    for (FLICButton *button in buttons) {
+        [buttonDicts addObject:[self buttonToDictionary:button]];
+    }
+
+    resolve(buttonDicts);
+}
+
+- (void)scanForButtons:(RCTPromiseResolveBlock)resolve
+    reject:(RCTPromiseRejectBlock)reject
+{
+    if (!self.manager) {
+        reject(@"NOT_INITIALIZED", @"Manager not initialized", nil);
+        return;
+    }
+
+    if (!self.managerRestored) {
+        reject(@"NOT_RESTORED", @"Manager not restored yet. Wait for managerDidRestoreState", nil);
+        return;
+    }
+
+    NSLog(@"Starting scan");
+
+    __weak Flic2 *weakSelf = self;
+
+    [[FLICManager sharedManager] scanForButtonsWithStateChangeHandler:^(FLICButtonScannerStatusEvent event) {
+        NSLog(@"Scan state change: %@", [weakSelf scannerEventToString:event]);
+        [weakSelf emitOnScanStatusChange:@{
+            @"event": @(event),
+            @"eventName": [weakSelf scannerEventToString:event]
+        }];
+    } completion:^(FLICButton * _Nullable button, NSError * _Nullable error) {
+        NSLog(@"Scan completion called - button: %@, error: %@", button ? @"YES" : @"NO", 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);
+            }
+        } else if (button) {
+            NSLog(@"Button found: %@", button.uuid);
+
+            // Set trigger mode and auto-connect like old implementation
+            button.triggerMode = FLICButtonTriggerModeClickAndDoubleClickAndHold;
+            [button connect];
+
+            // Emit button event for discovered button
+            [weakSelf emitOnButtonEvent:@{
+                @"uuid": button.uuid,
+                @"event": @"discovered",
+                @"button": [weakSelf buttonToDictionary:button]
+            }];
+        } else {
+            NSLog(@"No button found and no error");
+        }
+    }];
+
+    // Return immediately - scan results will come through events
+    resolve(@{@"success": @YES, @"message": @"Scan started"});
+}
+
+- (void)stopScan:(RCTPromiseResolveBlock)resolve
+    reject:(RCTPromiseRejectBlock)reject
+{
+    if (!self.manager) {
+        reject(@"NOT_INITIALIZED", @"Manager not initialized", nil);
+        return;
+    }
+
+    NSLog(@"Stopping scan");
+    [[FLICManager sharedManager] stopScan];
+    resolve(@{@"success": @YES, @"message": @"Scan stopped"});
+}
+
+- (void)forgetButton:(NSString *)uuid
+    resolve:(RCTPromiseResolveBlock)resolve
+    reject:(RCTPromiseRejectBlock)reject
+{
+    if (!self.manager) {
+        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;
+        }
+    }
+
+    if (!button) {
+        reject(@"BUTTON_NOT_FOUND", @"Button not found", nil);
+        return;
+    }
+
+    // Disconnect before forgetting like old implementation
+    [button disconnect];
+
+    [[FLICManager sharedManager] forgetButton:button completion:^(NSUUID *uuid, NSError * _Nullable error) {
+        if (error) {
+            reject(@"FORGET_ERROR", error.localizedDescription, error);
+        } else {
+            resolve(@{@"success": @YES, @"message": @"Button forgotten"});
+        }
+    }];
+}
+
+// MARK: - FLICButton Methods
+
+- (void)connectButton:(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;
+        }
+    }
+
+    if (!button) {
+        reject(@"BUTTON_NOT_FOUND", @"Button not found", nil);
+        return;
+    }
+
+    [button connect];
+    resolve(@{@"success": @YES, @"message": @"Connection initiated"});
+}
+
+- (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;
+        }
+    }
+
+    if (!button) {
+        reject(@"BUTTON_NOT_FOUND", @"Button not found", nil);
+        return;
+    }
+
+    [button disconnect];
+    resolve(@{@"success": @YES, @"message": @"Disconnection initiated"});
+}
+
+- (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;
+        }
+    }
+
+    if (!button) {
+        reject(@"BUTTON_NOT_FOUND", @"Button not found", nil);
+        return;
+    }
+
+    button.triggerMode = (FLICButtonTriggerMode)mode;
+    resolve(@{@"success": @YES, @"message": @"Trigger mode set"});
+}
+
+- (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;
+        }
+    }
+
+    if (!button) {
+        reject(@"BUTTON_NOT_FOUND", @"Button not found", nil);
+        return;
+    }
+
+    button.latencyMode = (FLICLatencyMode)mode;
+    resolve(@{@"success": @YES, @"message": @"Latency mode set"});
+}
+
+- (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;
+        }
+    }
+
+    if (!button) {
+        reject(@"BUTTON_NOT_FOUND", @"Button not found", nil);
+        return;
+    }
+
+    button.nickname = nickname;
+    resolve(@{@"success": @YES, @"message": @"Nickname set"});
+}
+
+// MARK: - Helper Methods
+
+- (void)connectAllKnownButtons:(RCTPromiseResolveBlock)resolve
+    reject:(RCTPromiseRejectBlock)reject
+{
+    if (!self.manager) {
+        reject(@"NOT_INITIALIZED", @"Manager not initialized", nil);
+        return;
+    }
+
+    NSArray<FLICButton *> *buttons = [[FLICManager sharedManager] buttons];
+
+    for (FLICButton *button in buttons) {
+        NSLog(@"Flic2 Connect button: %@", button.name);
+        button.triggerMode = FLICButtonTriggerModeClickAndDoubleClickAndHold;
+        [button connect];
+    }
+
+    resolve(@{@"success": @YES, @"message": @"All buttons connection initiated"});
+}
+
+- (void)disconnectAllKnownButtons:(RCTPromiseResolveBlock)resolve
+    reject:(RCTPromiseRejectBlock)reject
+{
+    if (!self.manager) {
+        reject(@"NOT_INITIALIZED", @"Manager not initialized", nil);
+        return;
+    }
+
+    NSArray<FLICButton *> *buttons = [[FLICManager sharedManager] buttons];
+
+    for (FLICButton *button in buttons) {
+        NSLog(@"Flic2 disconnect button: %@", button.name);
+        [button disconnect];
+    }
+
+    resolve(@{@"success": @YES, @"message": @"All buttons disconnection initiated"});
+}
+
+- (void)forgetAllButtons:(RCTPromiseResolveBlock)resolve
+    reject:(RCTPromiseRejectBlock)reject
+{
+    if (!self.manager) {
+        reject(@"NOT_INITIALIZED", @"Manager not initialized", nil);
+        return;
+    }
+
+    NSArray<FLICButton *> *buttons = [[FLICManager sharedManager] buttons];
+
+    for (FLICButton *button in buttons) {
+        [button disconnect];
+        [[FLICManager sharedManager] forgetButton:button completion:^(NSUUID *uuid, NSError * _Nullable error) {
+            // Individual completion handlers not needed for bulk operation
+        }];
+    }
+
+    resolve(@{@"success": @YES, @"message": @"All buttons forgotten"});
+}
+
+- (void)isScanning:(RCTPromiseResolveBlock)resolve
+    reject:(RCTPromiseRejectBlock)reject
+{
+    if (!self.manager) {
+        reject(@"NOT_INITIALIZED", @"Manager not initialized", nil);
+        return;
+    }
+
+    BOOL scanning = [[FLICManager sharedManager] isScanning];
+    resolve(@(scanning));
+}
+
+// MARK: - FLICManagerDelegate
+
+- (void)managerDidRestoreState:(FLICManager *)manager {
+    self.managerRestored = YES;
+    NSLog(@"Manager state restored - ready for operations");
+    [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"
+    }];
+}
+
+// MARK: - FLICButtonDelegate
+
+- (void)buttonDidConnect:(FLICButton *)button {
+    [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]
+    }];
+}
+
+- (void)button:(FLICButton *)button didDisconnectWithError:(NSError * _Nullable)error {
+    NSMutableDictionary *eventData = [NSMutableDictionary dictionaryWithDictionary:@{
+        @"uuid": button.uuid,
+        @"event": @"disconnected",
+        @"button": [self buttonToDictionary:button]
+    }];
+
+    if (error) {
+        eventData[@"error"] = @{
+            @"code": @(error.code),
+            @"message": error.localizedDescription
+        };
+    }
+
+    [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]
+    }];
+}
+
+- (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]
+    }];
+}
+
+- (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]
+    }];
+}
+
+- (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]
+    }];
+}
+
+- (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]
+    }];
+}
+
+- (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]
+    }];
+}
+
+- (void)button:(FLICButton *)button didUnpairWithError:(NSError * _Nullable)error {
+    [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]
+    }];
+}
+
+- (void)button:(FLICButton *)button didUpdateNickname:(NSString *)nickname {
+    [self emitOnButtonEvent:@{
+        @"uuid": button.uuid,
+        @"event": @"nicknameUpdate",
+        @"nickname": nickname,
+        @"button": [self buttonToDictionary:button]
+    }];
+}
+
+// MARK: - Helper Methods
+
+- (NSDictionary *)buttonToDictionary:(FLICButton *)button {
+    return @{
+        @"uuid": button.uuid,
+        @"identifier": button.identifier.UUIDString,
+        @"name": button.name ?: @"",
+        @"nickname": button.nickname ?: @"",
+        @"bluetoothAddress": button.bluetoothAddress,
+        @"serialNumber": button.serialNumber,
+        @"state": @(button.state),
+        @"stateName": [self buttonStateToString:button.state],
+        @"triggerMode": @(button.triggerMode),
+        @"triggerModeName": [self triggerModeToString:button.triggerMode],
+        @"latencyMode": @(button.latencyMode),
+        @"latencyModeName": [self latencyModeToString:button.latencyMode],
+        @"pressCount": @(button.pressCount),
+        @"firmwareRevision": @(button.firmwareRevision),
+        @"isReady": @(button.isReady),
+        @"batteryVoltage": @(button.batteryVoltage),
+        @"isUnpaired": @(button.isUnpaired)
+    };
+}
+
+- (NSString *)managerStateToString:(FLICManagerState)state {
+    switch (state) {
+        case FLICManagerStateUnknown:
+            return @"unknown";
+        case FLICManagerStateResetting:
+            return @"resetting";
+        case FLICManagerStateUnsupported:
+            return @"unsupported";
+        case FLICManagerStateUnauthorized:
+            return @"unauthorized";
+        case FLICManagerStatePoweredOff:
+            return @"poweredOff";
+        case FLICManagerStatePoweredOn:
+            return @"poweredOn";
+        default:
+            return @"unknown";
+    }
+}
+
+- (NSString *)buttonStateToString:(FLICButtonState)state {
+    switch (state) {
+        case FLICButtonStateDisconnected:
+            return @"disconnected";
+        case FLICButtonStateConnecting:
+            return @"connecting";
+        case FLICButtonStateConnected:
+            return @"connected";
+        case FLICButtonStateDisconnecting:
+            return @"disconnecting";
+        default:
+            return @"unknown";
+    }
+}
+
+- (NSString *)triggerModeToString:(FLICButtonTriggerMode)mode {
+    switch (mode) {
+        case FLICButtonTriggerModeClickAndHold:
+            return @"clickAndHold";
+        case FLICButtonTriggerModeClickAndDoubleClick:
+            return @"clickAndDoubleClick";
+        case FLICButtonTriggerModeClickAndDoubleClickAndHold:
+            return @"clickAndDoubleClickAndHold";
+        case FLICButtonTriggerModeClick:
+            return @"click";
+        default:
+            return @"unknown";
+    }
+}
+
+- (NSString *)latencyModeToString:(FLICLatencyMode)mode {
+    switch (mode) {
+        case FLICLatencyModeNormal:
+            return @"normal";
+        case FLICLatencyModeLow:
+            return @"low";
+        default:
+            return @"unknown";
+    }
+}
+
+- (NSString *)scannerEventToString:(FLICButtonScannerStatusEvent)event {
+    switch (event) {
+        case FLICButtonScannerStatusEventDiscovered:
+            return @"discovered";
+        case FLICButtonScannerStatusEventConnected:
+            return @"connected";
+        case FLICButtonScannerStatusEventVerified:
+            return @"verified";
+        case FLICButtonScannerStatusEventVerificationFailed:
+            return @"verificationFailed";
+        default:
+            return @"unknown";
+    }
+}
+
+
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+    return std::make_shared<facebook::react::NativeFlic2SpecJSI>(params);
+}
+
++ (NSString *)moduleName
+{
+  return @"Flic2";
+}
+
+@end

package/ios/flic2lib.framework/Headers/FLICButton.h

@@ -7,7 +7,7 @@
 //
 
 #import <Foundation/Foundation.h>
-#import "FLICEnums.h"
+#import <flic2lib/FLICEnums.h>
 
 NS_ASSUME_NONNULL_BEGIN
 

package/ios/flic2lib.framework/Headers/FLICManager.h

@@ -8,7 +8,7 @@
 
 #import <Foundation/Foundation.h>
 #import <CoreBluetooth/CoreBluetooth.h>
-#import "FLICButton.h"
+#import <flic2lib/FLICButton.h>
 
 NS_ASSUME_NONNULL_BEGIN
 

package/ios/flic2lib.framework/Modules/module.modulemap

@@ -1,6 +1,6 @@
 framework module flic2lib {
   umbrella header "flic2lib.h"
-
   export *
+
   module * { export * }
 }

package/lib/module/NativeFlic2.js

@@ -0,0 +1,14 @@
+"use strict";
+
+import { TurboModuleRegistry } from 'react-native';
+
+// MARK: - Event Types
+
+// MARK: - Flic2 Types
+
+// MARK: - Mode Types
+
+// MARK: - Spec Interface
+
+export default TurboModuleRegistry.getEnforcing('Flic2');
+//# sourceMappingURL=NativeFlic2.js.map

package/lib/module/NativeFlic2.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativeFlic2.ts"],"mappings":";;AAAA,SACEA,mBAAmB,QAGd,cAAc;;AAErB;;AA+CA;;AAsDA;;AAKA;;AA4CA,eAAeA,mBAAmB,CAACC,YAAY,CAAO,OAAO,CAAC","ignoreList":[]}