wizrb 1.1.1 → 1.1.2

data/lib/wizrb/lighting/events/set_rgb_event.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative '../../shared/events/base'
+
+module Wizrb
+  module Lighting
+    module Events
+      class SetRgbEvent < Wizrb::Shared::Events::Base
+        MIN_VALUE = 1
+        MAX_VALUE = 255
+
+        def initialize(red, green, blue)
+          validate_color!('Red', red)
+          validate_color!('Green', green)
+          validate_color!('Blue', blue)
+          super(method: 'setState', params: { r: red, g: green, b: blue })
+        end
+
+        private
+
+        def validate_color!(color, value)
+          return if value && value >= MIN_VALUE && value <= MAX_VALUE
+
+          raise ArgumentError, "#{color} must be between #{MIN_VALUE} and #{MAX_VALUE}"
+        end
+      end
+    end
+  end
+end

data/lib/wizrb/lighting/events/set_scene_event.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative '../../shared/events/base'
+
+module Wizrb
+  module Lighting
+    module Events
+      class SetSceneEvent < Wizrb::Shared::Events::Base
+        def initialize(value)
+          validate!(value)
+          super(method: 'setState', params: { sceneId: Wizrb::Lighting::SCENES[value] })
+        end
+
+        private
+
+        def validate!(value)
+          raise ArgumentError, 'Invalid scene' unless Wizrb::Lighting::SCENES.include?(value)
+        end
+      end
+    end
+  end
+end

data/lib/wizrb/lighting/events/set_speed_event.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative '../../shared/events/base'
+
+module Wizrb
+  module Lighting
+    module Events
+      class SetSpeedEvent < Wizrb::Shared::Events::Base
+        MIN_VALUE = 10
+        MAX_VALUE = 200
+
+        def initialize(value)
+          validate!(value)
+          super(method: 'setState', params: { speed: value })
+        end
+
+        private
+
+        def validate!(value)
+          return if value && value >= MIN_VALUE && value <= MAX_VALUE
+
+          raise ArgumentError, "Speed must be between #{MIN_VALUE} and #{MAX_VALUE}"
+        end
+      end
+    end
+  end
+end

data/lib/wizrb/lighting/events/set_warm_white_event.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative '../../shared/events/base'
+
+module Wizrb
+  module Lighting
+    module Events
+      class SetWarmWhiteEvent < Wizrb::Shared::Events::Base
+        MIN_VALUE = 1
+        MAX_VALUE = 255
+
+        def initialize(value)
+          validate!(value)
+          super(method: 'setState', params: { w: value })
+        end
+
+        private
+
+        def validate!(value)
+          return if value && value >= MIN_VALUE && value <= MAX_VALUE
+
+          raise ArgumentError, "Warm white must be between #{MIN_VALUE} and #{MAX_VALUE}"
+        end
+      end
+    end
+  end
+end

data/lib/wizrb/lighting/group.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative '../shared/group'
+
+module Wizrb
+  module Lighting
+    class Group < Wizrb::Shared::Group
+      def brightness(value)
+        dispatch_event(Wizrb::Lighting::Events::SetBrightnessEvent.new(value))
+      end
+
+      def cold_white(value)
+        dispatch_event(Wizrb::Lighting::Events::SetColdWhiteEvent.new(value))
+      end
+
+      def color_temp(value)
+        dispatch_event(Wizrb::Lighting::Events::SetColorTempEvent.new(value))
+      end
+
+      def rgb(red, green, blue)
+        dispatch_event(Wizrb::Lighting::Events::SetRgbEvent.new(red, green, blue))
+      end
+
+      def speed(value)
+        dispatch_event(Wizrb::Lighting::Events::SetSpeedEvent.new(value))
+      end
+
+      def warm_white(value)
+        dispatch_event(Wizrb::Lighting::Events::SetWarmWhiteEvent.new(value))
+      end
+
+      def scene(value)
+        dispatch_event(Wizrb::Lighting::Events::SetSceneEvent.new(value))
+      end
+    end
+  end
+end

