ewelink 1.0.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 344143666abe75f11d9d3ccdb49116b6ded1579a609820dac2b26f97de27dcac
-  data.tar.gz: 05fcfdaa151396125266d0125d3e28124eaae6da5a607a531a4729a937425902
+  metadata.gz: 2c58323e838b9fbbdca7c7ee0fdf22d1e7950c627fb4fcf8851b3263e69ce883
+  data.tar.gz: 475d05f731b079f7734fde4dd93ec8f151077d6e5b716a86e611f11bdbb8d49b
 SHA512:
-  metadata.gz: b83fe71850b9c0b1595df52687082452e3c8e0da75c896027d472fbfd1df2dc0c3688181f242db506b76bb415aee6a8f60055e51c8af8963c7062ce2e2a27996
-  data.tar.gz: 84577222fc03a3a20cb08eb5a8ad3243635b2694d33b4bee9bb52582bf9cc4ea8e2e404a7315206adf2bbce3e8ffdbb2b12792decf6ad24f17a844d4a24a6126
+  metadata.gz: 50ba5474e9012f219e380c47515d599da29a72b50cc26c36a19e253623c997e429a32c1b279619eef0e2d8b7f454fccde519500f998575c38d028ac86e6c1ba4
+  data.tar.gz: 122f2997897893b395cd04204e3e169d90bac15fc1a9eaabbf31def8da1c7f754bd502341411727364a79011379791a89031e9d42090d22bf96be233a24a5958

data/README.mdown

@@ -40,24 +40,30 @@ api.rf_bridge_buttons.each do |button|
 end
 ```
 
-### Set switch on or off
+### Turn switch on or off
 
 ```ruby
 require 'ewelink'
 
 api = Ewelink::Api.new(phone_number: '+687 414243', password: 'secr$t')
-api.switch_on!(switch[:uuid])
-api.switch_off!(switch[:uuid])
+api.turn_switch!(switch[:uuid], :on)
+api.turn_switch!(switch[:uuid], :off)
 ```
 
-### Check if switch is on or off
+Or :
+
+```ruby
+api.turn_switch!(switch[:uuid], true)
+api.turn_switch!(switch[:uuid], false)
+```
+
+### Check if switch is on
 
 ```ruby
 require 'ewelink'
 
 api = Ewelink::Api.new(phone_number: '+687 414243', password: 'secr$t')
 puts api.switch_on?(switch[:uuid])
