@rodrigo7/react-native-beacons-manager 1.0.0

package/ios/RNiBeacon/RNiBeacon/ESSTimer.h

@@ -0,0 +1,72 @@
+// Copyright 2015 Google Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#import <Foundation/Foundation.h>
+
+@class ESSTimer;
+
+typedef void(^ESSTimerBlock)(ESSTimer *timer);
+
+/**
+ *=-----------------------------------------------------------------------------------------------=
+ * ESSTimer
+ *=-----------------------------------------------------------------------------------------------=
+ * A Timer class, much like NSTimer, but implemented using dispatch queues and sources.
+ */
+@interface ESSTimer : NSObject
+
+@property(nonatomic, copy, readonly) ESSTimerBlock block;
+@property(nonatomic, strong, readonly) dispatch_queue_t queue;
+@property(nonatomic, assign, readonly) NSTimeInterval delay;
+
+- (ESSTimer *)initWithDelay:(NSTimeInterval)delay
+                    onQueue:(dispatch_queue_t)queue
+                      block:(ESSTimerBlock)block;
+
++ (ESSTimer *)timerWithDelay:(NSTimeInterval)delay
+                     onQueue:(dispatch_queue_t)queue
+                       block:(ESSTimerBlock)block;
+
++ (ESSTimer *)scheduledTimerWithDelay:(NSTimeInterval)delay
+                              onQueue:(dispatch_queue_t)queue
+                                block:(ESSTimerBlock)block;
+
+/**
+ * Schedule this timer so that it will fire after the specified delay.
+ */
+- (void)schedule;
+
+/**
+ * Reschedule the timer, so it will fire after the specified delay from the current time, rather
+ * than from when it was initially scheduled or last rescheduled.
+ * This should not be called before |schedule|, though it will have no effect.
+ */
+- (void)reschedule;
+
+/**
+ * Suspend this timer, so that it will not fire unless and until it has been resumed.
+ */
+- (void)suspend;
+
+/**
+ * Resume the timer to allow it to fire.
+ */
+- (void)resume;
+
+/**
+ * Cancel the timer, preventing it from ever firing again.
+ */
+- (void)cancel;
+
+@end

package/ios/RNiBeacon/RNiBeacon/ESSTimer.m

@@ -0,0 +1,107 @@
+// Copyright 2015 Google Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#import "ESSTimer.h"
+
+/**
+ *=-----------------------------------------------------------------------------------------------=
+ * Private Additions to ESSTimer
+ *=-----------------------------------------------------------------------------------------------=
+ */
+@interface ESSTimer ()
+
+@property(nonatomic, copy, readwrite) ESSTimerBlock block;
+@property(nonatomic, copy, readwrite) void(^wrappedBlock)();
+@property(nonatomic, strong, readwrite) dispatch_queue_t queue;
+@property(nonatomic, assign, readwrite) NSTimeInterval delay;
+
+// The dispatch source used for the timer.
+@property(nonatomic, strong, readwrite) dispatch_source_t source;
+
+@property(nonatomic, assign) BOOL suspended;
+
+@end
+
+/**
+ *=-----------------------------------------------------------------------------------------------=
+ * Implementation for ESSTimer
+ *=-----------------------------------------------------------------------------------------------=
+ */
+@implementation ESSTimer
+
+- (ESSTimer *)initWithDelay:(NSTimeInterval)delay
+                    onQueue:(dispatch_queue_t)queue
+                      block:(ESSTimerBlock)block {
+  self = [super init];
+  if (self) {
+    _block = block;
+    _queue = queue;
+    _delay = delay;
+
+    __block ESSTimer *blockSelf = self;
+
+    _wrappedBlock = ^{
+      // This is a one-shot timer - ensure we don't call its block after it has been canceled.
+      if (!dispatch_source_testcancel(blockSelf.source)) {
+        dispatch_source_cancel(blockSelf.source);
+        blockSelf.block(blockSelf);
+      }
+    };
+
+    _source = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, _queue);
+  }
+  return self;
+}
+
++ (ESSTimer *)timerWithDelay:(NSTimeInterval)delay
+                     onQueue:(dispatch_queue_t)queue
+                       block:(ESSTimerBlock)block {
+  return [[self alloc] initWithDelay:delay onQueue:queue block:block];
+
+}
+
++ (ESSTimer *)scheduledTimerWithDelay:(NSTimeInterval)delay
+                              onQueue:(dispatch_queue_t)queue
+                                block:(ESSTimerBlock)block {
+  ESSTimer *timer = [self timerWithDelay:delay onQueue:queue block:block];
+  [timer schedule];
+  return timer;
+}
+
+- (void)schedule {
+  [self reschedule];
+  dispatch_source_set_event_handler(_source, _wrappedBlock);
+  dispatch_resume(_source);
+}
+
+- (void)reschedule {
+  dispatch_time_t start = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(_delay * NSEC_PER_SEC));
+  // Leeway is 10% of timer delay
+  dispatch_source_set_timer(_source, start, DISPATCH_TIME_FOREVER,
+                            (uint64_t)(_delay / 10) * NSEC_PER_SEC);
+}
+
+- (void)suspend {
+  dispatch_suspend(_source);
+}
+
+- (void)resume {
+  dispatch_resume(_source);
+}
+
+- (void)cancel {
+  dispatch_source_cancel(_source);
+}
+
+@end

