lifx 0.0.1 → 0.4.0

data/lib/lifx/color.rb

@@ -0,0 +1,190 @@
+module LIFX
+  module Colors
+    DEFAULT_KELVIN = 3500
+
+    {
+      red: 0,
+      orange: 36,
+      yellow: 60,
+      green: 120,
+      cyan: 195,
+      blue: 250,
+      purple: 280,
+      pink: 325
+    }.each do |color, hue|
+      define_method(color) do |saturation: 1.0, brightness: 1.0, kelvin: DEFAULT_KELVIN|
+        Color.new(hue, saturation, brightness, kelvin)
+      end
+    end
+
+    # Helper to create a white {Color}
+    # @param brightness: [Float] Valid range: `0..1`
+    # @param kelvin: [Integer] Valid range: `2500..10000`
+    # @return [Color]
+    def white(brightness: 1.0, kelvin: DEFAULT_KELVIN)
+      Color.new(0, 0, brightness, kelvin)
+    end
+
+    # Helper to create a random {Color}
+    def random_color(hue: rand(360), saturation: rand, brightness: rand, kelvin: DEFAULT_KELVIN)
+      Color.new(hue, saturation, brightness, kelvin)
+    end
+  end
+
+  # LIFX::Color represents a color intervally by HSBK (Hue, Saturation, Brightness/Value, Kelvin).
+  # It has methods to construct a LIFX::Color instance from various color representations.
+  class Color < Struct.new(:hue, :saturation, :brightness, :kelvin)
+    extend Colors
+    UINT16_MAX = 65535
+    KELVIN_MIN = 2500
+    KELVIN_MAX = 10000
+
+    class << self
+      # Helper method to create from HSB/HSV
+      # @param hue [Float] Valid range: `0..360`
+      # @param saturation [Float] Valid range: `0..1`
+      # @param brightness [Float] Valid range: `0..1`
+      # @return [Color]
+      def hsb(hue, saturation, brightness)
+        new(hue, saturation, brightness, DEFAULT_KELVIN)
+      end
+      alias_method :hsv, :hsb
+
+      # Helper method to create from HSBK/HSVK
+      # @param hue [Float] Valid range: `0..360`
+      # @param saturation [Float] Valid range: `0..1`
+      # @param brightness [Float] Valid range: `0..1`
+      # @param kelvin [Integer] Valid range: `2500..10000`
+      # @return [Color]
+      def hsbk(hue, saturation, brightness, kelvin)
+        new(hue, saturation, brightness, kelvin)
+      end
+
+      # Helper method to create from HSL
+      # @param hue [Float] Valid range: `0..360`
+      # @param saturation [Float] Valid range: `0..1`
+      # @param luminance [Float] Valid range: `0..1`
+      # @return [Color]
+      def hsl(hue, saturation, luminance)
+        # From: http://ariya.blogspot.com.au/2008/07/converting-between-hsl-and-hsv.html
+        l = luminance * 2
+        saturation *= (l <= 1) ? l : 2 - l
+        brightness = (l + saturation) / 2
+        saturation = (2 * saturation) / (l + saturation)
+        new(hue, saturation, brightness, DEFAULT_KELVIN)
+      end
+
+      # Helper method to create from RGB.
+      # @note RGB is not the recommended way to create colors
+      # @param r [Integer] Red. Valid range: `0..255`
+      # @param g [Integer] Green. Valid range: `0..255`
+      # @param b [Integer] Blue. Valid range: `0..255`
+      # @return [Color]
+      def rgb(r, g, b)
+        r = r / 255.0
+        g = g / 255.0
+        b = b / 255.0
+
+        max = [r, g, b].max
+        min = [r, g, b].min
+
+        h = s = v = max
+        d = max - min
+        s = max.zero? ? 0 : d / max
+
+        if max == min
+          h = 0
+        else
+          case max
+          when r
+            h = (g - b) / d + (g < b ? 6 : 0)
+          when g
+            h = (b - r) / d + 2
+          when b
+            h = (r - g) / d + 4
+          end
+          h = h * 60
+        end
+
+        new(h, s, v, DEFAULT_KELVIN)
+      end
+
+      # Creates an instance from a {Protocol::Light::Hsbk} struct
+      # @api private
+      # @param hsbk [Protocol::Light::Hsbk]
+      # @return [Color]
+      def from_struct(hsbk)
+        new(
+          (hsbk.hue.to_f / UINT16_MAX) * 360,
+          (hsbk.saturation.to_f / UINT16_MAX),
+          (hsbk.brightness.to_f / UINT16_MAX),
+          hsbk.kelvin
+        )
+      end
+    end
+
+    def initialize(hue, saturation, brightness, kelvin)
+      hue = hue % 360
+      super(hue, saturation, brightness, kelvin)
+    end
+
+    # Returns a new Color with the hue changed while keeping other attributes
+    # @param hue [Float] Hue in degrees. `0..360`
+    # @return [Color]
+    def with_hue(hue)
+      Color.new(hue, saturation, brightness, kelvin)
+    end
+
+    # Returns a new Color with the saturaiton changed while keeping other attributes
+    # @param saturaiton [Float] Saturation as float. `0..1`
+    # @return [Color]
+    def with_saturation(saturation)
+      Color.new(hue, saturation, brightness, kelvin)
+    end
+
+    # Returns a new Color with the brightness changed while keeping other attributes
+    # @param brightness [Float] Brightness as float. `0..1`
+    # @return [Color]
+    def with_brightness(brightness)
+      Color.new(hue, saturation, brightness, kelvin)
+    end
+
+    # Returns a new Color with the kelvin changed while keeping other attributes
+    # @param kelvin [Integer] Kelvin. `2500..10000`
+    # @return [Color]
+    def with_kelvin(kelvin)
+      Color.new(hue, saturation, brightness, kelvin)
+    end
+
+    # Returns a struct for use by the protocol
+    # @api private
+    # @return [Protocol::Light::Hsbk]
+    def to_hsbk
+      Protocol::Light::Hsbk.new(
+        hue: (hue / 360.0 * UINT16_MAX).to_i,
+        saturation: (saturation * UINT16_MAX).to_i,
+        brightness: (brightness * UINT16_MAX).to_i,
+        kelvin: [KELVIN_MIN, kelvin.to_i, KELVIN_MAX].sort[1]
+      )
+    end
+
+    # Returns hue, saturation, brightness and kelvin in an array
+    # @return [Array<Float, Float, Float, Integer>]
+    def to_a
+      [hue, saturation, brightness, kelvin]
+    end
+
+    EQUALITY_THRESHOLD = 0.001 # 0.1% variance
+    # Checks if colours are equal to 0.1% variance
+    # @param other [Color] Color to compare to
+    # @return [Boolean]
+    def ==(other)
+      return false unless other.is_a?(Color)
+      conditions = []
+      conditions << ((hue - other.hue).abs < (EQUALITY_THRESHOLD * 360)) 
+      conditions << ((saturation - other.saturation).abs < EQUALITY_THRESHOLD)
+      conditions << ((brightness - other.brightness).abs < EQUALITY_THRESHOLD)
+      conditions.all?
+    end
+  end
+end

