@rodrigo7/react-native-beacons-manager 1.0.0

package/ios/RNiBeacon/RNiBeacon/ESSBeaconScanner.m

@@ -0,0 +1,204 @@
+// 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 <CoreBluetooth/CoreBluetooth.h>
+
+#import "ESSBeaconScanner.h"
+#import "ESSEddystone.h"
+#import "ESSTimer.h"
+
+static const char *const kBeaconsOperationQueueName = "kESSBeaconScannerBeaconsOperationQueueName";
+static NSString *const kESSEddystoneServiceID = @"FEAA";
+static NSString *const kSeenCacheBeaconInfo = @"beacon_info";
+static NSString *const kSeenCacheOnLostTimer = @"on_lost_timer";
+
+/**
+ *=-----------------------------------------------------------------------------------------------=
+ * Private Additions to ESSBeaconScanner
+ *=-----------------------------------------------------------------------------------------------=
+ */
+@interface ESSBeaconScanner () <CBCentralManagerDelegate> {
+  CBCentralManager *_centralManager;
+  dispatch_queue_t _beaconOperationsQueue;
+
+  /**
+   * This cache maps Core Bluetooth deviceIDs to NSData objects containing Eddystone telemetry.
+   * Then, the next time we see a UID frame for that Eddystone, we can add the most recently seen
+   * telemetry frame to the sighting.
+   */
+  NSMutableDictionary *_tlmCache;
+
+  /**
+   * Beacons we've seen list.
+   */
+  NSMutableDictionary *_eddystoneBeaconsCache;
+
+  BOOL _shouldBeScanning;
+}
+
+@end
+
+/**
+ *=-----------------------------------------------------------------------------------------------=
+ * Implementation for ESSBeaconScanner
+ *=-----------------------------------------------------------------------------------------------=
+ */
+@implementation ESSBeaconScanner
+
+- (instancetype)init {
+  if ((self = [super init]) != nil) {
+    _onLostTimeout = 5.0;
+    _tlmCache = [NSMutableDictionary dictionary];
+    _beaconOperationsQueue = dispatch_queue_create(kBeaconsOperationQueueName, NULL);
+    _centralManager = [[CBCentralManager alloc] initWithDelegate:self
+                                                           queue:_beaconOperationsQueue];
+  }
+
+  return self;
+}
+
+- (void)startScanning {
+  dispatch_async(_beaconOperationsQueue, ^{
+    if (_centralManager.state != CBCentralManagerStatePoweredOn) {
+      NSLog(@"CBCentralManager state is %ld, cannot start or stop scanning",
+            (long)_centralManager.state);
+      _shouldBeScanning = YES;
+    } else {
+      NSLog(@"Starting to scan for Eddystones");
+      _eddystoneBeaconsCache = [[NSMutableDictionary alloc] init];
+      NSArray *services = @[
+          [CBUUID UUIDWithString:kESSEddystoneServiceID]
+      ];
+
+      // We do not want multiple discoveries of the same beacon to be coalesced into one.
+      // (Unfortunately this is ignored when we are in the background.)
+      NSDictionary *options = @{ CBCentralManagerScanOptionAllowDuplicatesKey : @YES };
+      [_centralManager scanForPeripheralsWithServices:services options:options];
+    }
+  });
+}
+
+- (void)stopScanning {
+  _shouldBeScanning = NO;
+  [_centralManager stopScan];
+  [self clearRemainingTimers];
+}
+
+- (void)centralManagerDidUpdateState:(CBCentralManager *)central {
+  if (central.state == CBCentralManagerStatePoweredOn && _shouldBeScanning) {
+    [self startScanning];
+  }
+}
+
+// This will be called from the |beaconsOperationQueue|.
+- (void)centralManager:(CBCentralManager *)central
+    didDiscoverPeripheral:(CBPeripheral *)peripheral
+        advertisementData:(NSDictionary *)advertisementData
+                     RSSI:(NSNumber *)RSSI {
+  NSDictionary *serviceData = advertisementData[CBAdvertisementDataServiceDataKey];
+  NSData *beaconServiceData = serviceData[[ESSBeaconInfo eddystoneServiceID]];
+
+  ESSFrameType frameType = [ESSBeaconInfo frameTypeForFrame:beaconServiceData];
+
+  // If it's a telemetry (TLM) frame, then save it into our cache so that the next time we get a
+  // UID frame (i.e. an Eddystone "sighting"), we can include the telemetry with it.
+  if (frameType == kESSEddystoneTelemetryFrameType) {
+    _tlmCache[peripheral.identifier] = beaconServiceData;
+  } else if (frameType == kESSEddystoneURLFrameType) {
+    NSURL *url = [ESSBeaconInfo parseURLFromFrameData:beaconServiceData];
+
+    // Report the sighted URL frame.
+    if ([_delegate respondsToSelector:@selector(beaconScanner:didFindURL:)]) {
+      [_delegate beaconScanner:self didFindURL:url];
+    }
+  } else if (frameType == kESSEddystoneUIDFrameType
+             || frameType == kESSEddystoneEIDFrameType) {
+    CBUUID *eddystoneServiceUUID = [ESSBeaconInfo eddystoneServiceID];
+    NSData *eddystoneServiceData = serviceData[eddystoneServiceUUID];
+
+    // If we have telemetry data for this Eddystone, include it in the construction of the
+    // ESSBeaconInfo object. Otherwise, nil is fine.
+    NSData *telemetry = _tlmCache[peripheral.identifier];
+
+    ESSBeaconInfo *beaconInfo;
+    if (frameType == kESSEddystoneUIDFrameType) {
+      beaconInfo = [ESSBeaconInfo beaconInfoForUIDFrameData:eddystoneServiceData
+                                                  telemetry:telemetry
+                                                       RSSI:RSSI];
+    } else {
+      beaconInfo = [ESSBeaconInfo beaconInfoForEIDFrameData:eddystoneServiceData
+                                                  telemetry:telemetry
+                                                       RSSI:RSSI];
+    }
+
+    if (beaconInfo) {
+      // NOTE: At this point you can choose whether to keep or get rid of the telemetry data. You
+      //       can either opt to include it with every single beacon sighting for this beacon, or
+      //       delete it until we get a new / "fresh" TLM frame. We'll treat it as "report it only
+      //       when you see it", so we'll delete it each time.
+      [_tlmCache removeObjectForKey:peripheral.identifier];
+
+      // If we haven't seen this Eddystone before, fire a beaconScanner:didFindBeacon: and mark it
+      // as seen.
+      if (!_eddystoneBeaconsCache[beaconInfo.beaconID]) {
+        ESSTimer *onLostTimer = [ESSTimer scheduledTimerWithDelay:_onLostTimeout
+                                                          onQueue:dispatch_get_main_queue()
+                                                            block:
+            ^(ESSTimer *timer) {
+              ESSBeaconInfo *lostBeaconInfo =
+                  _eddystoneBeaconsCache[beaconInfo.beaconID][kSeenCacheBeaconInfo];
+              if (lostBeaconInfo) {
+                [_eddystoneBeaconsCache removeObjectForKey:beaconInfo.beaconID];
+                [self notifyDidRangeBeacon:_eddystoneBeaconsCache];
+              }
+            }];
+
+        _eddystoneBeaconsCache[beaconInfo.beaconID] = @{
+            kSeenCacheBeaconInfo: beaconInfo,
+            kSeenCacheOnLostTimer: onLostTimer,
+        };
+        [self notifyDidRangeBeacon:_eddystoneBeaconsCache];
+      } else {
+        // Reset the onLost timer.
+        [_eddystoneBeaconsCache[beaconInfo.beaconID][kSeenCacheOnLostTimer] reschedule];
+        [self notifyDidRangeBeacon:_eddystoneBeaconsCache];
+      }
+    }
+  } else {
+    NSLog(@"Unsupported frame type (%d) detected. Ignorning.", (int)frameType);
+  }
+}
+
+/**
+ * Commont event about beacons changes in region
+ */
+- (void)notifyDidRangeBeacon:(NSMutableDictionary *)beacons {
+    if (![_delegate respondsToSelector:@selector(beaconScanner:didRangeBeacon:)]) return;
+    
+    NSMutableArray *beaconArray = [[NSMutableArray alloc] init];
+    for (id key in beacons) {
+        [beaconArray addObject:beacons[key][kSeenCacheBeaconInfo]];
+    }
+    [_delegate beaconScanner:self didRangeBeacon:beaconArray];
+}
+
+- (void)clearRemainingTimers {
+  for (ESSBeaconID *beaconID in _eddystoneBeaconsCache) {
+    [_eddystoneBeaconsCache[beaconID][kSeenCacheOnLostTimer] cancel];
+  }
+
+  _eddystoneBeaconsCache = nil;
+}
+
+@end

