flic 0.0.1 → 0.0.2

data/lib/flic/client/features/force_disconnect.rb

@@ -0,0 +1,13 @@
+require 'flic/client/features'
+
+module Flic
+  class Client
+    module Features
+      module ForceDisconnect
+        def force_disconnect(button_bluetooth_address)
+          send_command Protocol::Commands::ForceDisconnect.new(bluetooth_address: button_bluetooth_address)
+        end
+      end
+    end
+  end
+end

data/lib/flic/client/features/get_button_uuid.rb

@@ -0,0 +1,43 @@
+require 'flic/client/features'
+
+require 'thread'
+
+module Flic
+  class Client
+    module Features
+      module GetButtonUuid
+        def initialize(*)
+          @button_bluetooth_address_callbacks_semaphore = Mutex.new
+          @button_bluetooth_address_callbacks = Hash.new { [] }
+
+          super
+        end
+
+        def get_button_uuid(button_bluetooth_address, callback = Proc.new)
+          command = Protocol::Commands::GetButtonUuid.new(bluetooth_address: button_bluetooth_address)
+
+          @button_bluetooth_address_callbacks_semaphore.synchronize do
+            @button_bluetooth_address_callbacks[command.bluetooth_address] << callback
+          end
+
+          send_command command
+        end
+
+        private
+
+        def handle_event(event)
+          case event
+            when Protocol::Events::GetButtonUuidResponse
+              callback = @button_bluetooth_address_callbacks_semaphore.synchronize do
+                @button_bluetooth_address_callbacks[event.bluetooth_address].shift
+              end
+
+              callback.call event.uuid if callback
+            else
+              super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/flic/client/features/get_info.rb

@@ -0,0 +1,52 @@
+require 'flic/client/features'
+
+require 'thread'
+
+module Flic
+  class Client
+    module Features
+      module GetInfo
+        def initialize(*)
+          @get_info_callbacks_semaphore = Mutex.new
+          @get_info_callbacks = []
+
+          super
+        end
+
+        def get_info(callback = Proc.new)
+          @get_info_callbacks_semaphore.synchronize do
+            @get_info_callbacks << callback
+          end
+
+          send_command Protocol::Commands::GetInfo.new
+        end
+
+        private
+
+        def handle_event(event)
+          case event
+            when Protocol::Events::GetInfoResponse
+              server_info = ServerInfo.new(
+                  event.bluetooth_controller_state,
+                  event.bluetooth_address,
+                  event.bluetooth_address_type,
+                  event.maximum_pending_connections,
+                  event.maximum_concurrently_connected_buttons,
+                  event.current_pending_connections,
+                  event.currently_no_space_for_new_connection,
+                  event.verified_buttons_bluetooth_addresses
+              )
+
+              callback = @get_info_callbacks_semaphore.synchronize do
+                @get_info_callbacks.shift
+              end
+
+              callback.call server_info if callback
+            else
+              super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/flic/client/features/ping.rb

@@ -0,0 +1,55 @@
+require 'flic/client/features'
+
+require 'thread'
+
+module Flic
+  class Client
+    module Features
+      module Ping
+        def initialize(*)
+          @ping_id_callback_semaphore = Mutex.new
+          @ping_id_callback = {}
+
+          super
+        end
+
+        def ping(callback = Proc.new)
+          ping_id = alloc_ping_id_with_callback(callback)
+
+          send_command Protocol::Commands::Ping.new(ping_id: ping_id)
+        end
+
+        private
+
+        def alloc_ping_id_with_callback(callback)
+          @ping_id_callback_semaphore.synchronize do
+            ping_id = nil
+
+            loop do
+              ping_id = rand(2**32)
+
+              break unless @ping_id_callback.has_key?(ping_id)
+            end
+
+            @ping_id_callback[ping_id] = callback
+
+            ping_id
+          end
+        end
+
+        def handle_event(event)
+          case event
+            when Protocol::Events::PingResponse
+              callback = @ping_id_callback_semaphore.synchronize do
+                @ping_id_callback.delete event.ping_id
+              end
+
+              callback.call if callback
+            else
+              super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/flic/client/features/scan.rb

