scan_beacon 0.3.6 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 97af646b756254104fb434abe2feba314cfd29c5
-  data.tar.gz: a59a971d4561c0ce78c6d9d8f048b4ad7633888d
+  metadata.gz: 986f14b044864f3f4e4403ae4cf4babab759035c
+  data.tar.gz: 39fe84b3c5617b4b4ba965af4fc22c7084b5e978
 SHA512:
-  metadata.gz: 4a8a190d612e264c8334f1d92d9ab893fb8dc0f6ccc73507cde1e3c6e0ca8a7e4c94d3b5f5ecfd0dc9584e747c85538285ba070fa13ce5d36e458aef1a659935
-  data.tar.gz: a3ce4f396c8476231c7508bd4d100be5db12f035f1a623d6231cd617be628e47a04e91bac2ea77d97cd5c9bec3a58c714a0a36caa0c7a5c68d43e059ad164d06
+  metadata.gz: 6d9c4da68dac5591b0719c44587258aef4ecc632138d0878185341ac20174bbb3106e113b9709f3c1cd5f24812ca15c336b719736cbf404d7ec36811d6da35f7
+  data.tar.gz: 50ff7678d58cb831273184acbde2c64b3c7301c1a869348b5003e3900ae8f596916a22cd1bec805f2bbf85c63952484f252c8389e5c3d664b3182164329e5563

data/.gitignore

@@ -3,6 +3,8 @@ yell.rb
 yeller.rb
 .DS_Store
 pkg/
-
+tmp/
+*.bundle
+*.so
 # Since this is a gem not an app, ignore the lock file
 Gemfile.lock

data/README.md

@@ -1,6 +1,6 @@
 # ScanBeacon gem
 
-A ruby gem that allows you to scan for beacon advertisements using a BlueGiga BLE112 device.
+A ruby gem that allows you to scan for beacon advertisements using CoreBluetooth (on Mac OS X) or a BlueGiga BLE112 device (on mac or linux)
 
 # Example Usage
 
@@ -9,10 +9,19 @@ A ruby gem that allows you to scan for beacon advertisements using a BlueGiga BL
 gem install scan_beacon
 ```
 
-## Start a scan
+## Create your scanner
 ``` ruby
 require 'scan_beacon'
+# to scan using CoreBluetooth on a mac
+scanner = ScanBeacon::CoreBluetoothScanner.new
+# to scan using a BLE112 device
 scanner = ScanBeacon::BLE112Scanner.new
+# to scan using BlueZ on Linux (make sure you have privileges)
+scanner = ScanBeacon::BlueZScanner.new
+```
+
+## Start a scan, yield beacons in a loop
+``` ruby
 scanner.scan do |beacons|
   beacons.each do |beacon|
     puts beacon.inspect
@@ -23,7 +32,7 @@ end
 ## Set a specific scan cycle period
 ``` ruby
 require 'scan_beacon'
-scanner = ScanBeacon::BLE112Scanner.new cycle_seconds: 2
+scanner = ScanBeacon::BLE112Scanner.new cycle_seconds: 5
 scanner.scan do |beacons|
   beacons.each do |beacon|
     puts beacon.inspect
@@ -31,6 +40,12 @@ scanner.scan do |beacons|
 end
 ```
 
+## Scan once for a set period and then return an array of beacons
+``` ruby
+scanner = ScanBeacon::CoreBluetoothScanner.new cycle_seconds: 2
+beacons = scanner.scan
+```
+
 ## Add a custom beacon layout
 By default, this gem supports AltBeacon advertisements.  But you can add a beacon parser to support other major beacon formats as well.
 