package/ios/RNiBeacon/RNiBeacon/ESSEddystone.h

@@ -0,0 +1,117 @@
+// 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>
+#import <CoreBluetooth/CoreBluetooth.h>
+
+typedef NS_ENUM(NSUInteger, ESSBeaconType) {
+  kESSBeaconTypeEddystone = 1,
+  kESSBeaconTypeEddystoneEID = 2,
+};
+
+typedef NS_ENUM(NSUInteger, ESSFrameType) {
+  kESSEddystoneUnknownFrameType = 0,
+  kESSEddystoneUIDFrameType,
+  kESSEddystoneURLFrameType,
+  kESSEddystoneEIDFrameType,
+  kESSEddystoneTelemetryFrameType,
+};
+
+/**
+ *=-----------------------------------------------------------------------------------------------=
+ * ESSBeaconID
+ *=-----------------------------------------------------------------------------------------------=
+ */
+@interface ESSBeaconID : NSObject <NSCopying>
+
+/**
+ * The type of the beacon. Currently only a couple of types are supported.
+ */
+@property(nonatomic, assign, readonly) ESSBeaconType beaconType;
+
+/**
+ * The raw beaconID data.
+ */
+@property(nonatomic, copy, readonly) NSData *beaconID;
+
+@end
+
+
+/**
+ *=-----------------------------------------------------------------------------------------------=
+ * ESSBeaconInfo
+ *=-----------------------------------------------------------------------------------------------=
+ */
+@interface ESSBeaconInfo : NSObject
+
+/**
+ * The most recent RSSI we got for this sighting. Sometimes the OS cannot compute one reliably, so
+ * this value can be null.
+ */
+@property(nonatomic, strong, readonly) NSNumber *RSSI;
+
+/**
+ * The beaconID for this Eddystone. All beacons have an ID.
+ */
+@property(nonatomic, strong, readonly) ESSBeaconID *beaconID;
+
+/**
+ * The telemetry that may or may not have been seen for this beacon. If it's set, the contents of
+ * it aren't terribly relevant to us, in general. See the Eddystone spec for more information
+ * if you're really interested in the exact details.
+ */
+@property(nonatomic, copy, readonly) NSData *telemetry;
+
+/**
+ * Transmission power reported by beacon. This is in dB.
+ */
+@property(nonatomic, strong, readonly) NSNumber *txPower;
+
+/**
+ * The scanner has seen a frame for an Eddystone. We'll need to know what type of Eddystone frame
+ * it is, as there are a few types.
+ */
++ (ESSFrameType)frameTypeForFrame:(NSData *)frameData;
+
+/**
+ * Given the service data for a frame we know to be a UID frame, an RSSI sighting,
+ * and -- optionally -- telemetry data (if we've seen it), create a new ESSBeaconInfo object to
+ * represent this Eddystone
+ */
++ (instancetype)beaconInfoForUIDFrameData:(NSData *)UIDFrameData
+                                telemetry:(NSData *)telemetry
+                                     RSSI:(NSNumber *)initialRSSI;
+
+/**
+ * Given the service data for a frame we know to be a UID frame, an RSSI sighting,
+ * and -- optionally -- telemetry data (if we've seen it), create a new ESSBeaconInfo object to
+ * represent this Eddystone
+ */
++ (instancetype)beaconInfoForEIDFrameData:(NSData *)EIDFrameData
+                                telemetry:(NSData *)telemetry
+                                     RSSI:(NSNumber *)initialRSSI;
+
+/**
+ * If we're given a URL frame, extract the URL from it.
+ */
++ (NSURL *)parseURLFromFrameData:(NSData *)URLFrameData;
+
+/**
+ * Convenience method to save everybody from creating these things all the time.
+ */
++ (CBUUID *)eddystoneServiceID;
+
++ (ESSBeaconInfo *)testBeaconFromBeaconIDString:(NSString *)beaconID;
+
+@end

