lifx-lan 0.1.0

data/lib/lifx/lan/light_collection.rb

@@ -0,0 +1,111 @@
+require 'lifx/lan/light_target'
+
+module LIFX
+  module LAN
+    # LightCollection represents a collection of {Light}s, which can either refer to
+    # all lights on a {NetworkContext}, or lights
+    class LightCollection
+      include LightTarget
+      include Enumerable
+      include RequiredKeywordArguments
+      extend Forwardable
+
+      class TagNotFound < ArgumentError; end
+
+      # Refers to {NetworkContext} the instance belongs to
+      # @return [NetworkContext]
+      attr_reader :context
+
+      # Tag of the collection. `nil` represents all lights
+      # @return [String]
+      attr_reader :tag
+
+      # Creates a {LightCollection} instance. Should not be used directly.
+      # @api private
+      # @param context: [NetworkContext] NetworkContext this collection belongs to
+      # @param tag: [String] Tag
+      def initialize(context: required!(:context), tag: nil)
+        @context = context
+        @tag = tag
+      end
+
+      # Queues a {Protocol::Payload} to be sent to bulbs in the collection
+      # @param payload [Protocol::Payload] Payload to be sent
+      # @param acknowledge: [Boolean] whether recipients should acknowledge message
+      # @param at_time: [Integer] Unix epoch in milliseconds to run the payload. Only applicable to certain payload types.
+      # @api private
+      # @return [LightCollection] self for chaining
+      def send_message(payload, acknowledge: false, at_time: nil)
+        if tag
+          context.send_message(target: Target.new(tag: tag), payload: payload, acknowledge: acknowledge, at_time: at_time)
+        else
+          context.send_message(target: Target.new(broadcast: true), payload: payload, acknowledge: acknowledge, at_time: at_time)
+        end
+        self
+      end
+
+      # Returns a {Light} with device id matching `id`
+      # @param id [String] Device ID
+      # @return [Light]
+      def with_id(id)
+        lights.find { |l| l.id == id}
+      end
+
+      # Returns a {Light} with its label matching `label`
+      # @param label [String, Regexp] Label
+      # @return [Light]
+      def with_label(label)
+        if label.is_a?(Regexp)
+          lights.find { |l| l.label(fetch: false) =~ label }
+        else
+          lights.find { |l| l.label(fetch: false) == label }
+        end
+      end
+
+      # Returns a {LightCollection} of {Light}s tagged with `tag`
+      # @param tag [String] Tag
+      # @return [LightCollection]
+      def with_tag(tag)
+        if context.tags.include?(tag)
+          self.class.new(context: context, tag: tag)
+        else
+          raise TagNotFound.new("No such tag '#{tag}'")
+        end
+      end
+
+      # Returns an Array of {Light}s
+      # @return [Array<Light>]
+      def lights
+        if tag
+          context.all_lights.select { |l| l.tags.include?(tag) }
+        else
+          context.all_lights
+        end
+      end
+
+      DEFAULT_ALIVE_THRESHOLD = 30 # seconds
+      # Returns an Array of {Light}s considered alive
+      # @param threshold: The maximum number of seconds a {Light} was last seen to be considered alive
+      # @return [Array<Light>] Lights considered alive
+      def alive(threshold: DEFAULT_ALIVE_THRESHOLD)
+        lights.select { |l| l.seconds_since_seen <= threshold }
+      end
+
+      # Returns an Array of {Light}s considered stale
+      # @param threshold: The minimum number of seconds since a {Light} was last seen to be considered stale
+      # @return [Array<Light>] Lights considered stale
+      def stale(threshold: DEFAULT_ALIVE_THRESHOLD)
+        lights.select { |l| l.seconds_since_seen > threshold }
+      end
+
+      # Returns a nice string representation of itself
+      # @return [String]
+      def to_s
+        %Q{#<#{self.class.name} lights=#{lights}#{tag ? " tag=#{tag}" : ''}>}
+      end
+      alias_method :inspect, :to_s
+
+      def_delegators :lights, :empty?, :each
+    end
+  end
+end

data/lib/lifx/lan/light_target.rb

@@ -0,0 +1,185 @@
+module LIFX
+  module LAN
+    # LightTarget is a module that contains Light commands that can work
+    # with either a single {Light} or multiple Lights via a {LightCollection}
+    module LightTarget
+      MSEC_PER_SEC   = 1000
+
+      # Attempts to set the color of the light(s) to `color` asynchronously.
+      # This method cannot guarantee that the message was received.
+      # @param color [Color] The color to be set
+      # @param duration: [Numeric] Transition time in seconds
+      # @return [Light, LightCollection] self for chaining
+      def set_color(color, duration: LIFX::Config.default_duration)
+        send_message(Protocol::Light::SetColor.new(
+          color: color.to_hsbk,
+          duration: (duration * MSEC_PER_SEC).to_i,
+          stream: 0,
+        ))
+        self
+      end
+
+      # Attempts to apply a waveform to the light(s) asynchronously.
+      # @note Don't use this directly.
+      # @api private
+      def set_waveform(color, waveform: required!(:waveform),
+                              cycles: required!(:cycles),
+                              stream: 0,
+                              transient: true,
+                              period: 1.0,
+                              skew_ratio: 0.5,
+                              acknowledge: false)
+        send_message(Protocol::Light::SetWaveform.new(
+          color: color.to_hsbk,
+          waveform: waveform,
+          cycles: cycles,
+          stream: stream,
+          transient: transient,
+          period: (period * 1_000).to_i,
+          skew_ratio: (skew_ratio * 65535).round - 32768,
+        ), acknowledge: acknowledge)
+      end
+
+      # Attempts to make the light(s) pulse `color` and then back to its original color. Asynchronous.
+      # @param color [Color] Color to pulse
+      # @param duty_cycle: [Float] Ratio of a cycle the light(s) is set to `color`
+      # @param cycles: [Integer] Number of cycles
+      # @param transient: [Boolean] If false, the light will remain at the color the waveform is at when it ends
+      # @param period: [Integer] Number of seconds a cycle. Must be above 1.0 (?)
+      # @param stream: [Integer] Unused
+      def pulse(color, cycles: 1,
+                       duty_cycle: 0.5,
+                       transient: true,
+                       period: 1.0,
+                       stream: 0)
+        set_waveform(color, waveform: Protocol::Light::Waveform::PULSE,
+                            cycles: cycles,
+                            skew_ratio: 1 - duty_cycle,
+                            stream: stream,
+                            transient: transient,
+                            period: period)
+      end
+
+      # Attempts to make the light(s) transition to `color` and back in a smooth sine wave. Asynchronous.
+      # @param color [Color] Color
+      # @param cycles: [Integer] Number of cycles
+      # @param peak: [Float] Defines the peak point of the wave. Defaults to 0.5 which is a standard sine
+      # @param transient: [Boolean] If false, the light will remain at the color the waveform is at when it ends
+      # @param period: [Integer] Number of seconds a cycle. Must be above 1.0 (?)
+      # @param stream: [Integer] Unused
+      def sine(color, cycles: 1,
+                      period: 1.0,
+                      peak: 0.5,
+                      transient: true,
+                      stream: 0)
+        set_waveform(color, waveform: Protocol::Light::Waveform::SINE,
+                            cycles: cycles,
+                            skew_ratio: peak,
+                            stream: stream,
+                            transient: transient,
+                            period: period)
+      end
+
+      # Attempts to make the light(s) transition to `color` smoothly, then immediately back to its original color. Asynchronous.
+      # @param color [Color] Color
+      # @param cycles: [Integer] Number of cycles
+      # @param transient: [Boolean] If false, the light will remain at the color the waveform is at when it ends
+      # @param period: [Integer] Number of seconds a cycle. Must be above 1.0 (?)
+      # @param stream: [Integer] Unused
+      def half_sine(color, cycles: 1,
+                           period: 1.0,
+                           transient: true,
+                           stream: 0)
+        set_waveform(color, waveform: Protocol::Light::Waveform::HALF_SINE,
+                            cycles: cycles,
+                            stream: stream,
+                            transient: transient,
+                            period: period)
+      end
+
+      # Attempts to make the light(s) transition to `color` linearly and back. Asynchronous.
+      # @param color [Color] Color to pulse
+      # @param cycles: [Integer] Number of cycles
+      # @param transient: [Boolean] If false, the light will remain at the color the waveform is at when it ends
+      # @param period: [Integer] Number of seconds a cycle. Must be above 1.0 (?)
+      # @param stream: [Integer] Unused
+      def triangle(color, cycles: 1,
+                       period: 1.0,
+                       peak: 0.5,
+                       transient: true,
+                       stream: 0)
+        set_waveform(color, waveform: Protocol::Light::Waveform::TRIANGLE,
+                            cycles: cycles,
+                            skew_ratio: peak,
+                            stream: stream,
+                            transient: transient,
+                            period: period)
+      end
+
+      # Attempts to make the light(s) transition to `color` linearly, then instantly back. Asynchronous.
+      # @param color [Color] Color to saw wave
+      # @param cycles: [Integer] Number of cycles
+      # @param transient: [Boolean] If false, the light will remain at the color the waveform is at when it ends
+      # @param period: [Integer] Number of seconds a cycle. Must be above 1.0 (?)
+      # @param stream: [Integer] Unused
+      def saw(color, cycles: 1,
+                     period: 1.0,
+                     transient: true,
+                     stream: 0)
+        set_waveform(color, waveform: Protocol::Light::Waveform::SAW,
+                            cycles: cycles,
+                            stream: stream,
+                            transient: transient,
+                            period: period)
+      end
+
+      # Attempts to set the power state to `state` asynchronously.
+      # This method cannot guarantee the message was received.
+      # @param state [:on, :off]
+      # @return [Light, LightCollection] self for chaining
+      def set_power(state)
+        level = case state
+        when :on
+          1
+        when :off
+          0
+        else
+          raise ArgumentError.new("Must pass in either :on or :off")
+        end
+        send_message(Protocol::Device::SetPower.new(level: level))
+        self
+      end
+
+      # Attempts to turn the light(s) on asynchronously.
+      # This method cannot guarantee the message was received.
+      # @return [Light, LightCollection] self for chaining
+      def turn_on
+        set_power(:on)
+      end
+
+      # Attempts to turn the light(s) off asynchronously.
+      # This method cannot guarantee the message was received.
+      # @return [Light, LightCollection] self for chaining
+      def turn_off
+        set_power(:off)
+      end
+
+      # Requests light(s) to report their state
+      # This method cannot guarantee the message was received.
+      # @return [Light, LightCollection] self for chaining
+      def refresh
+        send_message(Protocol::Light::Get.new)
+        self
+      end
+
+      NSEC_IN_SEC = 1_000_000_000
+      # Attempts to set the device time on the targets
+      # @api private
+      # @param time [Time] The time to set
+      # @return [void]
+      def set_time(time = Time.now)
+        send_message(Protocol::Device::SetTime.new(time: (time.to_f * NSEC_IN_SEC).round))
+      end
+    end
+  end
+end

data/lib/lifx/lan/logging.rb

@@ -0,0 +1,14 @@
+module LIFX
+  module LAN
+    # @private
+    module Logging
+      def self.included(mod)
+        mod.extend(self)
+      end
+
+      def logger
+        LIFX::LAN::Config.logger
+      end
+    end
+  end
+end

data/lib/lifx/lan/message.rb

@@ -0,0 +1,168 @@
+require 'forwardable'
+require 'lifx/lan/protocol_path'
+
+module LIFX
+  module LAN
+    # @api private
+    class Message
+      include Logging
+      extend Forwardable
+
+      class MessageError < StandardError; end
+      class UnpackError < MessageError; end
+      class PackError < MessageError; end
+
+      class InvalidFrame < UnpackError; end
+      class UnsupportedProtocolVersion < UnpackError; end
+      class NotAddressableFrame < UnpackError; end
+      class NoPayload < PackError; end
+      class UnmappedPayload < MessageError; end
+      class InvalidFields < PackError; end
+
+      PROTOCOL_VERSION = 1024
+
+      class << self
+        def unpack(data)
+          raise InvalidFrame if data.length < 2
+
+          header = Protocol::Header.read(data)
+          raise UnsupportedProtocolVersion.new("Expected #{PROTOCOL_VERSION} but got #{header.protocol} instead") if header.protocol != PROTOCOL_VERSION
+          raise NotAddressableFrame if header.addressable == 0
+
+          message = Protocol::Message.read(data)
+          path = ProtocolPath.new(raw_site: message.raw_site, raw_target: message.raw_target, tagged: message.tagged)
+          payload_class = message_type_for_id(message.type_.snapshot)
+          if payload_class.nil?
+            if Config.log_invalid_messages
+              logger.error("Message.unpack: Unrecognised payload ID: #{message.type_}")
+              logger.error("Message.unpack: Message: #{message}")
+            end
+            return nil # FIXME
+            raise UnmappedPayload.new("Unrecognised payload ID: #{message.type_}")
+          end
+          begin
+            payload = payload_class.read(message.payload)
+          rescue => ex
+            if message.raw_site == "\x00" * 6
+              logger.info("Message.unpack: Ignoring malformed message from virgin bulb")
+            else
+              if Config.log_invalid_messages
+                logger.error("Message.unpack: Exception while unpacking payload of type #{payload_class}: #{ex}")
+                logger.error("Message.unpack: Data: #{data.inspect}")
+              end
+            end
+          end
+          new(path, message, payload)
+        rescue => ex
+          if Config.log_invalid_messages
+            logger.debug("Message.unpack: Exception while unpacking #{data.inspect}")
+            logger.debug("Message.unpack: #{ex} - #{ex.backtrace.join("\n")}")
+          end
+          raise ex
+        end
+
+        def message_type_for_id(type_id)
+          Protocol::TYPE_ID_TO_CLASS[type_id]
+        end
+
+        def type_id_for_message_class(klass)
+          Protocol::CLASS_TO_TYPE_ID[klass]
+        end
+
+        def valid_fields
+          @valid_fields ||= Protocol::Message.new.field_names.map(&:to_sym)
+        end
+      end
+
+      LIFX::LAN::Protocol::Message.fields.each do |field|
+        define_method(field.name) do
+          @message.send(field.name).snapshot
+        end
+
+        define_method("#{field.name}=") do |value|
+          @message.send("#{field.name}=", value)
+        end
+      end
+
+      alias_method :tagged?, :tagged
+      alias_method :addressable?, :addressable
+
+      def_delegators :path, :device_id, :site_id, :tagged
+
+      attr_accessor :path, :payload
+      def initialize(*args)
+        if args.count == 3
+          @path, @message, @payload = args
+        elsif (hash = args.first).is_a?(Hash)
+          path = hash.delete(:path) || ProtocolPath.new
+          payload = hash.delete(:payload)
+
+          check_valid_fields!(hash)
+
+          @message = Protocol::Message.new(hash)
+          self.payload = payload
+          self.path = path
+          @message.tagged = path.tagged? if path
+        else
+          @message = Protocol::Message.new
+        end
+        @message.msg_size = @message.num_bytes
+        @message.protocol = PROTOCOL_VERSION
+      rescue => ex
+        raise MessageError.new("Unable to initialize message with args: #{args.inspect} - #{ex}")
+      end
+
+      def payload=(payload)
+        @payload = payload
+        type_id = self.class.type_id_for_message_class(payload.class)
+        if type_id.nil?
+          raise UnmappedPayload.new("Unmapped payload class #{payload.class}")
+        end
+        @message.type_ = type_id
+        @message.payload = payload.pack
+      end
+
+      def pack
+        raise NoPayload if !payload
+        @message.raw_site = path.raw_site
+        @message.raw_target = path.raw_target
+        @message.tagged = path.tagged?
+        @message.msg_size = @message.num_bytes
+        @message.pack
+      end
+
+      def to_s
+        hash = {site: path.site_id}
+        if path.tagged?
+          hash[:tags] = path.tag_ids
+          hash[:tags] = 'all' if hash[:tags].empty?
+        else
+          hash[:device] = path.device_id
+        end
+        hash[:type_] = payload.class.to_s.sub('LIFX::Protocol::', '')
+        hash[:addressable] = addressable? ? 'true' : 'false'
+        hash[:tagged] = path.tagged? ? 'true' : 'false'
+        hash[:at_time] = @message.at_time if @message.at_time && @message.at_time > 0
+        hash[:protocol] = protocol
+        hash[:payload] = payload.snapshot if payload
+        attrs = hash.map { |k, v| "#{k}=#{v}" }.join(' ')
+        %Q{#<LIFX::LAN::Message #{attrs}>}
+      end
+
+      def to_hex
+        pack.each_byte.map { |b| b.to_s(16).rjust(2, '0') }.join
+      end
+
+      alias_method :inspect, :to_s
+
+      protected
+
+      def check_valid_fields!(hash)
+        invalid_fields = hash.keys - self.class.valid_fields
+        if invalid_fields.count > 0
+          raise InvalidFields.new("Invalid fields for Message: #{invalid_fields.join(', ')}")
+        end
+      end
+    end
+  end
+end