data/lib/lifx/config.rb

@@ -0,0 +1,12 @@
+require 'configatron/core'
+require 'yell'
+module LIFX
+  Config = Configatron::Store.new
+
+  Config.default_duration = 1
+  Config.allowed_transports = [:udp, :tcp]
+  Config.logger = Yell.new do |logger|
+    logger.level = 'gte.warn'
+    logger.adapter STDERR, format: '%d [%5L] %p/%t : %m'
+  end
+end

data/lib/lifx/firmware.rb

@@ -0,0 +1,55 @@
+module LIFX
+  # LIFX::Firmware handles decoding firmware payloads
+  class Firmware < Struct.new(:build_time, :major, :minor)
+    include Comparable
+
+    def initialize(payload)
+      self.build_time = decode_time(payload.build)
+      self.major  = (payload.version >> 0x10)
+      self.minor  = (payload.version &  0xFF)
+    end
+
+    def to_s
+      "#<Firmware version=#{self.major}.#{self.minor}>"
+    end
+    alias_method :inspect, :to_s
+
+    def <=>(obj)
+      case obj
+      when String
+        major, minor = obj.split('.', 2).map(&:to_i)
+        [self.major, self.minor] <=> [major, minor]
+      when Firmware
+        [self.major, self.minor] <=> [obj.major, obj.minor]
+      else
+        nil
+      end
+    end
+
+
+    protected
+
+    def decode_time(int)
+      if int < 1300000000000000000
+        year   = byte(int, 56) + 2000
+        month  = bytes(int, 48, 40, 32).map(&:chr).join
+        day    = byte(int, 24)
+        hour   = byte(int, 16)
+        min    = byte(int,  8)
+        sec    = byte(int,  0)
+        # Don't want to pull in DateTime just for DateTime.new
+        Time.parse("%s %d %04d, %02d:%02d:%02d" % [month, day, year, hour, min, sec])
+      else
+        Time.at(int / 1000000000)
+      end
+    end
+
+    def byte(n, pos)
+      0xFF & (n >> pos)
+    end
+
+    def bytes(n, *range)
+      range.map {|r| byte(n, r)}
+    end
+  end
+end

data/lib/lifx/gateway_connection.rb

