flic 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ade3fb4aee08cb658059f896f2ba8e3524b7ee76
-  data.tar.gz: b04d34afa0853fb278f57a58c4569d02d53c02dc
+  metadata.gz: 5c7e0c99f004d000f1ed0b0296403fbc8e723a4a
+  data.tar.gz: d48a0bb111640992b77d6bac24f3cdd2e70b2b79
 SHA512:
-  metadata.gz: 625cdb437414faa416799c2a64b581880aa7847fd4f774cc34e16f3c74f882928fbd7dfcc8f1c8b88f73c6c1bc79becb9a0f5e9f8a7e3e54fa826707bbc23835
-  data.tar.gz: d0e5ec61e2394840c33232e60cc2db1840df09587198f99b443d28786e22078ae345fae7f66dc7939cd0ceeb0140297dc3db8729849b27acf0fa253375aada44
+  metadata.gz: fccb7b55b186dbae110a268d78682ae2cc1213b7fc3f0883f08c1fc330549c44b61e868a4a17c8b859e11688cefcc1fa3834cd34932316da3ac5def7135f7796
+  data.tar.gz: 2181c732b2ad6340fc12bd4865de9d2da1dea2e2118b4c09dc2ee9fa5a1d221ee88299609ab2495cb20c665e19d8d3b5618831f3fcaf71be95554ee240bb04fd

data/lib/flic.rb

@@ -1,7 +1,8 @@
 require 'flic/version'
 
 module Flic
+  autoload :Callbacks, 'flic/callbacks'
   autoload :Client, 'flic/client'
-  autoload :EventBus, 'flic/event_bus'
   autoload :Protocol, 'flic/protocol'
+  autoload :SimpleClient, 'flic/simple_client'
 end

data/lib/flic/callbacks.rb

@@ -0,0 +1,36 @@
+require 'flic'
+
+require 'thread'
+
+module Flic
+  module Callbacks
+    SEMAPHORE = Mutex.new
+
+    private
+
+    def define_callbacks(*callback_names)
+      callback_names.each do |callback_name|
+        semaphore_instance_variable = :"@#{callback_name}_callbacks_semaphore"
+        callbacks_instance_variable = :"@#{callback_name}_callbacks"
+
+        define_method :"#{callback_name}" do |*args, &callback|
+          semaphore = SEMAPHORE.synchronize do
+            instance_variable_get(semaphore_instance_variable) ||
+                instance_variable_set(semaphore_instance_variable, Mutex.new)
+          end
+
+          semaphore.synchronize do
+            callbacks = instance_variable_get(callbacks_instance_variable) ||
+                instance_variable_set(callbacks_instance_variable, [])
+
+            if callback
+              callbacks << callback
+            else
+              callbacks.each { |callback| callback.call *args }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/flic/client.rb

@@ -1,14 +1,29 @@
 require 'flic'
-require 'flic/event_bus'
-require 'flic/protocol'
+
+require 'thread'
+require 'socket'
 
 module Flic
   class Client
-    autoload :Connection, 'flic/client/connection'
-
     class Error < StandardError; end
     class ClientShutdownError < Error; end
 
+    autoload :ConnectionChannel, 'flic/client/connection_channel'
+    autoload :Features, 'flic/client/features'
+    autoload :ScanWizard, 'flic/client/scan_wizard'
+    autoload :Scanner, 'flic/client/scanner'
+    autoload :ServerInfo, 'flic/client/server_info'
+
+    extend Callbacks
+
+    prepend Features::ConnectionChannel
+    prepend Features::ForceDisconnect
+    prepend Features::GetButtonUuid
+    prepend Features::GetInfo
+    prepend Features::Ping
+    prepend Features::Scan
+    prepend Features::ScanWizard
+
     class << self
       def open(*args)
         client = new(*args)
@@ -21,227 +36,61 @@ module Flic
       end
     end
 
-    attr_reader :connection, :driver
+    attr_reader :host, :port, :socket, :connection
 
-    def initialize(*connection_args)
-      @connection = Connection.new(*connection_args)
+    define_callbacks :new_button_verified, :bluetooth_controller_state_changed,
+                     :connections_exhausted, :connection_available
 
-      @driver = EventBus::Driver.new do |event_bus|
-        begin
-          connection.listen do |event|
-            event_bus.broadcast(event)
-          end
-        rescue Connection::ConnectionClosedError
-          nil
-        rescue Protocol::Error => protocol_error
-          warn protocol_error
-
-          retry
-        end
-      end
 
+    def initialize(host = 'localhost', port = 5551)
+      @host, @port = host, port
+      @handle_next_event_semaphore = Mutex.new
+      @socket = TCPSocket.new(host, port)
+      @connection = Protocol::Connection.new(socket)
       yield self if block_given?
     end
 