package/ios/RNiBeacon/RNiBeacon/RNiBeacon.h

@@ -0,0 +1,16 @@
+//
+//  RNiBeacon.h
+//  RNiBeacon
+//
+//  Created by MacKentoch on 17/02/2017.
+//  Copyright © 2017 Erwan DATIN. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RNiBeacon : RCTEventEmitter <RCTBridgeModule>
+
+@end

package/ios/RNiBeacon/RNiBeacon/RNiBeacon.m

@@ -0,0 +1,467 @@
+//
+//  RNiBeacon.m
+//  RNiBeacon
+//
+//  Created by MacKentoch on 17/02/2017.
+//  Copyright © 2017 Erwan DATIN. All rights reserved.
+//
+
+#import <CoreLocation/CoreLocation.h>
+
+#import <React/RCTBridge.h>
+#import <React/RCTConvert.h>
+#import <React/RCTEventDispatcher.h>
+#import "ESSBeaconScanner.h"
+#import "ESSEddystone.h"
+
+#import "RNiBeacon.h"
+
+static NSString *const kEddystoneRegionID = @"EDDY_STONE_REGION_ID";
+bool hasListeners = NO;
+
+@interface RNiBeacon() <CLLocationManagerDelegate, ESSBeaconScannerDelegate>
+
+@property (strong, nonatomic) CLLocationManager *locationManager;
+@property (strong, nonatomic) ESSBeaconScanner *eddyStoneScanner;
+@property (assign, nonatomic) BOOL dropEmptyRanges;
+
+@end
+
+@implementation RNiBeacon
+
+// Will be called when this module's first listener is added.
+- (void)startObserving {
+  hasListeners = YES;
+}
+// Will be called when this module's last listener is removed, or on dealloc.
+- (void)stopObserving {
+  hasListeners = NO;
+}
+
+RCT_EXPORT_MODULE()
+
+#pragma mark Initialization
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    self.locationManager = [[CLLocationManager alloc] init];
+
+    self.locationManager.delegate = self;
+    self.locationManager.pausesLocationUpdatesAutomatically = NO;
+    self.dropEmptyRanges = NO;
+
+    self.eddyStoneScanner = [[ESSBeaconScanner alloc] init];
+    self.eddyStoneScanner.delegate = self;
+  }
+
+  return self;
+}
+
+- (NSArray<NSString *> *)supportedEvents
+{
+    return @[
+             @"authorizationStatusDidChange",
+             @"beaconsDidRange",
+             @"regionDidEnter",
+             @"regionDidExit",
+             @"didDetermineState"
+             ];
+}
+
+#pragma mark
+
+-(CLBeaconRegion *) createBeaconRegion: (NSString *) identifier
+                                  uuid: (NSString *) uuid
+                                 major: (NSInteger) major
+                                 minor:(NSInteger) minor
+{
+  NSUUID *beaconUUID = [[NSUUID alloc] initWithUUIDString:uuid];
+
+  unsigned short mj = (unsigned short) major;
+  unsigned short mi = (unsigned short) minor;
+
+  CLBeaconRegion *beaconRegion = [[CLBeaconRegion alloc] initWithProximityUUID:beaconUUID major:mj
+                                                                         minor:mi
+                                                                    identifier:identifier];
+
+  NSLog(@"createBeaconRegion with: identifier - uuid - major - minor");
+  beaconRegion.notifyOnEntry = YES;
+  beaconRegion.notifyOnExit = YES;
+  beaconRegion.notifyEntryStateOnDisplay = YES;
+
+  return beaconRegion;
+}
+
+-(CLBeaconRegion *) createBeaconRegion: (NSString *) identifier
+                                  uuid: (NSString *) uuid
+                                 major: (NSInteger) major
+{
+  NSUUID *beaconUUID = [[NSUUID alloc] initWithUUIDString:uuid];
+
+  unsigned short mj = (unsigned short) major;
+
+  CLBeaconRegion *beaconRegion = [[CLBeaconRegion alloc] initWithProximityUUID:beaconUUID
+                                                                         major:mj
+                                                                    identifier:identifier];
+
+  NSLog(@"createBeaconRegion with: identifier - uuid - major");
+  beaconRegion.notifyOnEntry = YES;
+  beaconRegion.notifyOnExit = YES;
+  beaconRegion.notifyEntryStateOnDisplay = YES;
+
+  return beaconRegion;
+}
+
+-(CLBeaconRegion *) createBeaconRegion: (NSString *) identifier
+                                  uuid: (NSString *) uuid
+{
+  NSUUID *beaconUUID = [[NSUUID alloc] initWithUUIDString:uuid];
+
+  CLBeaconRegion *beaconRegion = [[CLBeaconRegion alloc] initWithProximityUUID:beaconUUID
+                                                                    identifier:identifier];
+
+  NSLog(@"createBeaconRegion with: identifier - uuid");
+  beaconRegion.notifyOnEntry = YES;
+  beaconRegion.notifyOnExit = YES;
+  beaconRegion.notifyEntryStateOnDisplay = YES;
+
+  return beaconRegion;
+}
+
+-(CLBeaconRegion *) convertDictToBeaconRegion: (NSDictionary *) dict
+{
+  if (dict[@"minor"] == nil) {
+    if (dict[@"major"] == nil) {
+      return [self createBeaconRegion:[RCTConvert NSString:dict[@"identifier"]]
+                                 uuid:[RCTConvert NSString:dict[@"uuid"]]];
+    } else {
+      return [self createBeaconRegion:[RCTConvert NSString:dict[@"identifier"]]
+                                 uuid:[RCTConvert NSString:dict[@"uuid"]]
+                                major:[RCTConvert NSInteger:dict[@"major"]]];
+    }
+  } else {
+    return [self createBeaconRegion:[RCTConvert NSString:dict[@"identifier"]]
+                               uuid:[RCTConvert NSString:dict[@"uuid"]]
+                              major:[RCTConvert NSInteger:dict[@"major"]]
+                              minor:[RCTConvert NSInteger:dict[@"minor"]]];
+  }
+}
+
+-(NSDictionary *) convertBeaconRegionToDict: (CLBeaconRegion *) region
+{
+  if (region.minor == nil) {
+    if (region.major == nil) {
+      return @{
+               @"identifier": region.identifier,
+               @"uuid": [region.proximityUUID UUIDString],
+               };
+    } else {
+      return @{
+               @"identifier": region.identifier,
+               @"uuid": [region.proximityUUID UUIDString],
+               @"major": region.major
+               };
+    }
+  } else {
+    return @{
+             @"identifier": region.identifier,
+             @"uuid": [region.proximityUUID UUIDString],
+             @"major": region.major,
+             @"minor": region.minor
+             };
+  }
+}
+
+-(NSString *)stringForProximity:(CLProximity)proximity {
+  switch (proximity) {
+    case CLProximityUnknown:    return @"unknown";
+    case CLProximityFar:        return @"far";
+    case CLProximityNear:       return @"near";
+    case CLProximityImmediate:  return @"immediate";
+    default:                    return @"";
+  }
+}
+
+RCT_EXPORT_METHOD(requestAlwaysAuthorization)
+{
+  if ([self.locationManager respondsToSelector:@selector(requestAlwaysAuthorization)]) {
+    [self.locationManager requestAlwaysAuthorization];
+  }
+}
+
+RCT_EXPORT_METHOD(requestWhenInUseAuthorization)
+{
+  if ([self.locationManager respondsToSelector:@selector(requestWhenInUseAuthorization)]) {
+    [self.locationManager requestWhenInUseAuthorization];
+  }
+}
+
+RCT_EXPORT_METHOD(allowsBackgroundLocationUpdates:(BOOL)allow)
+{
+  self.locationManager.allowsBackgroundLocationUpdates = allow;
+}
+
+RCT_EXPORT_METHOD(getAuthorizationStatus:(RCTResponseSenderBlock)callback)
+{
+  callback(@[[self nameForAuthorizationStatus:[CLLocationManager authorizationStatus]]]);
+}
+
+RCT_EXPORT_METHOD(getMonitoredRegions:(RCTResponseSenderBlock)callback)
+{
+  NSMutableArray *regionArray = [[NSMutableArray alloc] init];
+
+  for (CLBeaconRegion *region in self.locationManager.monitoredRegions) {
+    [regionArray addObject: [self convertBeaconRegionToDict: region]];
+  }
+
+  callback(@[regionArray]);
+}
+
+RCT_EXPORT_METHOD(startMonitoringForRegion:(NSDictionary *) dict)
+{
+  [self.locationManager startMonitoringForRegion:[self convertDictToBeaconRegion:dict]];
+}
+
+RCT_EXPORT_METHOD(startRangingBeaconsInRegion:(NSDictionary *) dict)
+{
+  if ([dict[@"identifier"] isEqualToString:kEddystoneRegionID]) {
+      [_eddyStoneScanner startScanning];
+  } else {
+      [self.locationManager startRangingBeaconsInRegion:[self convertDictToBeaconRegion:dict]];
+  }
+}
+
+RCT_EXPORT_METHOD(stopMonitoringForRegion:(NSDictionary *) dict)
+{
+  [self.locationManager stopMonitoringForRegion:[self convertDictToBeaconRegion:dict]];
+}
+
+RCT_EXPORT_METHOD(stopRangingBeaconsInRegion:(NSDictionary *) dict)
+{
+  if ([dict[@"identifier"] isEqualToString:kEddystoneRegionID]) {
+    [self.eddyStoneScanner stopScanning];
+  } else {
+    [self.locationManager stopRangingBeaconsInRegion:[self convertDictToBeaconRegion:dict]];
+  }
+}
+
+RCT_EXPORT_METHOD(requestStateForRegion:(NSDictionary *)dict)
+{
+  if ([self.locationManager respondsToSelector:@selector(requestStateForRegion:)]) {
+    [self.locationManager requestStateForRegion:[self convertDictToBeaconRegion:dict]];
+  }
+}
+
+RCT_EXPORT_METHOD(startUpdatingLocation)
+{
+  [self.locationManager startUpdatingLocation];
+}
+
+RCT_EXPORT_METHOD(stopUpdatingLocation)
+{
+  [self.locationManager stopUpdatingLocation];
+}
+
+RCT_EXPORT_METHOD(shouldDropEmptyRanges:(BOOL)drop)
+{
+  self.dropEmptyRanges = drop;
+}
+
+-(NSString *)nameForAuthorizationStatus:(CLAuthorizationStatus)authorizationStatus
+{
+  switch (authorizationStatus) {
+    case kCLAuthorizationStatusAuthorizedAlways:
+      return @"authorizedAlways";
+
+    case kCLAuthorizationStatusAuthorizedWhenInUse:
+      return @"authorizedWhenInUse";
+
+    case kCLAuthorizationStatusDenied:
+      return @"denied";
+
+    case kCLAuthorizationStatusNotDetermined:
+      return @"notDetermined";
+
+    case kCLAuthorizationStatusRestricted:
+      return @"restricted";
+  }
+}
+
+-(void)locationManager:(CLLocationManager *)manager didChangeAuthorizationStatus:(CLAuthorizationStatus)status
+{
+    NSString *statusName = [self nameForAuthorizationStatus:status];
+    if (self.bridge && hasListeners) {
+      [self sendEventWithName:@"authorizationStatusDidChange" body:statusName];
+    }
+}
+
+-(void)locationManager:(CLLocationManager *)manager rangingBeaconsDidFailForRegion:(CLBeaconRegion *)region withError:(NSError *)error
+{
+  NSLog(@"Failed ranging region: %@", error);
+}
+
+-(void)locationManager:(CLLocationManager *)manager monitoringDidFailForRegion:(CLRegion *)region withError:(NSError *)error {
+  NSLog(@"Failed monitoring region: %@", error);
+}
+
+-(void)locationManager:(CLLocationManager *)manager didFailWithError:(NSError *)error {
+  NSLog(@"Location manager failed: %@", error);
+}
+
+-(NSString *)stringForState:(CLRegionState)state {
+  switch (state) {
+    case CLRegionStateInside:   return @"inside";
+    case CLRegionStateOutside:  return @"outside";
+    case CLRegionStateUnknown:  return @"unknown";
+    default:                    return @"unknown";
+  }
+}
+
+- (void) locationManager:(CLLocationManager *)manager didDetermineState:(CLRegionState)state forRegion:(CLRegion *)region
+{
+    NSDictionary *event = @{
+                          @"state":   [self stringForState:state],
+                          @"identifier":  region.identifier,
+                          };
+    if (self.bridge && hasListeners) {
+      [self sendEventWithName:@"didDetermineState" body:event];
+    }
+}
+
+-(void) locationManager:(CLLocationManager *)manager didRangeBeacons:
+(NSArray *)beacons inRegion:(CLBeaconRegion *)region
+{
+  if (self.dropEmptyRanges && beacons.count == 0) {
+    return;
+  }
+  NSMutableArray *beaconArray = [[NSMutableArray alloc] init];
+
+  for (CLBeacon *beacon in beacons) {
+    [beaconArray addObject:@{
+                             @"uuid": [beacon.proximityUUID UUIDString],
+                             @"major": beacon.major,
+                             @"minor": beacon.minor,
+
+                             @"rssi": [NSNumber numberWithLong:beacon.rssi],
+                             @"proximity": [self stringForProximity: beacon.proximity],
+                             @"accuracy": [NSNumber numberWithDouble: beacon.accuracy],
+                             @"distance": [NSNumber numberWithDouble: beacon.accuracy],
+                             }];
+  }
+
+  NSDictionary *event = @{
+                          @"region": @{
+                              @"identifier": region.identifier,
+                              @"uuid": [region.proximityUUID UUIDString],
+                              },
+                          @"beacons": beaconArray
+                          };
+
+    if (self.bridge && hasListeners) {
+      [self sendEventWithName:@"beaconsDidRange" body:event];
+    }
+}
+
+-(void)locationManager:(CLLocationManager *)manager
+        didEnterRegion:(CLBeaconRegion *)region {
+
+  if (! [region respondsToSelector:@selector(proximityUUID)]) {
+    return;
+  }
+
+  NSDictionary *event = [self convertBeaconRegionToDict: region];
+
+  if (self.bridge && hasListeners) {
+    [self sendEventWithName:@"regionDidEnter" body:event];
+  }
+}
+
+-(void)locationManager:(CLLocationManager *)manager
+         didExitRegion:(CLBeaconRegion *)region {
+
+  if (! [region respondsToSelector:@selector(proximityUUID)]) {
+    return;
+  }
+
+  NSDictionary *event = [self convertBeaconRegionToDict: region];
+
+  if (self.bridge && hasListeners) {
+    [self sendEventWithName:@"regionDidExit" body:event];
+  }
+}
+
++ (BOOL)requiresMainQueueSetup
+{
+    return YES;
+}
+
+- (void)beaconScanner:(ESSBeaconScanner *)scanner didRangeBeacon:(NSArray *)beacons {
+    [self notifyAboutBeaconChanges:beacons];
+}
+
+- (void)notifyAboutBeaconChanges:(NSArray *)beacons {
+    NSMutableArray *beaconArray = [[NSMutableArray alloc] init];
+
+    for (id key in beacons) {
+        ESSBeaconInfo *beacon = key;
+        NSDictionary *info = [self getEddyStoneInfo:beacon];
+        [beaconArray addObject:info];
+    }
+    NSDictionary *event = @{
+                            @"region": @{
+                                    @"identifier": kEddystoneRegionID,
+                                    @"uuid": @"", // do not use for eddy stone
+                                    },
+                            @"beacons": beaconArray
+                            };
+    if (self.bridge && hasListeners) {
+      [self sendEventWithName:@"beaconsDidRange" body:event];
+    }
+}
+
+- (NSDictionary*)getEddyStoneInfo:(id)beaconInfo {
+    ESSBeaconInfo *info = beaconInfo;
+    NSNumber *distance = [self calculateDistance:info.txPower rssi:info.RSSI];
+    NSString *identifier = [self getEddyStoneUUID:info.beaconID.beaconID];
+    NSDictionary *beaconData = @{
+                                 @"identifier": identifier,
+                                 @"uuid": identifier,
+                                 @"rssi": info.RSSI,
+                                 @"txPower": info.txPower,
+                                 @"distance": distance,
+                                 };
+    return beaconData;
+}
+
+- (NSNumber*)calculateDistance:(NSNumber*)txPower rssi:(NSNumber*) rssi {
+    if ([rssi floatValue] >= 0){
+        return [NSNumber numberWithInt:-1];
+    }
+
+    float ratio = [rssi floatValue] / ([txPower floatValue] - 41);
+    if (ratio < 1.0) {
+        return [NSNumber numberWithFloat:pow(ratio, 10)];
+    }
+
+    float distance = (0.89976) * pow(ratio, 7.7095) + 0.111;
+    return [NSNumber numberWithFloat:distance];
+}
+
+- (NSString *)getEddyStoneUUID:(NSData*)data {
+    const unsigned char *dataBuffer = (const unsigned char *)[data bytes];
+    const int EDDYSTONE_UUID_LENGTH = 10;
+    if (!dataBuffer) {
+        return [NSString string];
+    }
+
+    NSMutableString *hexString  = [NSMutableString stringWithCapacity:(data.length * 2)];
+    [hexString appendString:@"0x"];
+    for (int i = 0; i < EDDYSTONE_UUID_LENGTH; ++i) {
+        [hexString appendString:[NSString stringWithFormat:@"%02lx", (unsigned long)dataBuffer[i]]];
+    }
+
+    return [NSString stringWithString:hexString];
+}
+
+@end