@@ -0,0 +1,177 @@
+require 'lifx/observable'
+require 'lifx/timers'
+
+module LIFX
+  # @api private
+  class GatewayConnection
+    # GatewayConnection handles the UDP and TCP connections to the gateway
+    # A GatewayConnection is created when a new device sends a StatePanGateway
+    include Timers
+    include Logging
+    include Observable
+
+    MAX_TCP_ATTEMPTS = 3
+    def initialize
+      @threads = []
+      @tcp_attempts = 0
+      @threads << initialize_write_queue
+    end
+
+    def handle_message(message, ip, transport)
+      payload = message.payload
+      case payload
+      when Protocol::Device::StatePanGateway
+        if use_udp? && !udp_connected? && payload.service == Protocol::Device::Service::UDP
+          # UDP transport here is only for sending directly to bulb
+          # We receive responses via UDP transport listening to broadcast in Network
+          connect_udp(ip, payload.port.to_i)
+        elsif use_tcp? && !tcp_connected? && payload.service == Protocol::Device::Service::TCP && (port = payload.port.snapshot) > 0
+          connect_tcp(ip, port)
+        end
+      else
+        logger.error("#{self}: Unhandled message: #{message}")
+      end
+    end
+
+    def use_udp?
+      Config.allowed_transports.include?(:udp)
+    end
+
+    def use_tcp?
+      Config.allowed_transports.include?(:tcp)
+    end
+
+    def udp_connected?
+      @udp_transport && @udp_transport.connected?
+    end
+
+    def tcp_connected?
+      @tcp_transport && @tcp_transport.connected?
+    end
+
+    def connected?
+      udp_connected? || tcp_connected?
+    end
+
+    def connect_udp(ip, port)
+      @udp_transport = Transport::UDP.new(ip, port)
+    end
+
+    def connect_tcp(ip, port)
+      if @tcp_attempts > MAX_TCP_ATTEMPTS
+        logger.info("#{self}: Ignoring TCP service of #{ip}:#{port} due to too many failed attempts.")
+        return
+      end
+      @tcp_attempts += 1
+      logger.info("#{self}: Establishing connection to #{ip}:#{port}")
+      @tcp_transport = Transport::TCP.new(ip, port)
+      @tcp_transport.add_observer(self) do |message:, ip:, transport:|
+        notify_observers(message: message, ip: ip, transport: @tcp_transport)
+      end
+      @tcp_transport.listen
+      at_exit do
+        @tcp_transport.close if @tcp_transport
+      end
+    end
+
+    def write(message)
+      @queue.push(message)
+    end
+
+    def close
+      @threads.each { |thr| Thread.kill(thr) }
+      [@tcp_transport, @udp_transport].compact.each(&:close)
+    end
+
+    def flush(timeout: nil)
+      proc = lambda do
+        while !@queue.empty?
+          sleep 0.05
+        end
+      end
+      if timeout
+        Timeout.timeout(timeout) do
+          proc.call
+        end
+      else
+        proc.call
+      end
+    end
+
+    def to_s
+      "#<LIFX::GatewayConnection tcp=#{@tcp_transport} tcp_attempts=#{@tcp_attempts} udp=#{@udp_transport}>"
+    end
+    alias_method :inspect, :to_s
+
+    def set_message_rate(rate)
+      @message_rate = rate
+    end
+    protected
+
+    MAXIMUM_QUEUE_LENGTH   = 10
+    DEFAULT_MESSAGE_RATE = 5
+    def message_rate
+      @message_rate || DEFAULT_MESSAGE_RATE
+    end
+
+    def initialize_write_queue
+      @queue = SizedQueue.new(MAXIMUM_QUEUE_LENGTH)
+      @last_write = Time.now
+      Thread.abort_on_exception = true
+      Thread.new do
+        loop do
+          if !connected?
+            sleep 0.1
+            next
+          end
+          delay = [(1.0 / message_rate) - (Time.now - @last_write), 0].max
+          logger.debug("#{self}: Sleeping for #{delay}")
+          sleep(delay)
+          message = @queue.pop
+          if !message.is_a?(Message)
+            raise ArgumentError.new("Unexpected object in message queue: #{message.inspect}")
+          end
+          if !actually_write(message)
+            logger.error("#{self}: Couldn't write, pushing back onto queue.")
+            @queue << message
+          end
+          @last_write = Time.now
+        end
+      end
+    end
+
+    def check_connections
+      if @tcp_transport && !tcp_connected?
+        @tcp_transport = nil
+        logger.info("#{self}: TCP connection dropped, clearing.")
+      end
+
+      if @udp_transport && !udp_connected?
+        @udp_transport = nil
+        logger.info("#{self}: UDP connection dropped, clearing.")
+      end
+    end
+
+    def actually_write(message)
+      check_connections
+
+      # TODO: Support force sending over UDP
+      if tcp_connected?
+        if @tcp_transport.write(message)
+          logger.debug("-> #{self} #{@tcp_transport}: #{message}")
+          return true
+        end
+      end
+
+      if udp_connected?
+        if @udp_transport.write(message)
+          logger.debug("-> #{self} #{@tcp_transport}: #{message}")
+          return true
+        end
+      end
+
+      false
+    end
+
+  end
+end