@@ -41,5 +56,37 @@ scanner.add_parser( ScanBeacon::BeaconParser.new(:mybeacon, "m:2-3=0000,i:4-19,i
 ...
 ```
 
+## Advertise as a beacon on Linux using BlueZ
+Example:
+``` ruby
+# altbeacon
+beacon = ScanBeacon::Beacon.new(
+  ids: ["2F234454CF6D4A0FADF2F4911BA9FFA6", 11,11],
+  power: -59,
+  mfg_id: 0x0118,
+  beacon_type: :altbeacon
+)
+advertiser = ScanBeacon::BlueZAdvertiser.new(beacon: beacon)
+advertiser.start
+...
+advertiser.stop
+
+# Eddystone UID
+beacon = ScanBeacon::Beacon.new(
+  ids: ["2F234454F4911BA9FFA6", 3],
+  power: -20,
+  service_uuid: 0xFEAA,
+  beacon_type: :eddystone_uid
+)
+advertiser = ScanBeacon::BlueZAdvertiser.new(beacon: beacon)
+advertiser.start
+...
+advertiser.stop
+```
+
+
 # Dependencies
-You must have a BLE112 device plugged in to a USB port.
+To scan for beacons, you must have a Linux machine with BlueZ installed, or a Mac, or a BLE112 device plugged in to a USB port (on Mac or Linux).
+
+To advertise as a beacon, you must have a Linux machine with BlueZ installed.
+

data/Rakefile

@@ -1 +1,10 @@
 require "bundler/gem_tasks"
+require "rake/extensiontask"
+
+Rake::ExtensionTask.new "core_bluetooth" do |ext|
+  ext.lib_dir = "lib/scan_beacon"
+end
+
+Rake::ExtensionTask.new "bluez" do |ext|
+  ext.lib_dir = "lib/scan_beacon"
+end

data/ext/bluez/advertising.c

@@ -0,0 +1,125 @@
+#ifdef linux
+#include "ruby.h"
+#include <stdio.h>
+#include <errno.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <bluetooth/bluetooth.h>
+#include <bluetooth/hci.h>
+#include <bluetooth/hci_lib.h>
+#pragma pack(1)
+
+
+#define FLAGS_NOT_CONNECTABLE 0x1A
+#define FLAGS_CONNECTABLE     0x18
+
+typedef struct {
+  uint8_t len;
+  struct {
+    uint8_t len;
+    uint8_t type;
+    uint8_t data;
+  } flags;
+  uint8_t ad_data[28];
+} Advertisement;
+
+Advertisement advertisement;
+int advertising;
+
+VALUE method_start_advertising();
+
+void init_advertisement()
+{
+  memset(&advertisement, 0, sizeof(advertisement));
+  advertisement.flags.len = 2;
+  advertisement.flags.type = 1;
+  advertisement.flags.data = FLAGS_NOT_CONNECTABLE;
+  advertising = 0;
+}
+
+VALUE method_set_connectable(VALUE self, VALUE connectable)
+{
+  if ( RTEST(connectable) )
+  {
+    advertisement.flags.data = FLAGS_CONNECTABLE;
+  } else {
+    advertisement.flags.data = FLAGS_NOT_CONNECTABLE;
+  };
+  if (advertising) {
+    method_start_advertising();
+  }
+  return connectable;
+}
+
+VALUE method_set_advertisement_bytes(VALUE self, VALUE bytes)
+{
+  uint8_t len = RSTRING_LEN(bytes);
+  if (len > 28) {
+    len = 28;
+  }
+  advertisement.len = len + advertisement.flags.len + 1; // + 1 is to account for the flags length field
+  memcpy(advertisement.ad_data, RSTRING_PTR(bytes), len);
+  if (advertising) {
+    method_start_advertising();
+  }
+  return bytes;
+}
+
+VALUE method_start_advertising()
+{
+  struct hci_request rq;
+  le_set_advertising_parameters_cp adv_params_cp;
+  uint8_t status;
+  
+  // open connection to the device
+  int device_id = hci_get_route(NULL);
+  int device_handle = hci_open_dev(device_id);
+
+  // set advertising data
+  memset(&rq, 0, sizeof(rq));
+  rq.ogf = OGF_LE_CTL;
+  rq.ocf = OCF_LE_SET_ADVERTISING_DATA;
+  rq.cparam = &advertisement;
+  rq.clen = sizeof(advertisement);
+  rq.rparam = &status;
+  rq.rlen = 1;
+  hci_send_req(device_handle, &rq, 1000);
+
+  // set advertising params
+  memset(&adv_params_cp, 0, sizeof(adv_params_cp));
+  uint16_t interval_100ms = htobs(0x00A0); // 0xA0 * 0.625ms = 100ms
+  adv_params_cp.min_interval = interval_100ms;
+  adv_params_cp.max_interval = interval_100ms;
+  adv_params_cp.advtype = 0x03; // non-connectable undirected advertising
+  adv_params_cp.chan_map = 0x07;// all 3 channels
+  memset(&rq, 0, sizeof(rq));
+  rq.ogf = OGF_LE_CTL;
+  rq.ocf = OCF_LE_SET_ADVERTISING_PARAMETERS;
+  rq.cparam = &adv_params_cp;
+  rq.clen = LE_SET_ADVERTISING_PARAMETERS_CP_SIZE;
+  rq.rparam = &status;
+  rq.rlen = 1;
+  hci_send_req(device_handle, &rq, 1000);
+
+  // turn on advertising
+  hci_le_set_advertise_enable(device_handle, 0x01, 1000);
+
+  // and close the connection
+  hci_close_dev(device_handle);
+  advertising = 1;
+  return Qnil;
+}
+
+VALUE method_stop_advertising()
+{
+  int device_id = hci_get_route(NULL);
+  int device_handle = hci_open_dev(device_id);
+  hci_le_set_advertise_enable(device_handle, 0x00, 1000);
+  hci_close_dev(device_handle);
+  advertising = 0;
+  return Qnil;
+}
+
+
+#endif // linux

data/ext/bluez/bluez.c

@@ -0,0 +1,43 @@
+#ifdef linux
+#include "ruby.h"
+#include <stdio.h>
+#include <errno.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <bluetooth/bluetooth.h>
+#include <bluetooth/hci.h>
+#include <bluetooth/hci_lib.h>
+
+VALUE bluez_module = Qnil;
+
+void Init_bluez();
+VALUE method_device_up(VALUE self, VALUE device_id);
+VALUE method_device_down(VALUE self, VALUE device_id);
+VALUE method_set_connectable(VALUE self, VALUE connectable);
+VALUE method_set_advertisement_bytes(VALUE self, VALUE bytes);
+VALUE method_start_advertising();
+VALUE method_stop_advertising();
+VALUE method_scan(int argc, VALUE *argv, VALUE klass);
+VALUE method_devices();
+void init_advertisement();
+
+void Init_bluez()
+{
+  VALUE scan_beacon_module = rb_const_get(rb_cObject, rb_intern("ScanBeacon"));
+  bluez_module = rb_define_module_under(scan_beacon_module, "BlueZ");
+  rb_define_singleton_method(bluez_module, "device_up", method_device_up, 1);
+  rb_define_singleton_method(bluez_module, "device_down", method_device_down, 1);
+  rb_define_singleton_method(bluez_module, "start_advertising", method_start_advertising, 0);
+  rb_define_singleton_method(bluez_module, "stop_advertising", method_stop_advertising, 0);
+  rb_define_singleton_method(bluez_module, "advertisement_bytes=", method_set_advertisement_bytes, 1);
+  rb_define_singleton_method(bluez_module, "connectable=", method_set_connectable, 1);
+  rb_define_singleton_method(bluez_module, "scan", method_scan, -1);
+  rb_define_singleton_method(bluez_module, "devices", method_devices, 0);
+
+  // initialize the advertisement
+  init_advertisement();
+}
+
+
+#endif // linux

data/ext/bluez/devices.c

@@ -0,0 +1,101 @@
+#ifdef linux
+#include "ruby.h"
+#include <stdio.h>
+#include <errno.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <bluetooth/bluetooth.h>
+#include <bluetooth/hci.h>
+#include <bluetooth/hci_lib.h>
+
+#include "utils.h"
+
+VALUE method_device_up(VALUE self, VALUE device_id)
+{
+  VALUE success;
+  int ctl = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
+  int hdev = NUM2INT(device_id);
+  /* Start HCI device */
+  if (ioctl(ctl, HCIDEVUP, hdev) < 0) {
+    if (errno == EALREADY) {
+      success = Qtrue;
+    } else {
+      rb_sys_fail("Can't init device");
+      success = Qfalse;
+    }
+  } else {
+    success = Qtrue;
+  }
+  close(ctl);
+  return success;
+}
+
+VALUE method_device_down(VALUE self, VALUE device_id)
+{
+  VALUE success;
+  int ctl = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
+  int hdev = NUM2INT(device_id);
+  /* Stop HCI device */
+  if (ioctl(ctl, HCIDEVDOWN, hdev) < 0) {
+    rb_sys_fail("Can't init device");
+    success = Qfalse;
+  } else {
+    success = Qtrue;
+  }
+  close(ctl);
+  return success;
+}
+
+VALUE di_to_hash(struct hci_dev_info *di)
+{
+  VALUE hash = rb_hash_new();
+  rb_hash_aset(hash, ID2SYM(rb_intern("device_id")), INT2FIX(di->dev_id));
+  rb_hash_aset(hash, ID2SYM(rb_intern("name")), rb_str_new2(di->name));
+  rb_hash_aset(hash, ID2SYM(rb_intern("addr")), ba2value(&di->bdaddr));
+  if (hci_test_bit(HCI_UP, &di->flags)) {
+    rb_hash_aset(hash, ID2SYM(rb_intern("up")), Qtrue);
+  } else {
+    rb_hash_aset(hash, ID2SYM(rb_intern("up")), Qfalse);
+  }
+  return hash;
+}
+
+VALUE method_devices()
+{
+  struct hci_dev_list_req *dl;
+  struct hci_dev_req *dr;
+  struct hci_dev_info di;
+  int i;
+
+  if (!(dl = malloc(HCI_MAX_DEV * sizeof(struct hci_dev_req) + sizeof(uint16_t)))) {
+    rb_raise(rb_eException, "Can't allocate memory");    
+    return Qnil;
+  }
+  dl->dev_num = HCI_MAX_DEV;
+  dr = dl->dev_req;
+
+  int ctl = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
+  if (ioctl(ctl, HCIGETDEVLIST, (void *) dl) < 0) {
+    rb_raise(rb_eException, "Can't get device list");    
+    return Qnil;
+  }
+
+  VALUE devices = rb_ary_new();
+
+  for (i = 0; i< dl->dev_num; i++) {
+    di.dev_id = (dr+i)->dev_id;
+    if (ioctl(ctl, HCIGETDEVINFO, (void *) &di) < 0)
+      continue;
+    if (hci_test_bit(HCI_RAW, &di.flags) &&
+        !bacmp(&di.bdaddr, BDADDR_ANY)) {
+      int dd = hci_open_dev(di.dev_id);
+      hci_read_bd_addr(dd, &di.bdaddr, 1000);
+      hci_close_dev(dd);
+    }
+    rb_ary_push(devices, di_to_hash(&di));
+  }
+  return devices;
+}
+
+#endif // linux

data/ext/bluez/extconf.rb

@@ -0,0 +1,14 @@
+# Loads mkmf which is used to make makefiles for Ruby extensions
+require 'mkmf'
+
+# Give it a name
+extension_name = 'scan_beacon/bluez'
+
+# The destination
+dir_config(extension_name)
+
+if RUBY_PLATFORM =~ /linux/
+  abort 'could not find bluetooth library (libbluetooth-dev)' unless have_library("bluetooth")
+end
+
+create_makefile(extension_name)

data/ext/bluez/scanning.c

@@ -0,0 +1,144 @@
+#ifdef linux
+#include "ruby.h"
+#include <stdio.h>
+#include <errno.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <time.h>
+#include <bluetooth/bluetooth.h>
+#include <bluetooth/hci.h>
+#include <bluetooth/hci_lib.h>
+
+#include "utils.h"
+
+VALUE method_scan();
+
+
+VALUE stop_scan(VALUE device_id);
+VALUE perform_scan(VALUE device_id);
+
+struct hci_filter stored_filters[10];
+int device_handles[10];
+
+VALUE method_scan(int argc, VALUE *argv, VALUE klass)
+{
+  VALUE rb_device_id;
+  int device_id;
+  int device_handle;
+  uint8_t scan_type = 0x01; //passive
+  uint8_t own_type = 0x00; // I think this specifies not to use a random MAC
+  uint8_t filter_dups = 0x00;
+  uint8_t filter_policy = 0x00; // ?
+  uint16_t interval = htobs(0x0005);
+  uint16_t window = htobs(0x0005);
+
+  struct hci_filter new_filter;
+
+  // which device was specified?
+  rb_scan_args(argc, argv, "01", &rb_device_id);
+  if (rb_device_id == Qnil) {
+    device_id = hci_get_route(NULL);
+  } else {
+    device_id = NUM2INT(rb_device_id);
+  }
+  // open the device
+  if ( (device_handle = hci_open_dev(device_id)) < 0) {
+    rb_raise(rb_eException, "Could not open device");
+  }
+  device_handles[device_id] = device_handle;
+ 
+  // save the old filter so we can restore it later
+  socklen_t filter_size = sizeof(stored_filters[0]);
+  if (getsockopt(device_handle, SOL_HCI, HCI_FILTER, &stored_filters[device_id], &filter_size) < 0) {
+    rb_raise(rb_eException, "Could not get socket options");
+  }
+
+  // new filter to only look for event packets
+  hci_filter_clear(&new_filter);
+  hci_filter_set_ptype(HCI_EVENT_PKT, &new_filter);
+  hci_filter_set_event(EVT_LE_META_EVENT, &new_filter);
+  if (setsockopt(device_handle, SOL_HCI, HCI_FILTER, &new_filter, sizeof(new_filter)) < 0) {
+    rb_raise(rb_eException, "Could not set socket options");
+  }
+
+  // set the params
+  hci_le_set_scan_parameters(device_handle, scan_type, interval, window, own_type, filter_policy, 1000);
+  hci_le_set_scan_enable(device_handle, 0x01, filter_dups, 1000);
+
+  // perform the scan and make sure device gets put back into a proper state
+  // even in the case of being interrupted by a ruby exception
+  rb_ensure(perform_scan, INT2FIX(device_id), stop_scan, INT2FIX(device_id));
+  return Qnil;
+}
+
+VALUE perform_scan(VALUE device_id_in)
+{
+  int device_id = FIX2INT(device_id_in);
+  int device_handle = device_handles[device_id];
+  unsigned char buf[HCI_MAX_EVENT_SIZE], *ptr;
+  int len;
+  int keep_scanning = 1;
+  while (keep_scanning) {
+    evt_le_meta_event *meta;
+    le_advertising_info *info;
+
+    // wait for data with a timeout
+    fd_set set;
+    FD_ZERO(&set);
+    FD_SET(device_handle, &set);
+    struct timeval timeout;
+    timeout.tv_sec = 0;
+    timeout.tv_usec = 200000; // 200ms
+    int ret = select(device_handle + 1, &set, NULL, NULL, &timeout);
+    if (ret < 0) {
+      rb_raise(rb_eException, "Error waiting for data");
+    } else if (ret == 0) {
+      // timeout.  yield nil to give ruby a chance to stop the scan.
+      keep_scanning = rb_yield(Qnil) != Qfalse;
+      continue;
+    }
+
+    // keep trying to read until we get something
+    while ((len = read(device_handle, buf, sizeof(buf))) < 0) {
+      if (errno == EAGAIN || errno == EINTR) {
+        continue;
+      }
+      keep_scanning = 0;
+      break;
+    }
+
+    if (len > 0) {
+      ptr = buf + (1 + HCI_EVENT_HDR_SIZE);
+      len -= (1 + HCI_EVENT_HDR_SIZE);
+      meta = (void *) ptr;
+      // check if this event is an advertisement
+      if (meta->subevent != EVT_LE_ADVERTISING_REPORT) {
+        continue;
+      }
+      // parse out the ad data, the mac, and the rssi
+      info = (le_advertising_info *) (meta->data + 1);
+      VALUE rssi = INT2FIX( (int8_t)info->data[info->length] );
+      VALUE ad_data = rb_str_new((void *)info->data, info->length);
+      VALUE addr = ba2value(&info->bdaddr);
+      keep_scanning = rb_yield_values(3, addr, ad_data, rssi) != Qfalse;
+    }
+  }
+  return Qnil;
+}
+
+VALUE stop_scan(VALUE device_id_in)
+{
+  int device_id = FIX2INT(device_id_in);
+  int device_handle = device_handles[device_id];
+
+  // put back the old filter
+  setsockopt(device_handle, SOL_HCI, HCI_FILTER, &stored_filters[device_id], sizeof(stored_filters[0]));
+
+  // stop scanning
+  hci_le_set_scan_enable(device_handle, 0x00, 0x00, 1000);
+  hci_close_dev(device_handle);
+  return Qnil;
+}
+
+#endif // linux

data/ext/bluez/utils.c

@@ -0,0 +1,21 @@
+#ifdef linux
+#include "ruby.h"
+#include <stdio.h>
+#include <errno.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <bluetooth/bluetooth.h>
+#include <bluetooth/hci.h>
+#include <bluetooth/hci_lib.h>
+
+#include "utils.h"
+
+VALUE ba2value(bdaddr_t *bdaddr)
+{
+  char addr[18];
+  ba2str(bdaddr, addr);
+  return rb_str_new2(addr);
+}
+
+#endif // linux

data/ext/bluez/utils.h

@@ -0,0 +1,2 @@
+
+VALUE ba2value(bdaddr_t *bdaddr);

data/ext/core_bluetooth/core_bluetooth.m

@@ -0,0 +1,150 @@
+#ifdef __APPLE__
+
+// Include the Ruby headers and goodies
+#include "ruby.h"
+#import <Foundation/Foundation.h>
+#import <CoreBluetooth/CoreBluetooth.h>
+
+// Defining a space for information and references about the module to be stored internally
+VALUE cb_module = Qnil;
+
+// Prototype for the initialization method - Ruby calls this, not you
+void Init_core_bluetooth();
+VALUE method_scan();
+VALUE method_new_adverts();
+VALUE new_scan_hash(NSString* device, NSData *data, NSNumber *rssi, NSData *service_uuid);
+
+@interface BLEDelegate : NSObject <CBCentralManagerDelegate>
+- (NSArray *)scans;
+@end
+
+@implementation BLEDelegate {
+  NSMutableArray *_scans;
+}
+
+- (id)init
+{
+  self = [super init];
+  _scans = [[NSMutableArray alloc] init];
+  return self;
+}
+
+- (void)centralManager:(CBCentralManager *)central didDiscoverPeripheral:(CBPeripheral *)peripheral
+     advertisementData:(NSDictionary *)advertisementData RSSI:(NSNumber *)RSSI
+{
+  NSData *mfgData =  advertisementData[@"kCBAdvDataManufacturerData"];
+  NSDictionary *serviceData =  advertisementData[@"kCBAdvDataServiceData"];
+  if (mfgData) {
+    NSDictionary *scan = @{@"device": peripheral.identifier.UUIDString,
+                             @"data": mfgData,
+                             @"rssi": RSSI
+    };
+    @synchronized(_scans) {
+      [_scans addObject: scan];
+    }
+  } else if (serviceData) {
+    NSData *svcData = [serviceData allValues][0];
+    CBUUID *uuid = serviceData.allKeys[0];
+    NSDictionary *scan = @{@"device": peripheral.identifier.UUIDString,
+                             @"data": svcData,
+                             @"rssi": RSSI,
+                              @"service_uuid": uuid.data
+    };
+    @synchronized(_scans) {
+      [_scans addObject: scan];
+    }
+  }
+}
+
+- (void)centralManagerDidUpdateState:(CBCentralManager *)central
+{
+  [central scanForPeripheralsWithServices:nil options:@{CBCentralManagerScanOptionAllowDuplicatesKey : @(YES)}];
+}
+
+- (NSArray *) scans
+{
+  NSArray *scanCopy;
+  @synchronized(_scans) {
+    scanCopy = _scans;
+    _scans = [[NSMutableArray alloc] init];
+  }
+  return scanCopy;
+}
+
+@end
+
+VALUE sym_device = Qnil;
+VALUE sym_data = Qnil;
+VALUE sym_rssi = Qnil;
+VALUE sym_service_uuid = Qnil;
+BLEDelegate *bleDelegate;
+CBCentralManager *centralManager;
+
+// initialize our module here
+void Init_core_bluetooth()
+{
+  VALUE scan_beacon_module = rb_const_get(rb_cObject, rb_intern("ScanBeacon"));
+  cb_module = rb_define_module_under(scan_beacon_module, "CoreBluetooth");
+  rb_define_singleton_method(cb_module, "scan", method_scan, 0);
+  rb_define_singleton_method(cb_module, "new_adverts", method_new_adverts, 0);
+
+  sym_device = ID2SYM(rb_intern("device"));
+  sym_data = ID2SYM(rb_intern("data"));
+  sym_rssi = ID2SYM(rb_intern("rssi"));
+  sym_service_uuid = ID2SYM(rb_intern("service_uuid"));
+}
+
+// create a ruby hash to yield back to ruby,
+// of the form {device: "xxxx", data: "yyyy", rssi: -99}
+VALUE new_scan_hash(NSString* device, NSData *data, NSNumber *rssi, NSData *service_uuid)
+{
+  VALUE hash = rb_hash_new();
+  rb_hash_aset(hash, sym_device, rb_str_new_cstr(device.UTF8String));
+  rb_hash_aset(hash, sym_data, rb_str_new(data.bytes, data.length));
+  rb_hash_aset(hash, sym_rssi, INT2FIX( rssi.integerValue ));
+  if (service_uuid) {
+    uint16_t uuid = *((uint16_t *)service_uuid.bytes);
+    uuid = NSSwapShort(uuid);
+    rb_hash_aset(hash, sym_service_uuid, rb_str_new( (void*)&uuid, 2));
+  }
+  return hash;
+}
+
+VALUE method_new_adverts()
+{
+  @autoreleasepool {
+    VALUE ary = rb_ary_new();
+    NSArray *scans = bleDelegate.scans;
+    for (NSDictionary *scan in scans) {
+      VALUE hash = new_scan_hash( scan[@"device"], scan[@"data"], scan[@"rssi"], scan[@"service_uuid"] );
+      rb_ary_push(ary, hash);
+    }
+    [scans release];
+    return ary;
+  }
+}
+
+VALUE method_scan()
+{
+  VALUE scans = rb_ary_new();
+
+  @autoreleasepool {
+    @try {
+      bleDelegate = [[BLEDelegate alloc] init];
+      dispatch_queue_t scanQueue;
+      scanQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
+      centralManager = [[CBCentralManager alloc] initWithDelegate:bleDelegate queue:scanQueue];
+      BOOL exit = NO;
+      while (!exit) {
+        VALUE ret = rb_yield( Qnil );
+        exit = (ret == Qfalse);
+      }
+    }
+    @finally {
+      [centralManager stopScan];
+    }
+  }
+  return Qnil;
+}
+
+#endif // TARGET_OS_MAC

data/ext/core_bluetooth/extconf.rb

@@ -0,0 +1,23 @@
+# Loads mkmf which is used to make makefiles for Ruby extensions
+require 'mkmf'
+
+# Give it a name
+extension_name = 'scan_beacon/core_bluetooth'
+
+# The destination
+dir_config(extension_name)
+
+$DLDFLAGS << " -framework Foundation"
+$DLDFLAGS << " -framework CoreBluetooth"
+
+unless RUBY_PLATFORM =~ /darwin/
+  # don't compile the code on non-mac platforms because
+  # CoreBluetooth wont be there, and we may not even have
+  # the ability to compile ObjC code.
+  COMPILE_C = "echo"
+  # create a dummy .so file so RubyGems thinks everything
+  # was successful.  We wont try to load it anyway.
+  LINK_SO = "touch $@"
+end
+
+create_makefile(extension_name)

data/lib/scan_beacon/beacon.rb

@@ -3,11 +3,14 @@ require 'set'
 module ScanBeacon
   class Beacon
 
-    attr_accessor :mac, :ids, :power, :beacon_types
+    attr_accessor :mac, :ids, :power, :beacon_types, :data, :mfg_id, :service_uuid
 
     def initialize(opts={})
-      @ids = opts[:ids]
+      @ids = opts[:ids] || []
+      @data = opts[:data] || []
       @power = opts[:power]
+      @mfg_id = opts[:mfg_id]
+      @service_uuid = opts[:service_uuid]
       @beacon_types = Set.new [opts[:beacon_type]]
       @rssis = []
     end

data/lib/scan_beacon/beacon_parser.rb

@@ -1,12 +1,27 @@
 module ScanBeacon
   class BeaconParser
-
+    DEFAULT_LAYOUTS = {
+      altbeacon: "m:2-3=beac,i:4-19,i:20-21,i:22-23,p:24-24,d:25-25",
+      eddystone_uid: "s:0-1=aafe,m:2-2=00,p:3-3:-41,i:4-13,i:14-19;d:20-21"
+    }
+    AD_TYPE_MFG = 0xff
+    AD_TYPE_SERVICE = 0x03
+    BT_EIR_SERVICE_DATA = "\x16"
     attr_accessor :beacon_type
 
+    def self.default_parsers
+      DEFAULT_LAYOUTS.map {|name, layout| BeaconParser.new name, layout }
+    end
+
     def initialize(beacon_type, layout)
       @beacon_type = beacon_type
       @layout = layout.split(",")
-      @matchers = @layout.find_all {|item| item[0] == "m"}.map {|matcher|
+      if layout.include?("s")
+        @ad_type = AD_TYPE_SERVICE
+      else
+        @ad_type = AD_TYPE_MFG
+      end
+      @matchers = @layout.find_all {|item| ["m", "s"].include? item[0]}.map {|matcher|
         _, range_start, range_end, expected = matcher.split(/:|=|-/)
         {start: range_start.to_i, end: range_end.to_i, expected: expected}
       }
@@ -14,6 +29,10 @@ module ScanBeacon
         _, range_start, range_end = id.split(/:|-/)
         {start: range_start.to_i, end: range_end.to_i}
       }
+      @data_fields = @layout.find_all {|item| item[0] == "d"}.map {|field|
+        _, range_start, range_end = field.split(/:|-/)
+        {start: range_start.to_i, end: range_end.to_i}
+      }
       _, power_start, power_end = @layout.find {|item| item[0] == "p"}.split(/:|-/)
       @power = {start: power_start.to_i, end: power_end.to_i}
     end
@@ -25,27 +44,88 @@ module ScanBeacon
       return true
     end
 
-    def parse(data)
-      return nil if !matches?(data)
-      Beacon.new(ids: parse_ids(data), power: parse_power(data), beacon_type: @beacon_type)
+    def parse(data, ad_type = AD_TYPE_MFG)
+      return nil if ad_type != @ad_type || !matches?(data)
+      if @ad_type == AD_TYPE_MFG
+        Beacon.new(ids: parse_ids(data), power: parse_power(data), beacon_type: @beacon_type,
+          data: parse_data_fields(data), mfg_id: parse_mfg_or_service_id(data))
+      else
+        Beacon.new(ids: parse_ids(data), power: parse_power(data), beacon_type: @beacon_type,
+          data: parse_data_fields(data), service_uuid: parse_mfg_or_service_id(data))
+      end
     end
 
     def parse_ids(data)
-      @ids.map {|id|
-        if id[:end] - id[:start] == 1
+      parse_elems(@ids, data)
+    end
+
+    def parse_data_fields(data)
+      parse_elems(@data_fields, data)
+    end
+
+    def parse_elems(elems, data)
+      elems.map {|elem|
+        elem_str = data[elem[:start]..elem[:end]]
+        elem_length = elem_str.size
+        case elem_length
+        when 1
+          elem_str.unpack('C')[0]
+        when 2 
           # two bytes, so treat it as a short (big endian)
-          data[id[:start]..id[:end]].unpack('S>')[0]
+          elem_str.unpack('S>')[0]
+        when 6
+          # 6 bytes, treat it is an eddystone instance id
+          ("\x00\x00"+elem_str).unpack('Q>')[0]
         else
           # not two bytes, so treat it as a hex string
-          data[id[:start]..id[:end]].unpack('H*').join
+          elem_str.unpack('H*').join
         end
       }
     end
 
+    def parse_mfg_or_service_id(data)
+      data[0..1].unpack('S>')[0]
+    end
+
     def parse_power(data)
       data[@power[:start]..@power[:end]].unpack('c')[0]
     end
 
+    def generate_ad(beacon)
+      length = [@matchers, @ids, @power, @data_fields].flatten.map {|elem| elem[:end] }.max + 1
+      ad = "\x00" * length
+      @matchers.each do |matcher|
+        ad[matcher[:start]..matcher[:end]] = [matcher[:expected]].pack("H*")
+      end
+      @ids.each_with_index do |id, index|
+        ad[id[:start]..id[:end]] = generate_field(id, beacon.ids[index])
+      end
+      @data_fields.each_with_index do |field, index|
+        ad[field[:start]..field[:end]] = generate_field(field, beacon.data[index]) unless beacon.data[index].nil?
+      end
+      ad[@power[:start]..@power[:end]] = [beacon.power].pack('c')
+      if @ad_type == AD_TYPE_SERVICE
+        "\x03\x03" + [beacon.service_uuid].pack("S<") + [length+1].pack('C') + BT_EIR_SERVICE_DATA + ad
+      elsif @ad_type == AD_TYPE_MFG
+        ad[0..1] = [beacon.mfg_id].pack("S<")
+        [length+1].pack('C') + [AD_TYPE_MFG].pack('C') +  ad
+      end
+    end
+
+    def generate_field(field, value)
+      field_length = field[:end] - field[:start] + 1
+      case field_length
+      when 1
+        [value].pack("c")
+      when 2
+        [value].pack("S>")
+      when 6
+        [value].pack("Q>")[2..-1]
+      else
+        [value].pack("H*")[0..field_length-1]
+      end
+    end 
+
     def inspect
       "<BeaconParser type=\"#{@beacon_type}\", layout=\"#{@layout.join(",")}\">"
     end

data/lib/scan_beacon/ble112_scanner.rb

@@ -1,62 +1,26 @@
-require 'timeout'
-
 module ScanBeacon
-  class BLE112Scanner
-
-    DEFAULT_LAYOUTS = {altbeacon: "m:2-3=beac,i:4-19,i:20-21,i:22-23,p:24-24,d:25-25"}
-
-    attr_reader :beacons
+  class BLE112Scanner < GenericScanner
 
     def initialize(opts = {})
+      super
       @device = BLE112Device.new opts[:port]
-      @cycle_seconds = opts[:cycle_seconds] || 1
-      @parsers = DEFAULT_LAYOUTS.map {|name, layout| BeaconParser.new name, layout }
-      @beacons = []
     end
 
-    def add_parser(parser)
-      @parsers << parser
-    end
-
-    def scan
+    def each_advertisement
       @device.open do |device|
         device.start_scan
-        cycle_end = Time.now + @cycle_seconds
-
         begin
-          while true do
-            check_for_beacon( device.read )
-            if Time.now > cycle_end
-              yield @beacons
-              @beacons = []
-              cycle_end = Time.now + @cycle_seconds
+          keep_scanning = true
+          while keep_scanning do
+            response = device.read
+            if response.advertisement?
+              keep_scanning = false if yield(response.advertisement_data, response.mac, response.rssi) == false
             end
           end
         ensure
           device.stop_scan
         end
-
-      end
-    end
-
-    def check_for_beacon(response)
-      if response.advertisement?
-        beacon = nil
-        if @parsers.detect {|parser| beacon = parser.parse(response.advertisement_data) }
-          beacon.mac = response.mac
-          add_beacon(beacon, response.rssi)
-        end
-      end
-    end
-
-    def add_beacon(beacon, rssi)
-      if idx = @beacons.find_index(beacon)
-        @beacons[idx].add_type beacon.beacon_types.first
-        beacon = @beacons[idx]
-      else
-        @beacons << beacon
       end
-      beacon.add_rssi(rssi)
     end
 
   end

data/lib/scan_beacon/bluez_advertiser.rb

@@ -0,0 +1,45 @@
+module ScanBeacon
+  class BlueZAdvertiser
+ 
+    attr_accessor :beacon, :parser, :ad
+
+    def initialize(opts = {})
+      @device_id = opts[:device_id]
+      self.beacon = opts[:beacon]
+      self.parser = opts[:parser]
+      self.parser ||= BeaconParser.default_parsers.find {|parser| parser.beacon_type == beacon.beacon_types.first}
+    end
+
+    def beacon=(value)
+      @beacon = value
+      update_ad
+    end
+
+    def parser=(value)
+      @parser = value
+      update_ad
+    end
+
+    def ad=(value)
+      @ad = value
+      BlueZ.advertisement_bytes = @ad
+    end
+
+    def start
+      BlueZ.start_advertising
+    end
+
+    def stop
+      BlueZ.stop_advertising
+    end
+
+    def inspect
+      "<BlueZAdvertiser ad=#{@ad.inspect}>"
+    end
+
+    def update_ad
+      self.ad = @parser.generate_ad(@beacon) if @parser && @beacon
+    end
+
+  end
+end

data/lib/scan_beacon/bluez_scanner.rb

@@ -0,0 +1,26 @@
+module ScanBeacon
+  class BlueZScanner < GenericScanner
+
+    def initialize(opts = {})
+      super
+      @device_id = opts[:device_id] || BlueZ.devices[0][:device_id]
+      BlueZ.device_up @device_id
+    end
+
+    def each_advertisement
+      ScanBeacon::BlueZ.scan(@device_id) do |mac, ad_data, rssi|
+        if ad_data.nil?
+          yield(nil)
+        elsif ad_data.size > 4
+          ad_type = ad_data[4].unpack("C")[0]
+          if ad_type == 0xff
+            yield(ad_data[5..-1], mac, rssi, ad_type)
+          else
+            yield(ad_data[9..-1], mac, rssi, ad_type)
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/scan_beacon/core_bluetooth_scanner.rb

@@ -0,0 +1,25 @@
+module ScanBeacon
+  class CoreBluetoothScanner < GenericScanner
+
+    def each_advertisement
+      keep_scanning = true
+      CoreBluetooth::scan do
+        sleep 0.2
+        advertisements = CoreBluetooth::new_adverts
+        advertisements.each do |scan|
+          if scan[:service_uuid]
+            advert = scan[:service_uuid] + scan[:data]
+            keep_scanning = false if yield(advert, scan[:device], scan[:rssi], 0x03) == false
+          else
+            keep_scanning = false if yield(scan[:data], scan[:device], scan[:rssi], 0xff) == false
+          end
+        end
+        if advertisements.empty?
+          keep_scanning = false if yield(nil, nil, nil) == false
+        end
+        keep_scanning
+      end
+    end
+
+  end
+end

data/lib/scan_beacon/generic_scanner.rb

@@ -0,0 +1,59 @@
+module ScanBeacon
+  class GenericScanner
+
+    attr_reader :beacons
+
+    def initialize(opts = {})
+      @cycle_seconds = opts[:cycle_seconds] || 1
+      @parsers = BeaconParser.default_parsers
+      @beacons = []
+    end
+
+    def add_parser(parser)
+      @parsers << parser
+    end
+
+    def scan
+      @beacons = []
+      next_cycle = Time.now + @cycle_seconds
+      keep_scanning = true
+      each_advertisement do |data, device, rssi, ad_type = BeaconParser::AD_TYPE_MFG|
+        detect_beacon(data, device, rssi, ad_type) unless data.nil?
+
+        if Time.now > next_cycle
+          if block_given?
+            next_cycle = Time.now + @cycle_seconds
+            yield @beacons
+            @beacons = []
+          else
+            keep_scanning = false
+          end
+        end
+      end
+      return @beacons unless block_given?
+    end
+
+    def each_advertisement
+      raise NotImplementedError
+    end
+
+    def detect_beacon(data, device, rssi, ad_type)
+      beacon = nil
+      if @parsers.detect {|parser| beacon = parser.parse(data, ad_type) }
+        beacon.mac = device
+        add_beacon(beacon, rssi)
+      end
+    end
+
+    def add_beacon(beacon, rssi)
+      if idx = @beacons.find_index(beacon)
+        @beacons[idx].add_type beacon.beacon_types.first
+        beacon = @beacons[idx]
+      else
+        @beacons << beacon
+      end
+      beacon.add_rssi(rssi)
+    end
+
+  end
+end

data/lib/scan_beacon/version.rb

@@ -1,3 +1,3 @@
 module ScanBeacon
-  VERSION = "0.3.6"
+  VERSION = "0.5.0"
 end

data/lib/scan_beacon.rb

@@ -1,8 +1,18 @@
 require "scan_beacon/version"
 require "scan_beacon/beacon"
 require "scan_beacon/beacon_parser"
+require "scan_beacon/generic_scanner"
 require "scan_beacon/ble112_device"
 require "scan_beacon/ble112_scanner"
+case RUBY_PLATFORM
+when /darwin/
+  require "scan_beacon/core_bluetooth"
+  require "scan_beacon/core_bluetooth_scanner"
+when /linux/
+  require "scan_beacon/bluez"
+  require "scan_beacon/bluez_scanner"
+  require "scan_beacon/bluez_advertiser"
+end
 
 module ScanBeacon
 end

data/scan_beacon.gemspec

@@ -16,9 +16,11 @@ Gem::Specification.new do |spec|
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.extensions    = %w[ext/core_bluetooth/extconf.rb ext/bluez/extconf.rb]
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler", "~> 1.9"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.2"
+  spec.add_development_dependency "rake-compile"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scan_beacon
 version: !ruby/object:Gem::Version
-  version: 0.3.6
+  version: 0.5.0
 platform: ruby
 authors:
 - Radius Networks
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-07-02 00:00:00.000000000 Z
+date: 2015-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,11 +52,27 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: rake-compile
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email:
 - support@radiusnetworks.com
 executables: []
-extensions: []
+extensions:
+- ext/core_bluetooth/extconf.rb
+- ext/bluez/extconf.rb
 extra_rdoc_files: []
 files:
 - ".gitignore"
@@ -64,11 +80,24 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- ext/bluez/advertising.c
+- ext/bluez/bluez.c
+- ext/bluez/devices.c
+- ext/bluez/extconf.rb
+- ext/bluez/scanning.c
+- ext/bluez/utils.c
+- ext/bluez/utils.h
+- ext/core_bluetooth/core_bluetooth.m
+- ext/core_bluetooth/extconf.rb
 - lib/scan_beacon.rb
 - lib/scan_beacon/beacon.rb
 - lib/scan_beacon/beacon_parser.rb
 - lib/scan_beacon/ble112_device.rb
 - lib/scan_beacon/ble112_scanner.rb
+- lib/scan_beacon/bluez_advertiser.rb
+- lib/scan_beacon/bluez_scanner.rb
+- lib/scan_beacon/core_bluetooth_scanner.rb
+- lib/scan_beacon/generic_scanner.rb
 - lib/scan_beacon/version.rb
 - scan_beacon.gemspec
 homepage: https://github.com/RadiusNetworks/scanbeacon-gem