data/lib/wizrb/lighting/products/dimable_light.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'light'
+
+module Wizrb
+  module Lighting
+    module Products
+      class DimableLight < Wizrb::Lighting::Products::Light
+        MODULE_NAME_IDENTIFIER = 'DW'
+        FEATURES = {
+          brightness: true,
+          color_temp: false,
+          color: false,
+          effect: false,
+          scenes: %i[
+            wake_up
+            bedtime
+            cool_white
+            night_light
+            candlelight
+            golden_white
+            pulse
+            steampunk
+          ]
+        }.freeze
+
+        def initialize(ip:, port: 38_899)
+          super
+        end
+      end
+    end
+  end
+end

data/lib/wizrb/lighting/products/light.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'socket'
+require_relative '../../shared/products/device'
+require_relative '../state'
+
+module Wizrb
+  module Lighting
+    module Products
+      class Light < Wizrb::Shared::Products::Device
+        def initialize(ip:, port: 38_899)
+          super(ip: ip, port: port, state: Wizrb::Lighting::State.new)
+        end
+
+        def white_range
+          @white_range ||=
+            user_config&.dig('whiteRange') ||
+            model_config&.dig('extRange') ||
+            model_config&.dig('cctRange') ||
+            user_config&.dig('extRange') ||
+            user_config&.dig('cctRange')
+        end
+
+        def brightness(value)
+          dispatch_event(Wizrb::Lighting::Events::SetBrightnessEvent.new(value))
+        end
+
+        def cold_white(value)
+          dispatch_event(Wizrb::Lighting::Events::SetColdWhiteEvent.new(value))
+        end
+
+        def color_temp(value)
+          dispatch_event(Wizrb::Lighting::Events::SetColorTempEvent.new(value))
+        end
+
+        def rgb(red, green, blue)
+          dispatch_event(Wizrb::Lighting::Events::SetRgbEvent.new(red, green, blue))
+        end
+
+        def speed(value)
+          dispatch_event(Wizrb::Lighting::Events::SetSpeedEvent.new(value))
+        end
+
+        def warm_white(value)
+          dispatch_event(Wizrb::Lighting::Events::SetWarmWhiteEvent.new(value))
+        end
+
+        def scene(value)
+          dispatch_event(Wizrb::Lighting::Events::SetSceneEvent.new(value))
+        end
+      end
+    end
+  end
+end

data/lib/wizrb/lighting/products/rgb_light.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative 'light'
+
+module Wizrb
+  module Lighting
+    module Products
+      class RgbLight < Wizrb::Lighting::Products::Light
+        MODULE_NAME_IDENTIFIER = 'RGB'
+        FEATURES = {
+          brightness: true,
+          color_temp: true,
+          color: true,
+          effect: true,
+          scenes: %i[
+            ocean
+            romance
+            sunset
+            party
+            fireplace
+            cozy
+            forest
+            pastel_colors
+            wake_up
+            bedtime
+            warm_white
+            daylight
+            cool_white
+            night_light
+            focus
+            relax
+            true_colors
+            tv_time
+            plantgrowth
+            spring
+            summer
+            fall
+            deepdive
+            jungle
+            mojito
+            club
+            christmas
+            halloween
+            candlelight
+            golden_white
+            pulse
+            steampunk
+            rhythm
+          ]
+        }.freeze
+
+        def initialize(ip:, port: 38_899)
+          super
+        end
+      end
+    end
+  end
+end

data/lib/wizrb/lighting/products/tunable_light.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative 'light'
+
+module Wizrb
+  module Lighting
+    module Products
+      class TunableLight < Wizrb::Lighting::Products::Light
+        MODULE_NAME_IDENTIFIER = 'TW'
+        FEATURES = {
+          brightness: true,
+          color_temp: true,
+          color: false,
+          effect: true,
+          scenes: %i[
+            cozy
+            wake_up
+            bedtime
+            warm_white
+            daylight
+            cool_white
+            night_light
+            focus
+            relax
+            tv_time
+            candlelight
+            golden_white
+            pulse
+            steampunk
+          ]
+        }.freeze
+
+        def initialize(ip:, port: 38_899)
+          super
+        end
+      end
+    end
+  end
+end