@@ -0,0 +1,112 @@
+require 'flic/client/features'
+
+require 'thread'
+
+module Flic
+  class Client
+    module Features
+      module Scan
+        def initialize(*)
+          @scan_id_scanner_semaphore = Mutex.new
+          @scan_id_scanner = {}
+
+          super
+        end
+
+        def scanners
+          @scan_id_scanner_semaphore.synchronize { @scan_id_scanner.values }
+        end
+
+        def add_scanner(scanner)
+          scan_id = _add_scanner(scanner)
+
+          send_command Protocol::Commands::CreateScanner.new(scan_id: scan_id) if scan_id
+        end
+
+        def remove_scanner(scanner)
+          scan_id = _remove_scanner(scanner)
+
+          send_command Protocol::Commands::RemoveScanner.new(scan_id: scan_id) if scan_id
+        end
+
+        def shutdown(*)
+          scanners.each do |scanner|
+            _remove_scanner(scanner)
+          end
+
+          super
+        end
+
+        private
+
+        def handle_event(event)
+          case event
+            when Protocol::Events::AdvertisementPacket
+              scanner = find_scanner_for_scan_id(scanner)
+
+              if scanner
+                scanner.advertisement_received(
+                    event.bluetooth_address,
+                    event.name,
+                    event.rssi,
+                    event.is_private,
+                    event.is_already_verified
+                )
+              end
+            else
+              super
+          end
+        end
+
+        def _add_scanner(scanner)
+          scan_id = nil
+
+          @scan_id_scanner_semaphore.synchronize do
+            unless @scan_id_scanner.values.include?(scanner)
+              loop do
+                scan_id = rand(2**32)
+
+                break unless @scan_id_scanner.has_key?(scan_id)
+              end
+
+              @scan_id_scanner[scan_id] = scanner
+            end
+          end
+
+          scanner.added self if scan_id # we have to do this here because the server does not callback
+
+          scan_id
+        end
+
+        def _remove_scanner(scanner)
+          scan_id = nil
+
+          @scan_id_scanner_semaphore.synchronize do
+            @scan_id_scanner.each do |_scan_id, _scanner|
+              if scanner == _scanner
+                scan_id = _scan_id
+                break
+              end
+            end
+
+            @scan_id_scanner.delete scan_id if scan_id
+          end
+
+          scanner.removed self if scan_id # we have to do this here because the server does not callback
+
+          scan_id
+        end
+
+        def find_scanner_for_scan_id(needle)
+          @scan_id_scanner_semaphore.synchronize do
+            @scan_id_scanner.each do |scan_id, scanner|
+              return scanner if scan_id == needle
+            end
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/flic/client/features/scan_wizard.rb