-    def hostname
-      connection.hostname
-    end
-
-    def port
-      connection.port
-    end
-
-    def shutdown?
-      connection.closed?
-    end
-
     def shutdown
       connection.close
     end
 
-    def ping ping_id = rand(2**32)
-      request Protocol::Commands::Ping.new(ping_id: ping_id) do |event|
-        Protocol::Events::PingResponse === event &&
-            event.ping_id == ping_id
-      end
-
-      true
-    end
-
-    def server_info
-      request Protocol::Commands::GetInfo, Protocol::Events::GetInfoResponse
-    end
-
-    def button_uuid(bluetooth_address)
-      command = Protocol::Commands::GetButtonUuid.new(bluetooth_address: bluetooth_address)
-
-      response = request command do |event|
-        Protocol::Events::GetButtonUuidResponse === event &&
-            event.bluetooth_address == command.bluetooth_address
-      end
-
-      unless response.uuid == Protocol::INVALID_BUTTON_UUID
-        response.uuid
-      end
-    end
-
-    def buttons
-      server_info.verified_buttons
-    end
-
-    def disconnect_button(bluetooth_address)
-      send_command Protocol::Commands::ForceDisconnect.new(bluetooth_address: bluetooth_address)
-    end
-
-    def connect_button
-      bluetooth_address = nil
-
-      result = scan_wizard do |button_type, _bluetooth_address|
-        bluetooth_address = _bluetooth_address if button_type == :public
-      end
-
-      bluetooth_address if result == :success
-    end
-
-    def scan(scan_id = rand(2**32))
-      subscribe do |subscription|
-        send_command Protocol::Commands::CreateScanner.new(scan_id: scan_id)
-
-        begin
-          subscription.listen do |event|
-            if Protocol::Events::AdvertisementPacket === event && event.scan_id == scan_id
-              yield event.bluetooth_address, event.name, event.rssi, event.is_private, event.is_already_verified
-            end
-          end
-        ensure
-          send_command Protocol::Commands::RemoveScanner.new(scan_id: scan_id)
-        end
-      end
-    end
-
-    def scan_wizard(scan_wizard_id = rand(2**32))
-      subscribe do |subscription|
-        send_command Protocol::Commands::CreateScanWizard.new(scan_wizard_id: scan_wizard_id)
-
+    def handle_next_event
+      @handle_next_event_semaphore.synchronize do
         begin
-          bluetooth_address = nil
-          name = nil
-
-          result = subscription.listen do |event|
-            case event
-              when Protocol::Events::ScanWizardFoundPrivateButton
-                yield :private, nil, nil
-              when Protocol::Events::ScanWizardFoundPublicButton
-                bluetooth_address, name = event.bluetooth_address, event.name
-              when Protocol::Events::ScanWizardButtonConnected
-                yield :public, bluetooth_address, name
-              when Protocol::Events::ScanWizardCompleted
-                break event.scan_wizard_result
-            end
-          end
-        ensure
-          send_command Protocol::Commands::CancelScanWizard.new(scan_wizard_id: scan_wizard_id) unless result
-        end
-      end
-    end
-
-    def channel(bluetooth_address, latency_mode = :normal, auto_disconnect_time = nil, connection_id = rand(2**32))
-      auto_disconnect_time = 512 unless auto_disconnect_time # 512 means disabled
-
-      subscribe do |subscription|
-        send_command Protocol::Commands::CreateConnectionChannel.new(
-            connection_id: connection_id,
-            bluetooth_address: bluetooth_address,
-            latency_mode: latency_mode,
-            auto_disconnect_time: auto_disconnect_time
-        )
+          handle_event connection.recv_event
+        rescue Protocol::Connection::ConnectionClosedError
+          shutdown
 
-        is_removed = false
-
-        begin
-          subscription.listen do |event|
-            case event
-              when Protocol::Events::ButtonSingleOrDoubleClickOrHold
-                yield bluetooth_address, event.click_type, event.time_difference
-              when Protocol::Events::ConnectionChannelRemoved
-                is_removed = true
-                break
-            end
-          end
-        ensure
-          send_command Protocol::Commands::RemoveConnectionChannel.new(connection_id: connection_id) unless is_removed
+          raise ClientShutdownError, 'The connection has been closed'
         end
       end
     end
 