data/lib/wizrb/lighting/scenes/scene.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative '../group'
+
+module Wizrb
+  module Lighting
+    module Scenes
+      class Scene
+        def initialize(group, stop_delay: 1, save: true)
+          validate!(group)
+          @group = group
+          @stop_delay = stop_delay
+          @save = save
+          @running = false
+          @thread = nil
+        end
+
+        def start
+          @running = true
+          @thread = Thread.new do
+            save_state if @save
+            before_start
+            step while @running
+            after_stop
+          ensure
+            restore_state if @save
+          end
+        end
+
+        def stop
+          @running = false
+          sleep(@stop_delay)
+          @thread.terminate
+        end
+
+        protected
+
+        def before_start; end
+
+        def step
+          raise Wizrb::Error, 'You failed to implement #step on your scene'
+        end
+
+        def after_stop; end
+
+        private
+
+        def validate!(value)
+          return if value.is_a?(Wizrb::Lighting::Group)
+
+          raise Wizrb::Error, 'Scenes can only be activated on lighting groups'
+        end
+
+        def save_state
+          @state_events = @group.map do |device|
+            Wizrb::Shared::Events::Base.new(method: 'setState', params: device.refresh.state)
+          end
+        end
+
+        def restore_state
+          @group.each_with_index do |device, i|
+            device.dispatch_event(@state_events[i])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wizrb/lighting/scenes/spooky_scene.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative 'scene'
+
+module Wizrb
+  module Lighting
+    module Scenes
+      class SpookyScene < Wizrb::Lighting::Scenes::Scene
+        DEFAULT_STATE_EVENTS = [
+          Wizrb::Shared::Events::PowerEvent.new(true),
+          Wizrb::Lighting::Events::SetSpeedEvent.new(200),
+          Wizrb::Lighting::Events::SetColorTempEvent.new(1000),
+          Wizrb::Lighting::Events::SetBrightnessEvent.new(100)
+        ].freeze
+
+        BLACKOUT_EVENTS = [
+          Wizrb::Shared::Events::PowerEvent.new(false)
+        ].freeze
+
+        def initialize(group, sync: false)
+          @sync = sync
+          super(group, stop_delay: 10)
+        end
+
+        protected
+
+        def before_start
+          dispatch(DEFAULT_STATE_EVENTS, sync: true)
+        end
+
+        def step
+          if Random.rand > 0.5
+            Random.rand(1..10).times do
+              next if Random.rand > 0.25
+
+              dispatch(BLACKOUT_EVENTS, sync: @sync)
+              sleep(Random.rand > 0.98 ? 3 : 0.125)
+              dispatch(DEFAULT_STATE_EVENTS, sync: true)
+            end
+          end
+
+          sleep(Random.rand(0.125..5.0))
+        end
+
+        def after_stop
+          dispatch(DEFAULT_STATE_EVENTS, sync: true)
+        end
+
+        private
+
+        def dispatch(events, sync: false)
+          if sync || Random.rand > 0.5
+            @group.dispatch_events(*events)
+          else
+            @group.devices.sample.dispatch_events(*events)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wizrb/lighting/state.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Wizrb
+  module Lighting
+    class State < Wizrb::Shared::State
+      STATE_KEYS = %i[state w c r g b temp dimming speed sceneId].freeze
+
+      def parse!(response)
+        result = response&.dig('result')
+        return unless result
+
+        @state = result.transform_keys(&:to_sym).slice(*STATE_KEYS)
+        @state.delete(:sceneId) if @state[:sceneId]&.zero?
+      end
+
+      def warm_white
+        @state[:w]
+      end
+
+      def cold_white
+        @state[:c]
+      end
+
+      def rgb
+        { red: @state[:r], green: @state[:g], blue: @state[:b] }
+      end
+
+      def color_temp
+        @state[:temp]
+      end
+
+      def brightness
+        @state[:dimming]
+      end
+
+      def speed
+        @state[:speed]
+      end
+
+      def scene
+        Wizrb::Lighting::SCENES.key(@state[:schdPsetId] || @state[:sceneId])
+      end
+    end
+  end
+end