@@ -0,0 +1,131 @@
+require 'flic/client/features'
+
+require 'thread'
+
+module Flic
+  class Client
+    module Features
+      module ScanWizard
+        def initialize(*)
+          @scan_wizard_id_scan_wizard_semaphore = Mutex.new
+          @scan_wizard_id_scan_wizard = {}
+
+          super
+        end
+
+        def scan_wizards
+          @scan_wizard_id_scan_wizard_semaphore.synchronize { @scan_wizard_id_scan_wizard.values }
+        end
+
+        def add_scan_wizard(scan_wizard)
+          scan_wizard_id = _add_scan_wizard(scan_wizard)
+
+          if scan_wizard_id
+            scan_wizard.added self
+            send_command Protocol::Commands::CreateScanWizard.new(scan_wizard_id: scan_wizard_id)
+          end
+        end
+
+        def remove_scan_wizard(scan_wizard)
+          scan_wizard_id = find_scan_wizard_id_for_scan_wizard(scan_wizard)
+
+          send_command Protocol::Commands::CancelScanWizard.new(scan_wizard_id: scan_wizard_id) if scan_wizard_id
+        end
+
+        def shutdown(*)
+          scan_wizards.each do |scan_wizard|
+            _remove_scan_wizard(scan_wizard)
+            scan_wizard.removed self, nil, nil, nil
+          end
+
+          super
+        end
+
+        private
+
+        def handle_event(event)
+          case event
+            when Protocol::Events::ScanWizardFoundPrivateButton
+              scan_wizard = find_scan_wizard_for_scan_wizard_id(event.scan_wizard_id)
+
+              scan_wizard.found_private_button if scan_wizard
+            when Protocol::Events::ScanWizardFoundPublicButton
+              scan_wizard = find_scan_wizard_for_scan_wizard_id(event.scan_wizard_id)
+
+              scan_wizard.button_bluetooth_address = event.bluetooth_address
+              scan_wizard.button_name = event.name
+              scan_wizard.found_public_button event.bluetooth_address, event.name
+            when Protocol::Events::ScanWizardCompleted
+              scan_wizard = find_scan_wizard_for_scan_wizard_id(event.scan_wizard_id)
+
+              if scan_wizard
+                _remove_scan_wizard(scan_wizard)
+
+                scan_wizard.result = event.scan_wizard_result
+                scan_wizard.removed self, event.scan_wizard_result, scan_wizard.button_bluetooth_address, scan_wizard.button_name
+              end
+            else
+              super
+          end
+        end
+
+        def _add_scan_wizard(scan_wizard)
+          scan_wizard_id = nil
+
+          @scan_wizard_id_scan_wizard_semaphore.synchronize do
+            unless @scan_wizard_id_scan_wizard.values.include?(scan_wizard)
+              loop do
+                scan_wizard_id = rand(2**32)
+
+                break unless @scan_wizard_id_scan_wizard.has_key?(scan_wizard_id)
+              end
+
+              @scan_wizard_id_scan_wizard[scan_wizard_id] = scan_wizard
+            end
+          end
+
+          scan_wizard_id
+        end
+
+        def _remove_scan_wizard(scan_wizard)
+          scan_wizard_id = nil
+
+          @scan_wizard_id_scan_wizard_semaphore.synchronize do
+            if @scan_wizard_id_scan_wizard.values.include?(scan_wizard)
+              @scan_wizard_id_scan_wizard.each do |_scan_wizard_id, _scan_wizard|
+                if scan_wizard == _scan_wizard
+                  scan_wizard_id = _scan_wizard_id
+                  break
+                end
+              end
+
+              @scan_wizard_id_scan_wizard.delete scan_wizard_id if scan_wizard_id
+            end
+          end
+
+          scan_wizard_id
+        end
+
+        def find_scan_wizard_for_scan_wizard_id(needle)
+          @scan_wizard_id_scan_wizard_semaphore.synchronize do
+            @scan_wizard_id_scan_wizard.each do |scan_wizard_id, scan_wizard|
+              return scan_wizard if scan_wizard_id == needle
+            end
+          end
+
+          nil
+        end
+
+        def find_scan_wizard_id_for_scan_wizard(needle)
+          @scan_wizard_id_scan_wizard_semaphore.synchronize do
+            @scan_wizard_id_scan_wizard.each do |scan_wizard_id, scan_wizard|
+              return scan_wizard_id if scan_wizard == needle
+            end
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/flic/client/scan_wizard.rb

@@ -0,0 +1,14 @@
+require 'flic/client'
+
+module Flic
+  class Client
+    class ScanWizard
+      extend Callbacks
+
+      attr_accessor :button_bluetooth_address, :button_name, :result
+
+      define_callbacks :added, :removed,
+                       :found_private_button, :found_public_button, :button_connected
+    end
+  end
+end

data/lib/flic/client/scanner.rb

@@ -0,0 +1,12 @@
+require 'flic/client'
+
+module Flic
+  class Client
+    class Scanner
+      extend Callbacks
+
+      define_callbacks :added, :removed,
+                       :advertisement_received
+    end
+  end
+end

data/lib/flic/client/server_info.rb

@@ -0,0 +1,16 @@
+require 'flic/client'
+
+module Flic
+  class Client
+    ServerInfo = Struct.new(
+        'ServerInfo',
+        :bluetooth_controller_state, :bluetooth_address,
+        :bluetooth_address_type,
+        :maximum_pending_connections,
+        :maximum_concurrently_connected_buttons,
+        :current_pending_connections,
+        :currently_no_space_for_new_connection,
+        :verified_buttons_bluetooth_addresses
+    )
+  end
+end