bluetooth 1.0

data/ext/bluetooth/macosx/host_controller.m

@@ -0,0 +1,39 @@
+#import "ruby_bluetooth.h"
+
+@implementation HCIDelegate
+
+- (VALUE) device {
+    return device;
+}
+
+- (void) setDevice: (VALUE)input {
+    device = input;
+}
+
+
+- (void) controllerClassOfDeviceReverted: (id)sender {
+    printf("class of device reverted!\n");
+}
+
+- (void) readLinkQualityForDeviceComplete: (id)controller
+                                   device: (IOBluetoothDevice*)bt_device
+                                     info: (BluetoothHCILinkQualityInfo*)info
+                                    error: (IOReturn)error {
+    CFRunLoopStop(CFRunLoopGetCurrent());
+
+    rb_iv_set(device, "@link_quality_error", INT2NUM(error));
+    rb_iv_set(device, "@link_quality", UINT2NUM(info->qualityValue));
+}
+
+- (void) readRSSIForDeviceComplete: (id)controller
+                            device: (IOBluetoothDevice*)bt_device
+                              info: (BluetoothHCIRSSIInfo*)info
+                             error: (IOReturn)error {
+    CFRunLoopStop(CFRunLoopGetCurrent());
+
+    rb_iv_set(device, "@rssi_error", INT2NUM(error));
+    rb_iv_set(device, "@rssi", INT2NUM(info->RSSIValue));
+}
+
+@end
+

data/ext/bluetooth/macosx/ruby_bluetooth.h

@@ -0,0 +1,69 @@
+#import <Cocoa/Cocoa.h>
+
+#import <IOBluetooth/IOBluetoothUserLib.h>
+#import <IOBluetooth/objc/IOBluetoothDevice.h>
+#import <IOBluetooth/objc/IOBluetoothDeviceInquiry.h>
+#import <IOBluetooth/objc/IOBluetoothHostController.h>
+
+#import <ruby.h>
+
+void init_rbt_error();
+
+void rbt_check_status(IOReturn status, NSAutoreleasePool *pool);
+
+VALUE rbt_scan(VALUE);
+
+VALUE rbt_device_link_quality(VALUE);
+VALUE rbt_device_open_connection(VALUE);
+VALUE rbt_device_pair(VALUE);
+VALUE rbt_device_request_name(VALUE);
+VALUE rbt_device_rssi(VALUE);
+
+@interface BluetoothDeviceScanner : NSObject {
+	IOBluetoothDeviceInquiry *      _inquiry;
+	BOOL                            _busy;
+	VALUE                           _devices;
+}
+
+- (void) stopSearch;
+- (IOReturn) startSearch;
+- (VALUE) devices;
+@end
+
+@interface PairingDelegate : NSObject {
+	VALUE device;
+}
+
+- (VALUE) device;
+- (void) setDevice: (VALUE)input;
+
+- (void) devicePairingConnecting: (id)sender;
+- (void) devicePairingStarted: (id)sender;
+- (void) devicePairingFinished: (id)sender
+			 error: (IOReturn)error;
+
+- (void) devicePairingPasskeyNotification: (id)sender
+                                  passkey: (BluetoothPasskey)passkey;
+- (void) devicePairingPINCodeRequest: (id)sender;
+- (void) devicePairingUserConfirmationRequest: (id)sender
+                                 numericValue: (BluetoothNumericValue)numericValue;
+@end
+
+@interface HCIDelegate : NSObject {
+    VALUE device;
+}
+
+- (VALUE) device;
+- (void) setDevice: (VALUE)input;
+
+- (void) controllerClassOfDeviceReverted: (id)sender;
+- (void) readLinkQualityForDeviceComplete: (id)controller
+                                   device: (IOBluetoothDevice*)bt_device
+                                     info: (BluetoothHCILinkQualityInfo*)info
+                                    error: (IOReturn)error;
+- (void) readRSSIForDeviceComplete: (id)controller
+                            device: (IOBluetoothDevice*)bt_device
+                              info: (BluetoothHCIRSSIInfo*)info
+                             error: (IOReturn)error;
+@end
+