data/lib/wizrb/lighting.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Wizrb
+  module Lighting
+    SCENES = {
+      ocean: 1,
+      romance: 2,
+      sunset: 3,
+      party: 4,
+      fireplace: 5,
+      cozy: 6,
+      forest: 7,
+      pastel_colors: 8,
+      wake_up: 9,
+      bedtime: 10,
+      warm_white: 11,
+      daylight: 12,
+      cool_white: 13,
+      night_light: 14,
+      focus: 15,
+      relax: 16,
+      true_colors: 17,
+      tv_time: 18,
+      plantgrowth: 19,
+      spring: 20,
+      summer: 21,
+      fall: 22,
+      deepdive: 23,
+      jungle: 24,
+      mojito: 25,
+      club: 26,
+      christmas: 27,
+      halloween: 28,
+      candlelight: 29,
+      golden_white: 30,
+      pulse: 31,
+      steampunk: 32,
+      rhythm: 1000
+    }.freeze
+  end
+end

data/lib/wizrb/power/discover.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative '../shared/discover'
+require_relative 'group'
+require_relative 'products/smart_plug'
+
+module Wizrb
+  module Power
+    class Discover < Wizrb::Shared::Discover
+      private
+
+      def parse_response(data, addr)
+        response = JSON.parse(data)
+        return unless response.dig('result', 'success') && addr[1] && addr[2]
+
+        resolve_device(ip: addr[2], port: addr[1])
+      rescue StandardError
+        nil
+      end
+
+      def resolve_device(ip:, port: 38_899)
+        module_name = Wizrb::Shared::Products::Device.new(ip: ip, port: port).module_name
+
+        return unless module_name.include?(Wizrb::Power::Products::SmartPlug::MODULE_NAME_IDENTIFIER)
+
+        Wizrb::Power::Products::SmartPlug.new(ip: ip, port: port)
+      end
+
+      def group_devices
+        Wizrb::Power::Group.new(devices: @devices)
+      end
+    end
+  end
+end

data/lib/wizrb/power/group.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative '../shared/group'
+
+module Wizrb
+  module Power
+    class Group < Wizrb::Shared::Group
+    end
+  end
+end

data/lib/wizrb/power/products/smart_plug.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative '../../shared/products/device'
+
+module Wizrb
+  module Power
+    module Products
+      class SmartPlug < Wizrb::Shared::Products::Device
+        MODULE_NAME_IDENTIFIER = 'SOCKET'
+
+        def initialize(ip:, port: 38_899)
+          super
+        end
+      end
+    end
+  end
+end

data/lib/wizrb/shared/connection.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'socket'
+
+module Wizrb
+  module Shared
+    class Connection
+      attr_reader :ip, :port, :connection_id, :socket
+
+      def initialize(ip, port)
+        @ip = ip
+        @port = port
+        @connection_id = Time.now.to_i.to_s(16)
+        @socket = UDPSocket.new
+        log('Created')
+      end
+
+      def connect
+        with_error_logging do
+          socket.connect(ip, port)
+          log('Connected')
+        end
+      end
+
+      def send(data)
+        with_error_logging do
+          connect
+          log("Sending: #{data.to_json}")
+          socket.send(data.to_json.encode('UTF-8'), 0)
+        end
+      end
+
+      def receive(timeout: 2, max: 1024)
+        with_error_logging do
+          connect
+
+          ready = socket.wait_readable(timeout)
+          raise Wizrb::ConnectionTimeoutError unless ready
+
+          data, _addr = socket.recvfrom(max)
+          log("Received: #{data}")
+          parse_response(data)
+        end
+      end
+
+      def test
+        with_error_logging do
+          send({ method: 'getPilot', params: {} })
+          receive
+        end
+      end
+
+      private
+
+      def parse_response(data)
+        response = JSON.parse(data)
+
+        raise Wizrb::ConnectionError, response['error'] if response.key?('error')
+
+        response
+      end
+
+      def log(message)
+        puts "[Wizrb::Connection##{connection_id} #{ip}:#{port}] #{message}" if ENV['DEBUG']
+      end
+
+      def with_error_logging
+        yield
+      rescue StandardError => e
+        log("Error: #{e.message}")
+        raise
+      end
+    end
+  end
+end