flic 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ade3fb4aee08cb658059f896f2ba8e3524b7ee76
+  data.tar.gz: b04d34afa0853fb278f57a58c4569d02d53c02dc
+SHA512:
+  metadata.gz: 625cdb437414faa416799c2a64b581880aa7847fd4f774cc34e16f3c74f882928fbd7dfcc8f1c8b88f73c6c1bc79becb9a0f5e9f8a7e3e54fa826707bbc23835
+  data.tar.gz: d0e5ec61e2394840c33232e60cc2db1840df09587198f99b443d28786e22078ae345fae7f66dc7939cd0ceeb0140297dc3db8729849b27acf0fa253375aada44

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/.idea

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.0
+before_install: gem install bundler -v 1.12.5

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 TODO: Write your name
+
+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,30 @@
+# Flic
+
+Flic is a Ruby implementation of the [Fliclib](https://github.com/50ButtonsEach/fliclib-linux-hci/blob/master/ProtocolDocumentation.md).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'flic'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install flic
+
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/anarchocurious/flic.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,12 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec
+task :test => :spec
+
+task :console do
+  require 'flic'
+  require 'pry'
+  Pry.start
+end

data/flic.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'flic/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'flic'
+  spec.version       = Flic::VERSION
+  spec.authors       = ['Alec Larsen']
+  spec.email         = ['aleclarsen42@gmail.com']
+
+  spec.summary       = %q{A Ruby implementation of the (Fliclib)[https://github.com/50ButtonsEach/fliclib-linux-hci/blob/master/ProtocolDocumentation.md]}
+  spec.homepage      = 'https://github.com/anarchocurious/flic'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'bindata', '~> 2.3'
+
+  spec.add_development_dependency 'bundler', '~> 1.12'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'pry'
+end

data/lib/flic.rb

@@ -0,0 +1,7 @@
+require 'flic/version'
+
+module Flic
+  autoload :Client, 'flic/client'
+  autoload :EventBus, 'flic/event_bus'
+  autoload :Protocol, 'flic/protocol'
+end

data/lib/flic/client.rb

@@ -0,0 +1,247 @@
+require 'flic'
+require 'flic/event_bus'
+require 'flic/protocol'
+
+module Flic
+  class Client
+    autoload :Connection, 'flic/client/connection'
+
+    class Error < StandardError; end
+    class ClientShutdownError < Error; end
+
+    class << self
+      def open(*args)
+        client = new(*args)
+
+        begin
+          yield client
+        ensure
+          client.shutdown
+        end
+      end
+    end
+
+    attr_reader :connection, :driver
+
+    def initialize(*connection_args)
+      @connection = Connection.new(*connection_args)
+
+      @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
+
+      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)
+
+        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
+        )
+
+        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
+        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
+    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
+      end
+    end
+  end
+end

data/lib/flic/client/connection.rb

@@ -0,0 +1,87 @@
+require 'flic'
+require 'flic/client'
+require 'flic/protocol'
+
+require 'socket'
+
+module Flic
+  class Client
+    class Connection
+      class Error < StandardError; end
+      class ConnectionClosedError < Error; end
+
+      class << self
+        def open(*args)
+          client = new(*args)
+
+          begin
+            yield client
+          ensure
+            client.close
+          end
+        end
+      end
+
+      attr_reader :hostname, :port
+
+      def initialize(hostname = 'localhost', port = 5551, *additional_socket_args)
+        @hostname, @port = hostname, port
+        @socket = TCPSocket.new(hostname, port, *additional_socket_args)
+        @read_semaphore = Mutex.new
+        @write_semaphore = Mutex.new
+      end
+
+      def send_command(command)
+        send_packet Protocol.serialize_command(command)
+      end
+
+      def recv_event
+        Protocol.parse_event(recv_packet)
+      end
+
+      def listen
+        loop { yield recv_event }
+      end
+
+      def closed?
+        @socket.closed?
+      end
+
+      def close
+        @socket.close
+      end
+
+      private
+
+      def send_packet(payload)
+        @write_semaphore.synchronize do
+          packet_header = Protocol::PacketHeader.new(byte_length: payload.bytesize)
+          @socket.write(packet_header.to_binary_s)
+          @socket.write(payload)
+        end
+      rescue IOError
+        if closed?
+          raise ConnectionClosedError
+        else
+          raise
+        end
+      end
+
+      def recv_packet
+        @read_semaphore.synchronize do
+          packet_header = Protocol::PacketHeader.new
+          packet_header_bytes = @socket.read packet_header.num_bytes
+          packet_header.read(packet_header_bytes)
+
+          @socket.read(packet_header.byte_length)
+        end
+      rescue IOError
+        if closed?
+          raise ConnectionClosedError
+        else
+          raise
+        end
+      end
+    end
+  end
+end