data/ext/bluetooth/macosx/ruby_bluetooth.m

@@ -0,0 +1,29 @@
+#import "ruby_bluetooth.h"
+
+VALUE rbt_mBluetooth = Qnil;
+
+VALUE rbt_cBluetoothDevice = Qnil;
+VALUE rbt_cBluetoothERRORS = Qnil;
+VALUE rbt_cBluetoothError = Qnil;
+
+void Init_bluetooth() {
+    rbt_mBluetooth = rb_define_module("Bluetooth");
+
+    rbt_cBluetoothError  = rb_const_get(rbt_mBluetooth, rb_intern("Error"));
+
+    rb_define_singleton_method(rbt_mBluetooth, "scan", rbt_scan, 0);
+
+    rbt_cBluetoothDevice = rb_const_get(rbt_mBluetooth, rb_intern("Device"));
+
+    rb_define_method(rbt_cBluetoothDevice, "connect",
+            rbt_device_open_connection, 0);
+    rb_define_method(rbt_cBluetoothDevice, "_link_quality",
+            rbt_device_link_quality, 0);
+    rb_define_method(rbt_cBluetoothDevice, "pair", rbt_device_pair, 0);
+    rb_define_method(rbt_cBluetoothDevice, "request_name",
+            rbt_device_request_name, 0);
+    rb_define_method(rbt_cBluetoothDevice, "_rssi", rbt_device_rssi, 0);
+
+    init_rbt_error();
+}
+

data/ext/bluetooth/macosx/scan.m

@@ -0,0 +1,87 @@
+#import "ruby_bluetooth.h"
+
+extern VALUE rbt_cBluetoothDevice;
+
+VALUE rbt_scan(VALUE self) {
+    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+    BluetoothDeviceScanner *bds = [BluetoothDeviceScanner new];
+
+    [bds startSearch];
+
+    CFRunLoopRun();
+
+    [pool release];
+
+    return [bds devices];
+}
+
+@implementation BluetoothDeviceScanner
+
+- (void) deviceInquiryComplete:(IOBluetoothDeviceInquiry*)sender
+                         error:(IOReturn)error aborted:(BOOL)aborted {
+    CFRunLoopStop(CFRunLoopGetCurrent());
+}
+
+- (void) deviceInquiryDeviceFound:(IOBluetoothDeviceInquiry*)sender
+                           device:(IOBluetoothDevice*)device {
+    VALUE address;
+    VALUE name = Qnil;
+    const char * device_name = [[device name] UTF8String];
+
+    address = rb_str_new2([[device getAddressString] UTF8String]);
+
+    if (device_name)
+        name = rb_str_new2(device_name);
+
+    VALUE dev = rb_funcall(rbt_cBluetoothDevice, rb_intern("new"), 2,
+                           address, name);
+
+    rb_ary_push(_devices, dev);
+}
+
+- (void) deviceInquiryDeviceNameUpdated:(IOBluetoothDeviceInquiry*)sender
+                                 device:(IOBluetoothDevice*)device
+                       devicesRemaining:(uint32_t)devicesRemaining {
+    // do something
+}
+
+- (void) deviceInquiryUpdatingDeviceNamesStarted:(IOBluetoothDeviceInquiry*)sender
+                                devicesRemaining:(uint32_t)devicesRemaining {
+    // do something
+}
+
+- (IOReturn) startSearch {
+    IOReturn status;
+
+    [self stopSearch];
+
+    _inquiry = [IOBluetoothDeviceInquiry inquiryWithDelegate:self];
+    _devices = rb_ary_new();
+
+    [_inquiry setUpdateNewDeviceNames: TRUE];
+
+    status = [_inquiry start];
+
+    if (status == kIOReturnSuccess) {
+        [_inquiry retain];
+
+        _busy = TRUE;
+    }
+
+    return status;
+}
+
+- (void) stopSearch {
+    if (_inquiry) {
+        [_inquiry stop];
+
+        [_inquiry release];
+        _inquiry = nil;
+    }
+}
+
+- (VALUE) devices {
+    return _devices;
+}
+@end
+