package/ios/RNiBeacon/RNiBeacon/ESSEddystone.m

@@ -0,0 +1,352 @@
+// 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 "ESSEddystone.h"
+
+#import <CoreBluetooth/CoreBluetooth.h>
+
+/**
+ * The Bluetooth Service ID for Eddystones.
+ */
+static NSString *const kEddystoneServiceID = @"FEAA";
+
+/**
+ * Eddystones can have different frame types. Within the frames, these are (some of) the possible
+ * values. See the Eddystone spec for complete details.
+ */
+static const uint8_t kEddystoneUIDFrameTypeID = 0x00;
+static const uint8_t kEddystoneURLFrameTypeID = 0x10;
+static const uint8_t kEddystoneTLMFrameTypeID = 0x20;
+static const uint8_t kEddystoneEIDFrameTypeID = 0x30;
+
+// Note that for these Eddystone structures, the endianness of the individual fields is big-endian,
+// so you'll want to translate back to host format when necessary.
+// Note that in the Eddystone spec, the beaconID (UID) is divided into 2 fields, a 10 byte namespace
+// and a 6 byte instance id. However, since we ALWAYS use these in combination as a 16 byte
+// beaconID, we'll have our structure here reflect that.
+typedef struct __attribute__((packed)) {
+  uint8_t frameType;
+  int8_t  txPower;
+  uint8_t beaconID[16];
+  uint8_t RFU[2];
+} ESSEddystoneUIDFrameFields;
+
+typedef struct __attribute__((packed)) {
+  uint8_t frameType;
+  int8_t  txPower;
+  uint8_t beaconID[8];
+} ESSEddystoneEIDFrameFields;
+
+// Test equality, ensuring that nil is equal to itself.
+static inline BOOL IsEqualOrBothNil(id a, id b) {
+  return ((a == b) || (a && b && [a isEqual:b]));
+}
+
+/**
+ *=-----------------------------------------------------------------------------------------------=
+ * ESSBeaconID
+ *=-----------------------------------------------------------------------------------------------=
+ */
+@implementation ESSBeaconID
+
+/**
+ * This property is orginally declared in a superclass (NSObject), so cannot be auto-synthesized.
+ */
+@synthesize hash = _hash;
+
+- (instancetype)initWithType:(ESSBeaconType)beaconType
+                    beaconID:(NSData *)beaconID {
+  self = [super init];
+  if (self) {
+    _beaconType = beaconType;
+    _beaconID = [beaconID copy];
+    _hash = 31 * self.beaconType + [self.beaconID hash];
+  }
+  return self;
+}
+
+/**
+ * So that whenever you convert this to a string, you get something useful.
+ */
+- (NSString *)description {
+  if (self.beaconType == kESSBeaconTypeEddystone) {
+    return [NSString stringWithFormat:@"ESSBeaconID: beaconID=%@", self.beaconID];
+  } else if (self.beaconType == kESSBeaconTypeEddystoneEID) {
+    return [NSString stringWithFormat:@"ESSBeaconID (EID): beaconID=%@", self.beaconID];
+  } else {
+    return [NSString stringWithFormat:@"ESSBeaconID with invalid type %lu",
+            (unsigned long)self.beaconType];
+  }
+}
+
+- (BOOL)isEqual:(id)object {
+  if (object == self) {
+    return YES;
+  }
+  if (!self
+      || !object
+      || !([self isKindOfClass:[object class]] || [object isKindOfClass:[self class]])) {
+    return NO;
+  }
+
+  ESSBeaconID *other = (ESSBeaconID *)object;
+  return ((self.beaconType == other.beaconType) &&
+          IsEqualOrBothNil(self.beaconID, other.beaconID));
+}
+
+- (id)copyWithZone:(NSZone *)zone {
+  // Immutable object: 'copy' by reusing the same instance.
+  return self;
+}
+
+@end
+
+
+/**
+ *=-----------------------------------------------------------------------------------------------=
+ * ESSBeaconInfo
+ *=-----------------------------------------------------------------------------------------------=
+ */
+@implementation ESSBeaconInfo
+
+/**
+ * Given the advertising frames from CoreBluetooth for a device with the Eddystone Service ID,
+ * figure out what type of frame it is.
+ */
++ (ESSFrameType)frameTypeForFrame:(NSData *)frameData {
+  // It's an Eddystone ADV frame. Now check if it's a UID (ID) or TLM (telemetry) frame.
+  if (frameData) {
+    uint8_t frameType;
+    if ([frameData length] > 1) {
+      frameType = ((uint8_t *)[frameData bytes])[0];
+      switch (frameType) {
+        case kEddystoneUIDFrameTypeID:
+          return kESSEddystoneUIDFrameType;
+        case kEddystoneURLFrameTypeID:
+          return kESSEddystoneURLFrameType;
+        case kEddystoneTLMFrameTypeID:
+          return kESSEddystoneTelemetryFrameType;
+        case kEddystoneEIDFrameTypeID:
+          return kESSEddystoneEIDFrameType;
+      }
+    }
+  }
+
+  return kESSEddystoneUnknownFrameType;
+}
+
++ (NSURL *)parseURLFromFrameData:(NSData *)URLFrameData {
+  NSAssert([ESSBeaconInfo frameTypeForFrame:URLFrameData] == kESSEddystoneURLFrameType,
+           @"This should be a URL frame, but it's not. Whooops");
+
+  if (!(URLFrameData.length > 0)) {
+    return nil;
+  }
+  
+  unsigned char urlFrame[20];
+  [URLFrameData getBytes:&urlFrame length:URLFrameData.length];
+  
+  NSString *urlScheme = [self getURLScheme:*(urlFrame+2)];
+  
+  NSString *urlString = urlScheme;
+  for (int i = 0; i < URLFrameData.length - 3; i++) {
+    urlString = [urlString stringByAppendingString:[self getEncodedString:*(urlFrame + i + 3)]];
+  }
+  
+  return [NSURL URLWithString:urlString];
+}
+
+- (instancetype)initWithBeaconID:(ESSBeaconID *)beaconID
+                         txPower:(NSNumber *)txPower
+                            RSSI:(NSNumber *)RSSI
+                       telemetry:(NSData *)telemetry {
+  if ((self = [super init]) != nil) {
+    _beaconID = beaconID;
+    _txPower = txPower;
+    _RSSI = RSSI;
+    _telemetry = [telemetry copy];
+  }
+
+  return self;
+}
+
++ (instancetype)beaconInfoForUIDFrameData:(NSData *)UIDFrameData
+                                telemetry:(NSData *)telemetry
+                                     RSSI:(NSNumber *)RSSI {
+  NSAssert([ESSBeaconInfo frameTypeForFrame:UIDFrameData] == kESSEddystoneUIDFrameType,
+           @"This should be a UID frame, but it's not. Whooops");
+
+  // Make sure this frame has the correct frame type identifier
+  uint8_t frameType;
+  [UIDFrameData getBytes:&frameType length:1];
+  if (frameType != kEddystoneUIDFrameTypeID) {
+    return nil;
+  }
+
+  ESSEddystoneUIDFrameFields uidFrame;
+
+  if ([UIDFrameData length] == sizeof(ESSEddystoneUIDFrameFields)
+      || [UIDFrameData length] == sizeof(ESSEddystoneUIDFrameFields) - sizeof(uidFrame.RFU)) {
+
+    [UIDFrameData getBytes:&uidFrame length:(sizeof(ESSEddystoneUIDFrameFields)
+                                             - sizeof(uidFrame.RFU))];
+
+    NSData *beaconIDData = [NSData dataWithBytes:&uidFrame.beaconID
+                                          length:sizeof(uidFrame.beaconID)];
+
+    ESSBeaconID *beaconID = [[ESSBeaconID alloc] initWithType:kESSBeaconTypeEddystone
+                                                     beaconID:beaconIDData];
+    if (beaconID == nil) {
+      return nil;
+    }
+
+    return [[ESSBeaconInfo alloc] initWithBeaconID:beaconID
+                                           txPower:@(uidFrame.txPower)
+                                              RSSI:RSSI
+                                         telemetry:telemetry];
+  } else {
+    return nil;
+  }
+}
+
++ (instancetype)beaconInfoForEIDFrameData:(NSData *)EIDFrameData
+                                telemetry:(NSData *)telemetry
+                                     RSSI:(NSNumber *)RSSI {
+  NSAssert([ESSBeaconInfo frameTypeForFrame:EIDFrameData] == kESSEddystoneEIDFrameType,
+           @"This should be an EID frame, but it's not. Whooops");
+
+  // Make sure this frame has the correct frame type identifier
+  uint8_t frameType;
+  [EIDFrameData getBytes:&frameType length:1];
+  if (frameType != kEddystoneEIDFrameTypeID) {
+    return nil;
+  }
+
+  ESSEddystoneEIDFrameFields eidFrame;
+
+  if ([EIDFrameData length] == sizeof(ESSEddystoneEIDFrameFields)) {
+    [EIDFrameData getBytes:&eidFrame length:sizeof(ESSEddystoneEIDFrameFields)];
+    NSData *beaconIDData = [NSData dataWithBytes:&eidFrame.beaconID
+                                          length:sizeof(eidFrame.beaconID)];
+
+    ESSBeaconID *beaconID = [[ESSBeaconID alloc] initWithType:kESSBeaconTypeEddystoneEID
+                                                     beaconID:beaconIDData];
+    if (beaconID == nil) {
+      return nil;
+    }
+
+    return [[ESSBeaconInfo alloc] initWithBeaconID:beaconID
+                                           txPower:@(eidFrame.txPower)
+                                              RSSI:RSSI
+                                         telemetry:telemetry];
+  } else {
+    return nil;
+  }
+}
+
+- (NSString *)description {
+  NSString *str = [NSString stringWithFormat:@"Eddystone, id: %@, RSSI: %@, txPower: %@",
+                                             _beaconID, _RSSI, _txPower];
+  return str;
+}
+
++ (CBUUID *)eddystoneServiceID {
+  static CBUUID *_singleton;
+  static dispatch_once_t oncePredicate;
+
+  dispatch_once(&oncePredicate, ^{
+    _singleton = [CBUUID UUIDWithString:kEddystoneServiceID];
+  });
+
+  return _singleton;
+}
+
++ (ESSBeaconInfo *)testBeaconFromBeaconIDString:(NSString *)beaconID {
+  NSData *beaconIDData = [ESSBeaconInfo hexStringToNSData:beaconID];
+  ESSBeaconID *beaconIDObj = [[ESSBeaconID alloc] initWithType:kESSBeaconTypeEddystone
+                                                      beaconID:beaconIDData];
+
+  return [[ESSBeaconInfo alloc] initWithBeaconID:beaconIDObj
+                                         txPower:@(-20)
+                                            RSSI:@(-100)
+                                       telemetry:nil];
+}
+
++ (NSData *)hexStringToNSData:(NSString *)hexString {
+  NSMutableData *data = [[NSMutableData alloc] init];
+  unsigned char whole_byte;
+  char byte_chars[3] = {'\0','\0','\0'};
+
+  int i;
+  for (i = 0; i < [hexString length]/2; i++) {
+    byte_chars[0] = [hexString characterAtIndex:i * 2];
+    byte_chars[1] = [hexString characterAtIndex:i * 2 + 1];
+    whole_byte = strtol(byte_chars, NULL, 16);
+    [data appendBytes:&whole_byte length:1];
+  }
+
+  return data;
+}
+
++ (NSString *)getURLScheme:(char)hexChar {
+  switch (hexChar) {
+    case 0x00:
+      return @"http://www.";
+    case 0x01:
+      return @"https://www.";
+    case 0x02:
+      return @"http://";
+    case 0x03:
+      return @"https://";
+    default:
+      return nil;
+  }
+}
+
++ (NSString *)getEncodedString:(char)hexChar {
+  switch (hexChar) {
+    case 0x00:
+      return @".com/";
+    case 0x01:
+      return @".org/";
+    case 0x02:
+      return @".edu/";
+    case 0x03:
+      return @".net/";
+    case 0x04:
+      return @".info/";
+    case 0x05:
+      return @".biz/";
+    case 0x06:
+      return @".gov/";
+    case 0x07:
+      return @".com";
+    case 0x08:
+      return @".org";
+    case 0x09:
+      return @".edu";
+    case 0x0a:
+      return @".net";
+    case 0x0b:
+      return @".info";
+    case 0x0c:
+      return @".biz";
+    case 0x0d:
+      return @".gov";
+    default:
+      return [NSString stringWithFormat:@"%c", hexChar];
+  }
+}
+
+@end