-    def listen(*bluetooth_addresses)
-      subscribe do |subscription|
-        connection_id_bluetooth_address = {}
-
-        begin
-          bluetooth_addresses.each do |bluetooth_address|
-            connection_id = rand(2**32)
-
-            send_command Protocol::Commands::CreateConnectionChannel.new(
-                connection_id: connection_id,
-                bluetooth_address: bluetooth_address,
-                latency_mode: :normal,
-                auto_disconnect_time: 512
-            )
-
-            connection_id_bluetooth_address[connection_id] = bluetooth_address
-          end
-
-          subscription.listen do |event|
-            case event
-              when Protocol::Events::ButtonSingleOrDoubleClickOrHold
-                bluetooth_address = connection_id_bluetooth_address[event.connection_id]
-                yield bluetooth_address, event.click_type, event.time_difference
-              when Protocol::Events::ConnectionChannelRemoved
-                bluetooth_address = connection_id_bluetooth_address[event.connection_id]
-                connection_id_bluetooth_address.delete event.connection_id
-                raise "connection to #{bluetooth_address} was removed"
-            end
-          end
-        ensure
-          connection_id_bluetooth_address.each do |connection_id, _|
-            send_command Protocol::Commands::RemoveConnectionChannel.new(
-                connection_id: connection_id
-            )
-          end
-        end
-      end
+    def enter_main_loop
+      loop { handle_next_event }
     end
 
     private
 
-    def event_bus
-      @event_bus ||= driver.event_bus
-    end
-
     def send_command(command)
-      command = command.new if Class === command
       connection.send_command(command)
-    rescue Client::Connection::ConnectionClosedError
-      raise ClientShutdownError
-    end
-
-    def subscribe
-      event_bus.subscribe { |subscription| yield subscription }
-    rescue EventBus::EventBusShutdown
-      raise ClientShutdownError
-    end
-
-    def request(command, response_matcher = Proc.new)
-      subscribe do |subscription|
-        send_command command
-
-        subscription.listen do |event|
-          if response_matcher === event
-            break event
-          end
-        end
+    rescue Protocol::Connection::ConnectionClosedError
+      shutdown
+
+      raise ClientShutdownError, 'The connection has been closed'
+    end
+
+    def handle_event(event)
+      case event
+        when Protocol::Events::NewVerifiedButton
+          new_button_verified event.bluetooth_address
+        when Protocol::Events::BluetoothControllerStateChange
+          bluetooth_controller_state_changed event.bluetooth_controller_state
+        when Protocol::Events::NoSpaceForNewConnection
+          connections_exhausted
+        when Protocol::Events::GotSpaceForNewConnection
+          connection_available
       end
     end
   end
-end
+end

data/lib/flic/client/connection_channel.rb

@@ -0,0 +1,21 @@
+require 'flic/client'
+
+module Flic
+  class Client
+    class ConnectionChannel
+      extend Callbacks
+
+      attr_reader :button_bluetooth_address, :latency_mode, :auto_disconnect_time
+      attr_accessor :status
+
+      define_callbacks :added, :removed, :failed_to_add, :status_changed,
+                       :button_up_or_down, :button_click_or_hold,
+                       :button_single_click_or_double_click, :button_single_click_or_double_click_or_hold
+
+      def initialize(button_bluetooth_address, latency_mode, auto_disconnect_time = nil)
+        @button_bluetooth_address, @latency_mode, @auto_disconnect_time = button_bluetooth_address, latency_mode, auto_disconnect_time
+        @status = :disconnected
+      end
+    end
+  end
+end

data/lib/flic/client/features.rb

@@ -0,0 +1,15 @@
+require 'flic/client'
+
+module Flic
+  class Client
+    module Features
+      autoload :ConnectionChannel, 'flic/client/features/connection_channel'
+      autoload :ForceDisconnect, 'flic/client/features/force_disconnect'
+      autoload :GetButtonUuid, 'flic/client/features/get_button_uuid'
+      autoload :GetInfo, 'flic/client/features/get_info'
+      autoload :Ping, 'flic/client/features/ping'
+      autoload :Scan, 'flic/client/features/scan'
+      autoload :ScanWizard, 'flic/client/features/scan_wizard'
+    end
+  end
+end

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