data/ext/bluetooth/win32/ruby_bluetooth.cpp

@@ -0,0 +1,112 @@
+// Include the Ruby headers and goodies
+#include <ruby.h>
+#include <rubyio.h>
+#include <rubysig.h>
+#include <util.h>
+//#include <unistd.h>
+//#include <winsock2.h>
+#include <Ws2bth.h>
+#include <BluetoothAPIs.h>
+
+#include <stdio.h>
+
+#include "ruby_bluetooth.h"
+
+#pragma comment(lib, "irprops.lib")
+
+#pragma comment(lib, "ws2_32.lib")
+
+
+VALUE bt_module;
+VALUE bt_devices_class;
+VALUE bt_cBluetoothDevice;
+
+// The initialization method for this module
+void Init_bluetooth()
+{
+    bt_module = rb_define_module("Bluetooth");
+    bt_devices_class = rb_define_class_under(bt_module, "Devices", rb_cObject);
+    rb_define_singleton_method(bt_devices_class, "scan", RUBY_METHOD_FUNC(bt_devices_scan), 0);
+    rb_undef_method(bt_devices_class, "initialize");
+
+    bt_cBluetoothDevice = rb_const_get(mBluetooth, rb_intern("Device"));
+}
+
+// Scan local network for visible remote devices
+static VALUE bt_devices_scan(VALUE self)
+{
+    WORD wVersionRequested = 0x202;
+    HANDLE hRadio;
+    BLUETOOTH_FIND_RADIO_PARAMS btfrp = { sizeof(btfrp) };
+
+    HBLUETOOTH_RADIO_FIND hFind = BluetoothFindFirstRadio( &btfrp, &hRadio );
+
+    VALUE devices_array = rb_ary_new();
+    if ( NULL != hFind )
+    {
+        do
+        {
+            BLUETOOTH_DEVICE_INFO_STRUCT deviceInfo;
+
+            deviceInfo.dwSize = sizeof(deviceInfo);
+
+            BLUETOOTH_DEVICE_SEARCH_PARAMS deviceSearchParams;
+
+            memset(&deviceSearchParams, 0, sizeof(deviceSearchParams));
+
+            deviceSearchParams.dwSize = sizeof(deviceSearchParams);
+
+            deviceSearchParams.fReturnAuthenticated = true;
+            deviceSearchParams.fReturnRemembered = false;
+            deviceSearchParams.fReturnUnknown = true;
+            deviceSearchParams.fReturnConnected = true;
+            deviceSearchParams.fIssueInquiry = true;
+            deviceSearchParams.cTimeoutMultiplier = 1;
+
+            deviceSearchParams.hRadio = hRadio;
+
+            HANDLE hDeviceFind = BluetoothFindFirstDevice(&deviceSearchParams, &deviceInfo);
+
+            if (NULL != hDeviceFind)
+            {
+                do
+                {
+                    BYTE *rgBytes = deviceInfo.Address.rgBytes;
+                    //BluetoothDisplayDeviceProperties(0, &deviceInfo);
+                    char addr[19] = { 0 };
+                    char name[248] = { 0 };
+                    wcstombs(name, deviceInfo.szName, sizeof(name));
+
+                    snprintf(addr, sizeof(addr), "%02x:%02x:%02x:%02x:%02x:%02x",
+                             rgBytes[5],
+                             rgBytes[4],
+                             rgBytes[3],
+                             rgBytes[2],
+                             rgBytes[1],
+                             rgBytes[0]);
+
+                    VALUE bt_dev = rb_funcall(bt_cBluetoothDevice,
+                        rb_intern("new"), 2, 
+                        rb_str_new2(name), rb_str_new2(addr));
+                    rb_ary_push(devices_array, bt_dev);
+                }
+                while(BluetoothFindNextDevice(hDeviceFind, &deviceInfo));
+
+                BluetoothFindDeviceClose(hDeviceFind);
+            }
+
+            GUID guidServices[10];
+
+            DWORD numServices = sizeof(guidServices);
+
+            DWORD result = BluetoothEnumerateInstalledServices(hRadio, &deviceInfo, &numServices, guidServices);
+
+            CloseHandle( hRadio );
+        } while( BluetoothFindNextRadio( hFind, &hRadio ) );
+
+        BluetoothFindRadioClose( hFind );
+    }
+
+    return devices_array;
+
+}

