motion-beacon 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 09750b5492cc2c3e8fb72d58ae99a90c246265ea
+  data.tar.gz: 3a9920655fdbece2c6d2be36d405e56f6ccebab8
+SHA512:
+  metadata.gz: e4c9318ccd291aa94a7272c2af1b4ec9c060f17ab318dc6f402a28763706f9143d4afdcd1bf206eb39f77660bc9e10fe2f91f738b0a3a4c9bf618533acbaf5ab
+  data.tar.gz: 1974bd9fc9192bcb423bdc54b1c1cfa07c584e7e04c94c3f83842cc6c58c3f6d4edef77e9cd9056f168e1cca59129607ebe86fea5178dc3ae67eb902acff4fe7

data/.gitignore

@@ -0,0 +1,21 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+
+.DS_Store
+build

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+ 
+# Specify your gem's dependencies in motion-beacon.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,12 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    sugarcube-timer (1.3.11)
+    rake (10.1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  sugarcube-timer
+  rake

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Vaclav Samec
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,34 @@
+# MotionBeacon
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'motion-beaon'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install motion-beacon
+
+## Usage
+
+Inlcude MotionBeacon module in your app_delegate.rb:
+
+	include MotionBeacon
+
+Once MotionBeacon module is included, you can start using it:
+
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,12 @@
+# -*- coding: utf-8 -*-
+$:.unshift("/Library/RubyMotion/lib")
+require 'motion/project/template/ios'
+require 'bundler'
+require 'sugarcube-timer'
+ 
+$:.unshift("./lib/")
+require './lib/motion-beacon'
+ 
+Motion::Project::App.setup do |app|
+  app.frameworks += ['CoreLocation']
+end

data/app/app_delegate.rb

@@ -0,0 +1,37 @@
+include SugarCube::Timer
+
+class AppDelegate
+  def application(application, didFinishLaunchingWithOptions:launchOptions)
+
+    after 2.sec do
+
+      @beaconManager = BeaconManager.new('E2C56DB5-DFFB-48D2-B060-D0F5A71096E0', 'com.codium.iBeaconsDemo')
+
+      @beaconManager.createRegion(major: 0, minor: 1)
+      @beaconManager.startRangingBeacons(major: 0, minor: 1)
+      @beaconManager.createRegion(major: 0, minor: 2)
+      @beaconManager.startRangingBeacons(major: 0, minor: 2)
+
+      @beaconManager.onEnterRegion { |region|
+
+        NSLog("Region entered: #{region.to_s}")
+      }
+
+      @beaconManager.onLeaveRegion { |region|
+        NSLog("Region leaved: " + region.to_s)
+      }
+
+      @beaconManager.onChangeRegion { |oldRegion, newRegion|
+        NSLog("Region change, old: [#{oldRegion.to_s}] new: [#{newRegion}]")
+      }
+
+      @beaconManager.onLostRegions {
+        NSLog("Regions lost")
+      }
+
+    end
+
+    true
+  end
+end
+

data/lib/motion-beacon/beaconmanager.rb

@@ -0,0 +1,315 @@
+include SugarCube::Timer
+
+# wrapper over CLLocationManager and CLBeaconRegion
+class BeaconManager
+
+  # the unique ID of the beacons being targeted
+  attr_reader :proximityUUID
+
+  # unique identifier to all your beacons for using in your application
+  #   @example
+  #     com.company.beaconsApp
+  attr_reader :beaconID
+
+  # timeout for deactivating regions in [ms]
+  REGION_TIMEOUT = 2000
+
+  # tick update timeout in [ms]
+  UPDATE_TIMEOUT = 500
+
+  # initialize BeaconManager with a proximity ID of beacons being targeted and application beacon ID
+  # @example
+  #   beaconManager = BeaconManager.new('E2C56DB5-DFFB-48D2-B060-D0F5A71096E0',
+  #                                     'com.company.beacons')
+  def initialize(proximityUUID, beaconID)
+    @locationManager = CLLocationManager.alloc.init
+    @locationManager.delegate = self
+
+    @proximityUUID = if proximityUUID.is_a? NSUUID then
+                      id
+                    elsif proximityUUID.is_a? String then
+                      NSUUID.alloc.initWithUUIDString(proximityUUID)
+                    else
+                      raise 'Invalid Beacon proximity UUID!'
+                    end
+
+    @beaconID = if beaconID.is_a? String then
+                  beaconID
+                else
+                  raise 'Invalid Beacon app ID!'
+                end
+
+    @regions = []
+    @activeRegions = []
+    @activeRegion = nil
+    @callbacks = Hash.new { |hash, key| hash[key] = [] }
+
+    every UPDATE_TIMEOUT.millisec do
+      self.onTimer
+    end
+  end
+
+  # create a beacon region that targets beacons with specified major value and minor value
+  # @example
+  #   createRegion(major: 0, minor: 1)
+  def createRegion(options = {})
+
+    minor = options.fetch(:minor, nil)
+    major = options.fetch(:major, nil)
+
+    id = @beaconID;
+    if not major.nil?
+      id = id + ':' + if minor.nil? then major.to_s else minor.to_s end
+    end
+
+    region = if major.nil? then
+               CLBeaconRegion.alloc.initWithProximityUUID(@proximityUUID, identifier: id)
+             elsif minor.nil? then
+               CLBeaconRegion.alloc.initWithProximityUUID(@proximityUUID, major: major, identifier: id)
+             else
+               CLBeaconRegion.alloc.initWithProximityUUID(@proximityUUID, major: major, minor: minor, identifier: id)
+             end
+
+    region.notifyOnEntry = true
+    region.notifyOnExit = true
+    region.notifyEntryStateOnDisplay = true
+
+    @regions.push(region)
+  end
+
+  # advertise this device as a beacon
+  def advertiseSelf(major, minor)
+  end
+
+  # start the delivery of notifications for beacons in the specified region
+  # @example
+  #   startRangingBeacons(:major = 0, :minor = 1)
+  #   startRangingBeacons(:major = 0)
+  #   startRangingBeacons
+  def startRangingBeacons(options = {})
+    major = options.fetch(:major, nil)
+    minor = options.fetch(:minor, nil)
+
+    regions = findRegions(major, minor)
+
+    regions.each { |region|
+      @locationManager.startRangingBeaconsInRegion(region)
+    }
+  end
+
+  # stops the delivery of notifications for the specified beacon regions
+  # @example
+  #   stopRangingBeacons(:major = 0, :minor = 1)
+  #   stopRangingBeacons(:major = 0)
+  #   stopRangingBeacons
+  def stopRangingBeacons(options = {})
+    major = options.fetch(:major, nil)
+    minor = options.fetch(:minor, nil)
+
+    regions = findRegions(major, minor)
+
+    regions.each { |region|
+      @locationManager.stopRangingBeacons(region)
+    }
+  end
+
+  # add event handler for detection of entering the beacon region
+  # @example
+  #   onEnterRegion { my_code }
+  #   onEnterRegion(:major = 0) { |region| my_code }
+  #   onEnterRegion(:major = 0, :minor = 1) { my_code }
+  def onEnterRegion(options = {}, &block)
+    major = options.fetch(:major, nil)
+    minor = options.fetch(:minor, nil)
+
+    key = CallbackKey.new(major, minor, :enter)
+    @callbacks[key].push(block.weak!)
+  end
+
+  # add event handler for detection of leaving the beacon region
+  # @example
+  #   onLeaveRegion { my_code }
+  #   onLeaveRegion(:major = 0) { |region| my_code }
+  #   onLeaveRegion(:major = 0, :minor = 1) { my_code }
+  def onLeaveRegion(options = {}, &block)
+    major = options.fetch(:major, nil)
+    minor = options.fetch(:minor, nil)
+
+    key = CallbackKey.new(major, minor, :leave)
+    @callbacks[key].push(block.weak!)
+  end
+
+  # add event handler for detection of changing the region
+  # @example
+  #   onChangeRegion { |oldRegion, newRegion| my_code }
+  def onChangeRegion(&block)
+    key = CallbackKey.new(0, 0, :change)
+    @callbacks[key].push(block.weak!)
+  end
+
+  # add event handler for detection of loosing any regions
+  # this is called when there are no close regions in range
+  # @example
+  #   onLostRegions { my_code }
+  def onLostRegions(&block)
+    key = CallbackKey.new(0, 0, :lost)
+    @callbacks[key].push(block.weak!)
+  end
+
+private
+  CallbackKey = Struct.new(:major, :minor, :type)
+
+
+protected
+  def onTimer
+    @activeRegions.each { |region|
+      region.timeout += UPDATE_TIMEOUT
+    }
+
+#    if @activeRegions.count > 0 then
+#      NSLog("onTimer.timeout: " + @activeRegions[0].timeout.to_s)
+#    end
+
+    @activeRegions.delete_if { |region| region.timeout > REGION_TIMEOUT }
+
+    self.updateRegions
+  end
+
+  protected
+  def updateRegions
+    if not @activeRegions.empty? then
+
+#      if @activeRegions.count > 1 then
+#        NSLog("region0: #{@activeRegions[0].distance.to_s} region1: #{@activeRegions[1].distance.to_s}")
+#      end
+
+      sorted = @activeRegions.sort { |a, b| a.distance <=> b.distance }
+
+      if sorted[0] != @activeRegion then
+        if not @activeRegion.nil? then
+          regionLeaved(@activeRegion)
+        end
+        regionChanged(@activeRegion, sorted[0])
+        @activeRegion = sorted[0]
+        regionEntered(@activeRegion)
+      end
+
+    elsif not @activeRegion.nil? then
+      self.regionLeaved(@activeRegion)
+      self.regionChanged(@activeRegion, nil)
+      @activeRegion = nil
+      self.regionsLost
+    end
+  end
+
+  def regionEntered(region)
+#    NSLog("regionEntered: callbacks: #{@callbacks.count.to_s}")
+    @callbacks.each { |key, value|
+
+      if (key.type == :enter) and
+         ((key.major.nil?) or
+         (key.minor.nil? and key.major == region.major) or
+         (region.major == key.major and region.minor == key.minor) or
+         (region.hasBeacon?(key.major, key.minor))) then
+
+         if not value[0].nil? then
+           value[0].call(region)
+         end
+      end
+    }
+
+  end
+
+  def regionLeaved(region)
+#    NSLog("onRegionLeav: callbacks: #{@callbacks.count.to_s}")
+    @callbacks.each { |key, value|
+
+      if (key.type == :leave) and
+         ((key.major.nil?) or
+         (key.minor.nil? and key.major == region.major) or
+         (region.major == key.major and region.minor == key.minor) or
+         (region.hasBeacon?(key.major, key.minor))) then
+
+         if not value[0].nil? then
+           value[0].call(region)
+         end
+      end
+    }
+  end
+
+  def regionChanged(regionOld, regionNew)
+    @callbacks.each { |key, value|
+
+      if key.type == :change then
+
+        if not value[0].nil? then
+          value[0].call(regionOld, regionNew)
+        end
+      end
+    }
+  end
+
+  def regionsLost
+    @callbacks.each { |key, value|
+
+      if key.type == :lost
+        if not value[0].nil?
+          value[0].call
+        end
+      end
+    }
+  end
+
+private
+
+  def findRegions(major, minor)
+    regionsFound = []
+
+    if major.nil?
+      return @regions
+    end
+
+    @regions.each { |region|
+      if region.major == major then
+        if region.minor == minor or minor.nil? then
+          regionsFound.push(region)
+        end
+      end
+    }
+
+    regionsFound
+  end
+
+  def locationManager(locationManager, didRangeBeacons: beacons, inRegion: region)
+
+#    NSLog("didRangeBeacons: " + beacons.count.to_s + " valid: " + beaconsValid?(beacons).to_s)
+
+    if not beacons.empty? and beaconsValid?(beacons) then
+
+#      NSLog("didRangeBeacons: " + beacons.count.to_s + " valid: " + beaconsValid?(beacons).to_s)
+
+      regionIndex = @activeRegions.index(region)
+
+      if regionIndex.nil? then
+        region.beacons = beacons
+        region.timeout = 0
+        @activeRegions.push(region)
+      else
+        @activeRegions[regionIndex].beacons = beacons
+        @activeRegions[regionIndex].timeout = 0
+      end
+
+      self.updateRegions
+
+    end
+  end
+
+  def locationManager(locationManager, rangingBeaconsDidFailForRegion: region, withError: error)
+    NSLog("rangingBeaconsDidFailForRegion: " + region.to_s + " " + error.to_s)
+  end
+
+  def beaconsValid?(beacons)
+    beacons.any? { |beacon| beacon.accuracy > -1 and beacon.rssi != 0 }
+  end
+end
+

data/lib/motion-beacon/clbeaconregion.rb

@@ -0,0 +1,47 @@
+# extended BeaconRegion class with list of beacons and helper methods
+class CLBeaconRegion
+
+  attr_accessor :beacons
+  attr_accessor :timeout
+
+  def distance
+    if @beacons.empty? then
+      return 99999
+    else
+      beaconMin = @beacons.min { |a, b| a.accuracy <=> b.accuracy }
+      beaconMin.accuracy
+    end
+  end
+
+  def hasBeacon?(major, minor)
+    @beacons.each { |beacon|
+      if not major.nil? then
+        if minor.nil? then
+          if beacon.major == major then
+            return true
+          end
+        else
+          if beacon.major == major and beacon.minor == minor then
+            return true
+          end
+        end
+      end
+    }
+    false
+  end
+
+  def to_s
+      "region: [major]: " + major.to_s +
+      " [minor]: " + minor.to_s
+  end
+
+  def printBeacons
+    @beacons.each { |beacon|
+      NSLog("beacon: [major]: " + beacon.major.to_s +
+      " [minor]: " + beacon.minor.to_s +
+      " [proximity]: " + beacon.proximity.to_s +
+      " [accuracy]: " + beacon.accuracy.to_s +
+      " [rssi]: " + beacon.rssi.to_s)
+    }
+  end
+end

data/lib/motion-beacon/version.rb

@@ -0,0 +1,5 @@
+module Motion
+  module Beacon
+    VERSION = "0.0.1"
+  end
+end

data/lib/motion-beacon.rb

@@ -0,0 +1,9 @@
+unless defined?(Motion::Project::Config)
+  raise "This file must be required within a RubyMotion project Rakefile."
+end
+
+Motion::Project::App.setup do |app|
+  Dir.glob(File.join(File.dirname(__FILE__), 'motion-beacon/*.rb')).each do |file|
+    app.files.unshift(file)
+  end
+end

data/motion-beacon.gemspec

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/motion-beacon/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["CODIUM"]
+  gem.email         = ["vaclav.s@codium.co"]
+  gem.description   = "detect iBeacons with simple events"
+  gem.summary       = "Goal of this gem is to add a simple but powerful event system for iBeacon detection."
+  gem.homepage      = "https://bitbucket.org/vencacodium/motion-beacon"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  #gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "motion-beacon"
+  gem.require_paths = ["lib"]
+  gem.version       = Motion::Beacon::VERSION
+  gem.add_dependency "sugarcube-timer"
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: motion-beacon
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- CODIUM
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sugarcube-timer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: detect iBeacons with simple events
+email:
+- vaclav.s@codium.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .repl_history
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- app/app_delegate.rb
+- lib/motion-beacon.rb
+- lib/motion-beacon/beaconmanager.rb
+- lib/motion-beacon/clbeaconregion.rb
+- lib/motion-beacon/version.rb
+- motion-beacon.gemspec
+homepage: https://bitbucket.org/vencacodium/motion-beacon
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Goal of this gem is to add a simple but powerful event system for iBeacon
+  detection.
+test_files: []