@@ -0,0 +1,175 @@
+require 'flic/client/features'
+
+require 'thread'
+
+module Flic
+  class Client
+    module Features
+      module ConnectionChannel
+        def initialize(*)
+          @connection_channel_id_connection_channel_semaphore = Mutex.new
+          @connection_channel_id_connection_channel = {}
+
+          super
+        end
+
+        def connection_channels
+          @connection_channel_id_connection_channel_semaphore.synchronize { @connection_channel_id_connection_channel.values }
+        end
+
+        def add_connection_channel(connection_channel)
+          connection_channel_id = _add_connection_channel(connection_channel)
+
+          if connection_channel_id
+            send_command Protocol::Commands::CreateConnectionChannel.new(
+                connection_channel_id: connection_channel_id,
+                bluetooth_address: connection_channel.button_bluetooth_address,
+                latency_mode: connection_channel.latency_mode,
+                auto_disconnect_time: connection_channel.auto_disconnect_time
+            )
+          end
+        end
+
+        def remove_connection_channel(connection_channel)
+          connection_channel_id = find_connection_channel_id_by_connection_channel(connection_channel)
+
+          if connection_channel_id
+            send_command Protocol::Commands::RemoveConnectionChannel.new(
+                connection_channel_id: connection_channel_id
+            )
+          end
+        end
+
+        def shutdown(*)
+          connection_channels.each do |connection_channel|
+            _remove_connection_channel(connection_channel)
+            connection_channel.removed self
+          end
+
+          super
+        end
+
+        private
+
+        def handle_event(event)
+          case event
+            when Protocol::Events::CreateConnectionChannelResponse
+              connection_channel = find_connection_channel_by_connection_channel_id(event.connection_channel_id)
+
+              if connection_channel
+                if event.error == :no_error
+                  connection_channel.added self
+                else
+                  _remove_connection_channel(connection_channel)
+                  connection_channel.failed_to_add self, event.error
+                end
+              end
+
+            when Protocol::Events::ConnectionStatusChanged
+              connection_channel = find_connection_channel_by_connection_channel_id(event.connection_channel_id)
+
+              if connection_channel
+                connection_channel.status = event.connection_status
+                connection_channel.status_changed event.connection_status
+              end
+
+            when Protocol::Events::ButtonUpOrDown
+              connection_channel = find_connection_channel_by_connection_channel_id(event.connection_channel_id)
+
+              if connection_channel
+                connection_channel.button_up_or_down event.click_type, event.time_difference, event.was_queued
+              end
+            when Protocol::Events::ButtonClickOrHold
+              connection_channel = find_connection_channel_by_connection_channel_id(event.connection_channel_id)
+
+              if connection_channel
+                connection_channel.button_click_or_hold event.click_type, event.time_difference, event.was_queued
+              end
+
+            when Protocol::Events::ButtonSingleOrDoubleClick
+              connection_channel = find_connection_channel_by_connection_channel_id(event.connection_channel_id)
+
+              if connection_channel
+                connection_channel.button_single_click_or_double_click event.click_type, event.time_difference, event.was_queued
+              end
+
+            when Protocol::Events::ButtonSingleOrDoubleClickOrHold
+              connection_channel = find_connection_channel_by_connection_channel_id(event.connection_channel_id)
+
+              if connection_channel
+                connection_channel.button_single_click_or_double_click_or_hold event.click_type, event.time_difference, event.was_queued
+              end
+
+            when Protocol::Events::ConnectionChannelRemoved
+              connection_channel = find_connection_channel_by_connection_channel_id(event.connection_channel_id)
+
+              if connection_channel
+                _remove_connection_channel(connection_channel)
+                connection_channel.removed self, event.reason
+              end
+
+            else
+              super
+          end
+        end
+
+        def find_connection_channel_by_connection_channel_id(needle)
+          @connection_channel_id_connection_channel_semaphore.synchronize do
+            @connection_channel_id_connection_channel.each do |connection_channel_id, connection_channel|
+              return connection_channel if connection_channel_id == needle
+            end
+          end
+
+          nil
+        end
+
+        def find_connection_channel_id_by_connection_channel(needle)
+          @connection_channel_id_connection_channel_semaphore.synchronize do
+            @connection_channel_id_connection_channel.each do |connection_channel_id, connection_channel|
+              return connection_channel_id if connection_channel == needle
+            end
+          end
+
+          nil
+        end
+
+        def _add_connection_channel(connection_channel)
+          connection_channel_id = nil
+
+          @connection_channel_id_connection_channel_semaphore.synchronize do
+            unless @connection_channel_id_connection_channel.values.include?(connection_channel)
+              loop do
+                connection_channel_id = rand(2**32)
+
+                break unless @connection_channel_id_connection_channel.has_key?(connection_channel_id)
+              end
+
+              @connection_channel_id_connection_channel[connection_channel_id] = connection_channel
+            end
+          end
+
+          connection_channel_id
+        end
+
+        def _remove_connection_channel(connection_channel)
+          connection_channel_id = nil
+
+          @connection_channel_id_connection_channel_semaphore.synchronize do
+            if @connection_channel_id_connection_channel.values.include?(connection_channel)
+              @connection_channel_id_connection_channel.each do |_connection_channel_id, _connection_channel|
+                if connection_channel == _connection_channel
+                  connection_channel_id = _connection_channel_id
+                  break
+                end
+              end
+
+              @connection_channel_id_connection_channel.delete connection_channel_id if connection_channel_id
+            end
+          end
+
+          connection_channel_id
+        end
+      end
+    end
+  end
+end