data/ext/bluetooth/win32/ruby_bluetooth.h

@@ -0,0 +1,24 @@
+// Prototype for the initialization method - Ruby calls this, not you
+void Init_ruby_bluetooth();
+
+struct bluetooth_device_struct
+  {
+    VALUE addr;
+    VALUE name;
+  };
+
+static VALUE bt_device_new(VALUE self, VALUE name, VALUE addr);
+
+static VALUE bt_devices_scan(VALUE self);
+
+static VALUE bt_socket_s_for_fd(VALUE klass, VALUE fd);
+
+static VALUE bt_socket_inspect(VALUE self);
+
+static VALUE bt_init_sock(VALUE sock, int fd);
+
+static int bt_ruby_socket(int domain, int type, int proto);
+
+static VALUE bt_rfcomm_socket_init(int argc, VALUE *argv, VALUE sock);
+
+static VALUE bt_rfcomm_socket_connect(VALUE self, VALUE host, VALUE port);

data/lib/bluetooth.rb

@@ -0,0 +1,21 @@
+module Bluetooth
+
+  VERSION = '1.0'
+
+  ERRORS = {}
+
+  class Error < RuntimeError
+    def self.raise status
+      err = Bluetooth::ERRORS[status]
+      super(*err) if err
+
+      super self, "unknown error (#{status})"
+    end
+  end
+
+  autoload :Device, 'bluetooth/device'
+
+end
+
+require 'bluetooth/bluetooth'
+

data/lib/bluetooth/device.rb

@@ -0,0 +1,79 @@
+##
+# A bluetooth device
+
+class Bluetooth::Device
+
+  ##
+  # The address of this device in XX-XX-XX-XX-XX-XX format
+
+  attr_accessor :address
+
+  ##
+  # Sets the name of this device
+
+  attr_writer :name
+
+  ##
+  # Creates a new Device with an +address+ and an optional +name+
+
+  def initialize address, name = nil
+    @address = address
+    @name = name
+
+    @pair_error = nil
+    @pair_confirmation_callback = nil
+  end
+
+  ##
+  # The bytes of this address
+
+  def address_bytes
+    @address.split('-').map { |c| c.to_i(16) }.pack 'C*'
+  end
+
+  ##
+  # Returns the link quality for the device.
+
+  def link_quality
+    connect do
+      _link_quality
+    end
+  end
+
+  ##
+  # The name of this Device.  It will be automatically looked up if not
+  # already known.
+
+  def name
+    return @name if @name
+
+    @name = request_name
+
+    return '(unknown)' unless @name
+
+    @name
+  end
+
+  ##
+  # Called during pairing if user confirmation is required with a number
+  # to match with the device.  Return true if the number matches.
+
+  def pair_confirmation &block
+    @pair_confirmation_callback = block
+  end
+
+  ##
+  # Returns the RSSI for the device
+
+  def rssi
+    connect do
+      _rssi
+    end
+  end
+
+  def to_s # :nodoc:
+    "#{name} at #{address}"
+  end
+
+end
+