-puts api.switch_off?(switch[:uuid])
 ```
 
 ### Press RF bridge button

data/VERSION

@@ -1 +1 @@
-1.0.1
+2.1.0

data/ewelink.gemspec

@@ -17,6 +17,7 @@ Gem::Specification.new do |s|
 
   s.add_dependency 'activesupport', '>= 6.0.0', '< 7.0.0'
   s.add_dependency 'httparty', '>= 0.18.0', '< 0.19.0'
+  s.add_dependency 'websocket-client-simple', '>= 0.3.0', '< 0.4.0'
 
   s.add_development_dependency 'byebug', '>= 11.0.0', '< 12.0.0'
   s.add_development_dependency 'rake', '>= 12.0.0', '< 13.0.0'

data/lib/ewelink.rb

@@ -7,6 +7,9 @@ require 'json'
 require 'logger'
 require 'openssl'
 require 'optparse'
+require 'set'
+require 'timeout'
+require 'websocket-client-simple'
 
 module Ewelink
 

data/lib/ewelink/api.rb

@@ -7,10 +7,12 @@ module Ewelink
     DEFAULT_REGION = 'us'
     RF_BRIDGE_DEVICE_UIID = 28
     SWITCH_DEVICES_UIIDS = [1, 5, 6, 24]
-    TIMEOUT = 10
+    TIMEOUT = 10.seconds
     URL = 'https://#{region}-api.coolkit.cc:8080'
     UUID_NAMESPACE = 'e25750fb-3710-41af-b831-23224f4dd609';
     VERSION = 8
+    WEB_SOCKET_PING_TOLERANCE_FACTOR = 1.5
+    WEB_SOCKET_WAIT_INTERVAL = 0.2.seconds
 
     attr_reader :email, :password, :phone_number
 
@@ -19,107 +21,162 @@ module Ewelink
       @mutexs = {}
       @password = password.presence || raise(Error.new(":password must be specified"))
       @phone_number = phone_number.presence.try(:strip)
+      @switches_statuses = {}
+      @web_socket_authenticated_api_keys = Set.new
       raise(Error.new(":email or :phone_number must be specified")) if email.blank? && phone_number.blank?
     end
 
     def press_rf_bridge_button!(uuid)
-      button = find_rf_bridge_button!(uuid)
-      params = {
-        'appid' => APP_ID,
-        'deviceid' => button[:device_id],
-        'nonce' => nonce,
-        'params' => {
-          'cmd' => 'transmit',
-          'rfChl' => button[:channel],
-        },
-        'ts' => Time.now.to_i,
-        'version' => VERSION,
-      }
-      http_request(:post, '/api/user/device/status', body: JSON.generate(params), headers: authentication_headers)
-      true
+      synchronize(:press_rf_bridge_button) do
+        button = find_rf_bridge_button!(uuid)
+        web_socket_wait_for(-> { web_socket_authenticated? }) do
+          params = {
+            'action' => 'update',
+            'apikey' => button[:api_key],
+            'deviceid' => button[:device_id],
+            'params' => {
+              'cmd' => 'transmit',
+              'rfChl' => button[:channel],
+            },
+            'sequence' => web_socket_sequence,
+            'ts' => 0,
+            'userAgent' => 'app',
+          }
+          Ewelink.logger.debug(self.class.name) { "Pressing RF bridge button #{button[:uuid].inspect}" }
+          send_to_web_socket(JSON.generate(params))
+          true
+        end
+      end
     end
 
     def reload
-      Ewelink.logger.debug(self.class.name) { 'Reloading API (authentication token, devices & region cache)' }
-      [:@authentication_token, :@devices, :@rf_bridge_buttons, :@region, :@switches].each do |variable|
+      Ewelink.logger.debug(self.class.name) { 'Reloading API (authentication token, devices, region, connections,...)' }
+      dispose_web_socket
+      @switches_statuses.clear
+      [
+        :@api_keys,
+        :@authentication_token,
+        :@devices,
+        :@region,
+        :@rf_bridge_buttons,
+        :@switches,
+      ].each do |variable|
         remove_instance_variable(variable) if instance_variable_defined?(variable)
       end
       self
     end
 
     def rf_bridge_buttons
-      @rf_bridge_buttons ||= [].tap do |buttons|
-        rf_bridge_devices = devices.select { |device| device['uiid'] == RF_BRIDGE_DEVICE_UIID }.tap do |devices|
-          Ewelink.logger.debug(self.class.name) { "Found #{devices.size} RF 433MHz Bridge device(s)" }
-        end
-        rf_bridge_devices.each do |device|
-          device_id = device['deviceid'].presence || next
-          device_name = device['name'].presence || next
-          buttons = device['params']['rfList'].each do |rf|
-            button = {
-              channel: rf['rfChl'],
-              device_id: device_id,
-              device_name: device_name,
-            }
-            remote_info = device['tags']['zyx_info'].find { |info| info['buttonName'].find { |data| data.key?(button[:channel].to_s) } }.presence || next
-            remote_name = remote_info['name'].try(:squish).presence || next
-            button_info = remote_info['buttonName'].find { |info| info.key?(button[:channel].to_s) }.presence || next
-            button_name = button_info.values.first.try(:squish).presence || next
-            button.merge!({
-              name: button_name,
-              remote_name: remote_name,
-              remote_type: remote_info['remote_type'],
-            })
-            button[:uuid] = Digest::UUID.uuid_v5(UUID_NAMESPACE, "#{button[:device_id]}/#{button[:channel]}")
-            buttons << button
+      synchronize(:rf_bridge_buttons) do
+        @rf_bridge_buttons ||= [].tap do |buttons|
+          rf_bridge_devices = devices.select { |device| device['uiid'] == RF_BRIDGE_DEVICE_UIID }.tap do |devices|
+            Ewelink.logger.debug(self.class.name) { "Found #{devices.size} RF 433MHz bridge device(s)" }
           end
-        end
-      end.tap { |buttons| Ewelink.logger.debug(self.class.name) { "Found #{buttons.size} RF 433MHz bridge button(s)" } }
-    end
-
-    def switch_off!(uuid)
-      update_switch_on!(uuid, false)
-    end
-
-    def switch_off?(uuid)
-      !switch_on?(uuid)
-    end
-
-    def switch_on!(uuid)
-      update_switch_on!(uuid, true)
+          rf_bridge_devices.each do |device|
+            api_key = device['apikey'].presence || next
+            device_id = device['deviceid'].presence || next
+            device_name = device['name'].presence || next
+            buttons = device['params']['rfList'].each do |rf|
+              button = {
+                api_key: api_key,
+                channel: rf['rfChl'],
+                device_id: device_id,
+                device_name: device_name,
+              }
+              remote_info = device['tags']['zyx_info'].find { |info| info['buttonName'].find { |data| data.key?(button[:channel].to_s) } }.presence || next
+              remote_name = remote_info['name'].try(:squish).presence || next
+              button_info = remote_info['buttonName'].find { |info| info.key?(button[:channel].to_s) }.presence || next
+              button_name = button_info.values.first.try(:squish).presence || next
+              button.merge!({
+                name: button_name,
+                remote_name: remote_name,
+                remote_type: remote_info['remote_type'],
+              })
+              button[:uuid] = Digest::UUID.uuid_v5(UUID_NAMESPACE, "#{button[:device_id]}/#{button[:channel]}")
+              buttons << button
+            end
+          end
+        end.tap { |buttons| Ewelink.logger.debug(self.class.name) { "Found #{buttons.size} RF 433MHz bridge button(s)" } }
+      end
     end
 
     def switch_on?(uuid)
       switch = find_switch!(uuid)
-      params = {
-        'appid' => APP_ID,
-        'deviceid' => switch[:device_id],
-        'nonce' => nonce,
-        'ts' => Time.now.to_i,
-        'version' => VERSION,
-      }
-      response = http_request(:get, '/api/user/device/status', headers: authentication_headers, query: params)
-      response['params']['switch'] == 'on'
+      if @switches_statuses[switch[:uuid]].nil?
+        params = {
+          'action' => 'query',
+          'apikey' => switch[:api_key],
+          'deviceid' => switch[:device_id],
+          'sequence' => web_socket_sequence,
+          'ts' => 0,
+          'userAgent' => 'app',
+        }
+        web_socket_wait_for(-> { web_socket_authenticated? }) do
+          Ewelink.logger.debug(self.class.name) { "Checking switch #{switch[:uuid].inspect} status" }
+          send_to_web_socket(JSON.generate(params))
+        end
+      end
+      web_socket_wait_for(-> { !@switches_statuses[switch[:uuid]].nil? }) do
+        Ewelink.logger.debug(self.class.name) { "Switch #{switch[:uuid].inspect} is #{@switches_statuses[switch[:uuid]]}" }
+        @switches_statuses[switch[:uuid]] == 'on'
+      end
     end
 
     def switches
-      @switches ||= [].tap do |switches|
-        switch_devices = devices.select { |device| SWITCH_DEVICES_UIIDS.include?(device['uiid']) }
-        switch_devices.each do |device|
-          device_id = device['deviceid'].presence || next
-          name = device['name'].presence || next
-          switch = {
-            device_id: device_id,
-            name: name,
-          }
-          switch[:uuid] = Digest::UUID.uuid_v5(UUID_NAMESPACE, switch[:device_id])
-          switches << switch
-        end
-      end.tap { |switches| Ewelink.logger.debug(self.class.name) { "Found #{switches.size} switch(es)" } }
+      synchronize(:switches) do
+        @switches ||= [].tap do |switches|
+          switch_devices = devices.select { |device| SWITCH_DEVICES_UIIDS.include?(device['uiid']) }
+          switch_devices.each do |device|
+            api_key = device['apikey'].presence || next
+            device_id = device['deviceid'].presence || next
+            name = device['name'].presence || next
+            switch = {
+              api_key: api_key,
+              device_id: device_id,
+              name: name,
+            }
+            switch[:uuid] = Digest::UUID.uuid_v5(UUID_NAMESPACE, switch[:device_id])
+            switches << switch
+          end
+        end.tap { |switches| Ewelink.logger.debug(self.class.name) { "Found #{switches.size} switch(es)" } }
+      end
+    end
+
+    def turn_switch!(uuid, on)
+      if ['on', :on, 'true'].include?(on)
+        on = true
+      elsif ['off', :off, 'false'].include?(on)
+        on = false
+      end
+      switch = find_switch!(uuid)
+      @switches_statuses[switch[:uuid]] = nil
+      web_socket_wait_for(-> { web_socket_authenticated? }) do
+        params = {
+          'action' => 'update',
+          'apikey' => switch[:api_key],
+          'deviceid' => switch[:device_id],
+          'params' => {
+            'switch' => on ? 'on' : 'off',
+          },
+          'sequence' => web_socket_sequence,
+          'ts' => 0,
+          'userAgent' => 'app',
+        }
+        Ewelink.logger.debug(self.class.name) { "Turning switch #{switch[:uuid].inspect} #{on ? 'on' : 'off'}" }
+        send_to_web_socket(JSON.generate(params))
+      end
+      switch_on?(switch[:uuid]) # Waiting for switch status update
+      true
     end
 
     private
 
+    def api_keys
+      synchronize(:api_keys) do
+        @api_keys ||= Set.new(devices.map { |device| device['apikey'] })
+      end
+    end
+
     def authentication_headers
       { 'Authorization' => "Bearer #{authentication_token}" }
     end
@@ -141,7 +198,7 @@ module Ewelink
             params['phoneNumber'] = phone_number
           end
           body = JSON.generate(params)
-          response = http_request(:post, '/api/user/login', { body: body, headers: { 'Authorization' => "Sign #{Base64.encode64(OpenSSL::HMAC.digest('SHA256', APP_SECRET, body))}" } })
+          response = rest_request(:post, '/api/user/login', { body: body, headers: { 'Authorization' => "Sign #{Base64.encode64(OpenSSL::HMAC.digest('SHA256', APP_SECRET, body))}" } })
           raise(Error.new('Authentication token not found')) if response['at'].blank?
           response['at'].tap { Ewelink.logger.debug(self.class.name) { 'Authentication token found' } }
         end
@@ -158,12 +215,42 @@ module Ewelink
             'ts' => Time.now.to_i,
             'version' => VERSION,
           }
-          response = http_request(:get, '/api/user/device', headers: authentication_headers, query: params)
+          response = rest_request(:get, '/api/user/device', headers: authentication_headers, query: params)
           response['devicelist'].tap { |devices| Ewelink.logger.debug(self.class.name) { "Found #{devices.size} device(s)" } }
         end
       end
     end
 
+    def dispose_web_socket
+      @web_socket_authenticated_api_keys = Set.new
+
+      if @web_socket_ping_thread
+        if Thread.current == @web_socket_ping_thread
+          Thread.current[:stop] = true
+        else
+          @web_socket_ping_thread.kill
+        end
+      end
+
+      if @web_socket.present?
+        begin
+          @web_socket.close if @web_socket.open?
+        rescue
+          # Ignoring close errors
+        end
+      end
+
+      [
+        :@last_web_socket_pong_at,
+        :@web_socket_ping_interval,
+        :@web_socket_ping_thread,
+        :@web_socket_url,
+        :@web_socket,
+      ].each do |variable|
+        remove_instance_variable(variable) if instance_variable_defined?(variable)
+      end
+    end
+
     def find_rf_bridge_button!(uuid)
       rf_bridge_buttons.find { |button| button[:uuid] == uuid } || raise(Error.new("No such RF bridge button with UUID: #{uuid.inspect}"))
     end
@@ -180,43 +267,176 @@ module Ewelink
       @region ||= DEFAULT_REGION
     end
 
-    def http_request(method, path, options = {})
+    def rest_request(method, path, options = {})
       url = "#{URL.gsub('#{region}', region)}#{path}"
       method = method.to_s.upcase
       headers = (options[:headers] || {}).reverse_merge('Content-Type' => 'application/json')
       Ewelink.logger.debug(self.class.name) { "#{method} #{url}" }
-      response = synchronize(:http_request) { HTTParty.send(method.downcase, url, options.merge(headers: headers).reverse_merge(timeout: TIMEOUT)) }
+      response = HTTParty.send(method.downcase, url, options.merge(headers: headers).reverse_merge(timeout: TIMEOUT))
       raise(Error.new("#{method} #{url}: #{response.code}")) unless response.success?
       if response['error'] == 301 && response['region'].present?
         @region = response['region']
         Ewelink.logger.debug(self.class.name) { "Switched to region #{region.inspect}" }
-        return http_request(method, path, options)
+        return rest_request(method, path, options)
       end
       remove_instance_variable(:@authentication_token) if instance_variable_defined?(:@authentication_token) && [401, 403].include?(response['error'])
       raise(Error.new("#{method} #{url}: #{response['error']} #{response['msg']}".strip)) if response['error'].present? && response['error'] != 0
-      response
+      response.to_h
     rescue Errno::ECONNREFUSED, OpenSSL::OpenSSLError, SocketError, Timeout::Error => e
       raise Error.new(e)
     end
 
+    def send_to_web_socket(data)
+      if web_socket_outdated_ping?
+        Ewelink.logger.warn(self.class.name) { 'WebSocket ping is outdated' }
+        dispose_web_socket
+      end
+      web_socket.send(data)
+    rescue
+      dispose_web_socket
+      raise
+    end
+
     def synchronize(name, &block)
       (@mutexs[name] ||= Mutex.new).synchronize(&block)
     end
 
-    def update_switch_on!(uuid, on)
-      switch = find_switch!(uuid)
-      params = {
-        'appid' => APP_ID,
-        'deviceid' => switch[:device_id],
-        'nonce' => nonce,
-        'params' => {
-          'switch' => on ? 'on' : 'off',
-        },
-        'ts' => Time.now.to_i,
-        'version' => VERSION,
-      }
-      http_request(:post, '/api/user/device/status', body: JSON.generate(params), headers: authentication_headers)
-      true
+    def web_socket
+      synchronize(:web_socket) do
+        @web_socket ||= begin
+          api = self
+
+          WebSocket::Client::Simple.connect(web_socket_url) do |web_socket|
+            Ewelink.logger.debug(self.class.name) { "Opening WebSocket to #{web_socket_url}" }
+
+            web_socket.on(:close) do
+              api.instance_eval do
+                Ewelink.logger.debug(self.class.name) { 'WebSocket closed' }
+                dispose_web_socket
+              end
+            end
+
+            web_socket.on(:error) do |e|
+              api.instance_eval do
+                Ewelink.logger.warn(self.class.name) { "WebSocket error: #{e}" }
+                dispose_web_socket
+              end
+            end
+
+            web_socket.on(:message) do |message|
+              api.instance_eval do
+                if message.data == 'pong'
+                  Ewelink.logger.debug(self.class.name) { "Received WebSocket #{message.data.inspect} message" }
+                  @last_web_socket_pong_at = Time.now
+                  next
+                end
+
+                begin
+                  response = JSON.parse(message.data)
+                rescue => e
+                  Ewelink.logger.error(self.class.name) { "WebSocket JSON parse error" }
+                  next
+                end
+
+                if response.key?('error') && response['error'] != 0
+                  Ewelink.logger.error(self.class.name) { "WebSocket message error: #{message.data}" }
+                  next
+                end
+
+                if !@web_socket_ping_thread && response.key?('config') && response['config'].key?('hbInterval')
+                  @last_web_socket_pong_at = Time.now
+                  # @web_socket_ping_interval = response['config']['hbInterval']
+                  @web_socket_ping_interval = 30.seconds
+                  Ewelink.logger.debug(self.class.name) { "Creating thread for WebSocket ping every #{@web_socket_ping_interval} seconds" }
+                  @web_socket_ping_thread = Thread.new do
+                    loop do
+                      break if Thread.current[:stop]
+                      sleep(@web_socket_ping_interval)
+                      Ewelink.logger.debug(self.class.name) { 'Sending WebSocket ping' }
+                      send_to_web_socket('ping')
+                    end
+                  end
+                end
+
+                if response['apikey'].present? && !@web_socket_authenticated_api_keys.include?(response['apikey'])
+                  @web_socket_authenticated_api_keys << response['apikey']
+                  Ewelink.logger.debug(self.class.name) { "WebSocket successfully authenticated API key: #{response['apikey'].truncate(16).inspect}" }
+                end
+
+                if response['deviceid'].present? && response['params'].is_a?(Hash) && response['params']['switch'].present?
+                  switch = switches.find { |switch| switch[:device_id] == response['deviceid'] }
+                  @switches_statuses[switch[:uuid]] = response['params']['switch'] if switch.present?
+                end
+              end
+            end
+
+            web_socket.on(:open) do
+              api.instance_eval do
+                Ewelink.logger.debug(self.class.name) { 'WebSocket opened' }
+                api_keys.each do |api_key|
+                  params = {
+                    'action' => 'userOnline',
+                    'apikey' => api_key,
+                    'appid' => APP_ID,
+                    'at' => authentication_token,
+                    'nonce' => nonce,
+                    'sequence' => web_socket_sequence,
+                    'ts' => Time.now.to_i,
+                    'userAgent' => 'app',
+                    'version' => VERSION,
+                  }
+                  Ewelink.logger.debug(self.class.name) { "Authenticating WebSocket API key: #{api_key.truncate(16).inspect}" }
+                  send_to_web_socket(JSON.generate(params))
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def web_socket_authenticated?
+      api_keys == @web_socket_authenticated_api_keys
+    end
+
+    def web_socket_outdated_ping?
+      @last_web_socket_pong_at.present? && @web_socket_ping_interval.present? && @last_web_socket_pong_at < (@web_socket_ping_interval * WEB_SOCKET_PING_TOLERANCE_FACTOR).seconds.ago
+    end
+
+    def web_socket_sequence
+      (Time.now.to_f * 1000).round.to_s
+    end
+
+    def web_socket_url
+      synchronize(:web_socket_url) do
+        @web_socket_url ||= begin
+          params = {
+            'accept' => 'ws',
+            'appid' => APP_ID,
+            'nonce' => nonce,
+            'ts' => Time.now.to_i,
+            'version' => VERSION,
+          }
+          response = rest_request(:post, '/dispatch/app', body: JSON.generate(params), headers: authentication_headers)
+          raise('Error while getting WebSocket URL') unless response['error'] == 0
+          domain = response['domain'].presence || raise("Can't get WebSocket server domain")
+          port = response['port'].presence || raise("Can't get WebSocket server port")
+          "wss://#{domain}:#{port}/api/ws".tap { |url| Ewelink.logger.debug(self.class.name) { "WebSocket URL is: #{url.inspect}" } }
+        end
+      end
+    end
+
+    def web_socket_wait_for(condition, &block)
+      web_socket # Initializes WebSocket
+      Timeout.timeout(TIMEOUT) do
+        loop do
+          if condition.call
+            return yield if block_given?
+            return true
+          end
+          sleep(WEB_SOCKET_WAIT_INTERVAL)
+        end
+      end
     end
 
   end

data/lib/ewelink/runner.rb

@@ -6,16 +6,17 @@ module Ewelink
       api = Api.new(options.slice(:email, :password, :phone_number))
       puts(JSON.pretty_generate(api.switches)) if options[:list_switches]
       puts(JSON.pretty_generate(api.rf_bridge_buttons)) if options[:list_rf_bridge_buttons]
-      options[:switches_on_uuids].each { |uuid| api.switch_on!(uuid) }
-      options[:switches_off_uuids].each { |uuid| api.switch_off!(uuid) }
+      options[:turn_switches_on_uuids].each { |uuid| api.turn_switch!(uuid, :on) }
+      options[:turn_switches_off_uuids].each { |uuid| api.turn_switch!(uuid, :off) }
       options[:press_rf_bridge_buttons_uuids].each { |uuid| api.press_rf_bridge_button!(uuid) }
+      puts(JSON.pretty_generate(options[:switch_status_uuids].map { |uuid| [uuid, api.switch_on?(uuid) ? 'on' : 'off'] }.to_h)) if options[:switch_status_uuids].present?
     end
 
     private
 
     def options
       @options ||= begin
-        options = { press_rf_bridge_buttons_uuids: [], switches_off_uuids: [], switches_on_uuids: [] }
+        options = { press_rf_bridge_buttons_uuids: [], turn_switches_off_uuids: [], turn_switches_on_uuids: [], switch_status_uuids: [] }
         parser = OptionParser.new do |opts|
           opts.banner = 'Manage eWeLink smart home devices'
           opts.version = File.read(File.expand_path('../../VERSION', __dir__)).strip
@@ -37,15 +38,18 @@ module Ewelink
           opts.on('--list-rf-bridge-buttons', 'List all RF 433MHz bridge buttons in JSON format') do
             options[:list_rf_bridge_buttons] = true
           end
-          opts.on('--switch-on SWITCH_UUID', 'Set the switch with specified UUID on') do |uuid|
-            options[:switches_on_uuids] << uuid
+          opts.on('--turn-switch-on SWITCH_UUID', 'Turn the switch with specified UUID on') do |uuid|
+            options[:turn_switches_on_uuids] << uuid
           end
-          opts.on('--switch-off SWITCH_UUID', 'Set the switch with specified UUID off') do |uuid|
-            options[:switches_off_uuids] << uuid
+          opts.on('--turn-switch-off SWITCH_UUID', 'Turn the switch with specified UUID off') do |uuid|
+            options[:turn_switches_off_uuids] << uuid
           end
           opts.on('--press-rf-bridge-button BUTTON_UUID', 'Press RF 433MHz bridge button with specified UUID') do |uuid|
             options[:press_rf_bridge_buttons_uuids] << uuid
           end
+          opts.on('--switch-status SWITCH_UUID', 'Displays switch status of specified UUID') do |uuid|
+            options[:switch_status_uuids] << uuid
+          end
           opts.on('-v', '--verbose', 'Verbose mode') do
             Ewelink.logger.level = :debug
           end
@@ -61,7 +65,7 @@ module Ewelink
           STDERR.puts(parser.summarize)
           exit(1)
         end
-        if [:list_switches, :list_rf_bridge_buttons, :switches_on_uuids, :switches_off_uuids, :press_rf_bridge_buttons_uuids].map { |action| options[action] }.all?(&:blank?)
+        if [:list_switches, :list_rf_bridge_buttons, :turn_switches_on_uuids, :turn_switches_off_uuids, :press_rf_bridge_buttons_uuids, :switch_status_uuids].map { |action| options[action] }.all?(&:blank?)
           STDERR.puts('An action must be specified (listing switches, press RF bridge button, etc.)')
           STDERR.puts(parser.summarize)
           exit(1)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ewelink
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.1.0
 platform: ruby
 authors:
 - Alexis Toulotte
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-04-18 00:00:00.000000000 Z
+date: 2020-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -50,6 +50,26 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: 0.19.0
+- !ruby/object:Gem::Dependency
+  name: websocket-client-simple
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.4.0
 - !ruby/object:Gem::Dependency
   name: byebug
   requirement: !ruby/object:Gem::Requirement
@@ -109,7 +129,7 @@ homepage: https://github.com/alexistoulotte/ewelink
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -125,7 +145,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.0.3
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Manage eWeLink devices
 test_files: []