ewelink 4.1.0 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8cba69a24adaf18a0be08cbf1618b612d6d0e90fd788d8b9f2360f7d19f67406
-  data.tar.gz: adc650eac1533d343320490132302827a79f0fc4a0571d0dcba91ef926e5f682
+  metadata.gz: '03889642d2851312650d6419544fd7423b2b8ca0a64a272386de46646640b191'
+  data.tar.gz: b36f496794dce02953b423d601f4e71905afca7c0aebe4fe5bfc65d08f65daff
 SHA512:
-  metadata.gz: 39ab9a66085401bb70f34f74b9220e70ad691c5db65b180816d5a284462162064364d6e6ed3f2b5d990f9c3fa3450472fb0b13ba0b3ecbca1a22042de3926d28
-  data.tar.gz: 19b1627d07a411ef4fe04578f924a7d339413d65d7132b8cd7614877b1e72300b5cbd51f1f9a6469807fe3179e37a65c048f1e699601c4eb3b4f05b82b0e663f
+  metadata.gz: c3a3349b5c5f5384eb4f02abcf3749b0674ef839c2354f38d319db4ff15e272f7ec551058b52601a1971307f225eac8d0c5c7cfee00d6537a527bb09f044aceb
+  data.tar.gz: 63035965d8732f4fda004b16331ee06a4ad6f55da7a4338b041585823397b14bb6dfecacf83123354b024f2a9fb8e1b724d32011862d9343babec527fff12d2e

data/README.mdown

@@ -80,8 +80,6 @@ api.press_rf_bridge_button!(button[:uuid])
 - `async_actions` (`true` | `false`): To perform actions (pressing an RF
   bridge button or turning a switch on/off) in asynchronous mode. (default:
   `false`).
-- `update_devices_status_on_connect` (`true` | `false`): To update devices
-  status (on, off) when connecting to Ewelink API (default: `false`).
 
 ### Configuring logger
 

data/VERSION

@@ -1 +1 @@
-4.1.0
+6.0.0

data/ewelink.gemspec

@@ -16,7 +16,6 @@ Gem::Specification.new do |s|
   s.required_ruby_version = '>= 3.1.0'
 
   s.add_dependency 'activesupport', '>= 7.0.0', '< 8.0.0'
-  s.add_dependency 'faye-websocket', '>= 0.11.0', '< 0.12.0'
   s.add_dependency 'httparty', '>= 0.20.0', '< 0.21.0'
   s.add_dependency 'thread', '>= 0.2.0', '< 0.3.0'
 

data/lib/ewelink/api.rb

@@ -2,34 +2,26 @@ module Ewelink
 
   class Api
 
-    APP_ID = 'oeVkj2lYFGnJu5XUtWisfW4utiN4u9Mq'.freeze
-    APP_SECRET = '6Nz4n0xA8s8qdxQf2GqurZj2Fs55FUvM'.freeze
+    APP_ID = 'Uw83EKZFxdif7XFXEsrpduz5YyjP7nTl'.freeze
+    APP_SECRET = 'mXLOjea0woSMvK9gw7Fjsy7YlFO4iSu6'.freeze
+    DEFAULT_COUNTRY_CODE = '+44'.freeze
     DEFAULT_REGION = 'us'.freeze
     REQUEST_TIMEOUT = 10.seconds
     RF_BRIDGE_DEVICE_UIID = 28
     SWITCH_DEVICES_UIIDS = [1, 5, 6, 24].freeze
-    URL = 'https://#{region}-api.coolkit.cc:8080'.freeze
+    URL = 'https://#{region}-apia.coolkit.cc'.freeze
     VERSION = 8
-    WEB_SOCKET_CHECK_AUTHENTICATION_TIMEOUT = 30.seconds
-    WEB_SOCKET_PING_TOLERANCE_FACTOR = 1.5
-    SWITCH_STATUS_CHANGE_CHECK_TIMEOUT = 2.seconds
-    WEB_SOCKET_WAIT_INTERVAL = 0.2.seconds
 
     attr_reader :email, :password, :phone_number
 
-    def initialize(password:, async_actions: false, email: nil, phone_number: nil, update_devices_status_on_connect: false)
+    def initialize(password:, async_actions: false, email: nil, phone_number: nil)
       @async_actions = async_actions.present?
       @email = email.presence.try(:strip)
       @mutexs = {}
       @password = password.presence || raise(Error.new(':password must be specified'))
       @phone_number = phone_number.presence.try(:strip)
-      @update_devices_status_on_connect = update_devices_status_on_connect.present?
-      @web_socket_authenticated = false
-      @web_socket_switches_statuses = {}
 
       raise(Error.new(':email or :phone_number must be specified')) if email.blank? && phone_number.blank?
-
-      start_web_socket_authentication_check_thread
     end
 
     def async_actions?
@@ -40,23 +32,21 @@ module Ewelink
       process_action do
         synchronize(:press_rf_bridge_button) do
           button = find_rf_bridge_button!(uuid)
-          web_socket_wait_for(-> { web_socket_authenticated? }, initialize_web_socket: true) 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
+          headers = authentication_headers.merge(
+            'X-CK-Appid' => APP_ID,
+            'X-CK-Nonce' => nonce,
+          )
+          params = {
+            'type' => 1,
+            'id' => button[:device_id],
+            'params' => {
+              'cmd' => 'transmit',
+              'rfChl' => button[:channel],
+            },
+          }
+          body = JSON.generate(params)
+          response = rest_request(:post, '/v2/device/thing/status', headers:, body:)
+          response['error'] == 0
         end
       end
     end
@@ -64,38 +54,13 @@ module Ewelink
     def reload
       Ewelink.logger.debug(self.class.name) { 'Reloading API (authentication token, api key, devices, region, connections,...)' }
 
-      @web_socket_authenticated = false
-      @web_socket_switches_statuses.clear
-
-      [@web_socket_ping_thread, @web_socket_thread].each do |thread|
-        next unless thread
-        if Thread.current == thread
-          thread[:stop] = true
-        else
-          thread.kill
-        end
-      end
-
-      if @web_socket.present?
-        begin
-          @web_socket.close if @web_socket.open?
-        rescue
-          # Ignoring close errors
-        end
-      end
-
       %i(
         @authentication_infos
         @devices
-        @last_web_socket_pong_at
+        @homes_ids
         @region
         @rf_bridge_buttons
         @switches
-        @web_socket_ping_interval
-        @web_socket_ping_thread
-        @web_socket_thread
-        @web_socket_url
-        @web_socket
       ).each do |variable|
         remove_instance_variable(variable) if instance_variable_defined?(variable)
       end
@@ -105,21 +70,21 @@ module Ewelink
     def rf_bridge_buttons
       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|
+          rf_bridge_devices = devices.select { |device| device['itemData']['extra']['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|
-            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|
+            api_key = device['itemData']['apikey'].presence || next
+            device_id = device['itemData']['deviceid'].presence || next
+            device_name = device['itemData']['name'].presence || next
+            buttons = device['itemData']['params']['rfList'].each do |rf|
               button = {
                 api_key:,
                 channel: rf['rfChl'],
                 device_id:,
                 device_name:,
               }
-              remote_info = device['tags']['zyx_info'].find { |info| info['buttonName'].find { |data| data.key?(button[:channel].to_s) } }.presence || next
+              remote_info = device['itemData']['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
@@ -138,37 +103,32 @@ module Ewelink
 
     def switch_on?(uuid)
       switch = find_switch!(uuid)
-      if @web_socket_switches_statuses[switch[:uuid]].nil?
-        web_socket_wait_for(-> { web_socket_authenticated? }, initialize_web_socket: true) do
-          Ewelink.logger.debug(self.class.name) { "Checking switch #{switch[:uuid].inspect} status" }
-          params = {
-            'action' => 'query',
-            'apikey' => switch[:api_key],
-            'deviceid' => switch[:device_id],
-            'sequence' => web_socket_sequence,
-            'ts' => 0,
-            'userAgent' => 'app',
-          }
-          send_to_web_socket(JSON.generate(params))
-        end
-      end
-      web_socket_wait_for(-> { !@web_socket_switches_statuses[switch[:uuid]].nil? }, initialize_web_socket: true) do
-        @web_socket_switches_statuses[switch[:uuid]] == 'on'
-      end
+      headers = authentication_headers.merge(
+        'X-CK-Appid' => APP_ID,
+        'X-CK-Nonce' => nonce,
+      )
+      params = {
+        'type' => 1,
+        'id' => switch[:device_id],
+        'params' => 'switch',
+      }
+      Ewelink.logger.debug(self.class.name) { "Checking switch #{switch[:uuid].inspect} status" }
+      response = rest_request(:get, '/v2/device/thing/status', headers:, query: params)
+      response['data']['params']['switch'] == 'on'
     end
 
     def switches
       synchronize(:switches) do
         @switches ||= [].tap do |switches|
-          switch_devices = devices.select { |device| SWITCH_DEVICES_UIIDS.include?(device['uiid']) }
+          switch_devices = devices.select { |device| SWITCH_DEVICES_UIIDS.include?(device['itemData']['extra']['uiid']) }
           switch_devices.each do |device|
-            api_key = device['apikey'].presence || next
-            device_id = device['deviceid'].presence || next
-            name = device['name'].presence || next
+            api_key = device['itemData']['apikey'].presence || next
+            device_id = device['itemData']['deviceid'].presence || next
+            name = device['itemData']['name'].presence || next
             switch = {
               api_key:,
               device_id:,
-              model: device['productModel'],
+              model: device['itemData']['productModel'],
               name:,
             }
             switch[:uuid] = Digest::UUID.uuid_v5(Digest::UUID::DNS_NAMESPACE, switch[:device_id])
@@ -186,54 +146,30 @@ module Ewelink
           on = false
         end
         switch = find_switch!(uuid)
-        @web_socket_switches_statuses[switch[:uuid]] = nil
-        web_socket_wait_for(-> { web_socket_authenticated? }, initialize_web_socket: true) 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
-        sleep(SWITCH_STATUS_CHANGE_CHECK_TIMEOUT)
-        switch_on?(switch[:uuid]) # Waiting for switch status update
-        true
+        headers = authentication_headers.merge(
+          'X-CK-Appid' => APP_ID,
+          'X-CK-Nonce' => nonce,
+        )
+        params = {
+          'type' => 1,
+          'id' => switch[:device_id],
+          'params' => {
+            'switch' => on ? 'on' : 'off',
+          },
+        }
+        body = JSON.generate(params)
+        Ewelink.logger.debug(self.class.name) { "Turning switch #{switch[:uuid].inspect} #{on ? 'on' : 'off'}" }
+        response = rest_request(:post, '/v2/device/thing/status', headers:, body:)
+        response['error'] == 0
       end
     end
 
-    def update_devices_status_on_connect?
-      @update_devices_status_on_connect
-    end
-
     private
 
     def api_key
       authentication_infos[:api_key]
     end
 
-    def authenticate_web_socket_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
-
     def authentication_headers
       { 'Authorization' => "Bearer #{authentication_token}" }
     end
@@ -242,12 +178,8 @@ module Ewelink
       synchronize(:authentication_infos) do
         @authentication_infos ||= begin
           params = {
-            'appid' => APP_ID,
-            'imei' => SecureRandom.uuid.upcase,
-            'nonce' => nonce,
+            'countryCode' => DEFAULT_COUNTRY_CODE,
             'password' => password,
-            'ts' => Time.now.to_i,
-            'version' => VERSION,
           }
           if email.present?
             params['email'] = email
@@ -255,12 +187,20 @@ module Ewelink
             params['phoneNumber'] = phone_number
           end
           body = JSON.generate(params)
-          response = rest_request(:post, '/api/user/login', { body:, headers: { 'Authorization' => "Sign #{Base64.encode64(OpenSSL::HMAC.digest('SHA256', APP_SECRET, body))}" } })
-          raise(Error.new('Authentication token not found')) if response['at'].blank?
-          raise(Error.new('API key not found')) if response['user'].blank? || response['user']['apikey'].blank?
+          response = rest_request(:post, '/v2/user/login', {
+            body:,
+            headers: {
+              'Authorization' => "Sign #{Base64.encode64(OpenSSL::HMAC.digest('SHA256', APP_SECRET, body))}",
+              'X-CK-Appid': APP_ID,
+              'X-CK-Nonce': nonce,
+            },
+          })
+          raise(Error.new('Invalid authentication response')) unless response['data'].is_a?(Hash) && response['data']['user'].is_a?(Hash)
+          raise(Error.new('Authentication token not found')) unless response['data']['at'].present?
+          raise(Error.new('API key not found')) unless response['data']['user']['apikey'].present?
           {
-            authentication_token: response['at'].tap { Ewelink.logger.debug(self.class.name) { 'Authentication token found' } },
-            api_key: response['user']['apikey'].tap { Ewelink.logger.debug(self.class.name) { 'API key found' } },
+            api_key: response['data']['user']['apikey'].tap { Ewelink.logger.debug(self.class.name) { 'API key found' } },
+            authentication_token: response['data']['at'].tap { Ewelink.logger.debug(self.class.name) { 'Authentication token found' } },
           }
         end
       end
@@ -273,15 +213,22 @@ module Ewelink
     def devices
       synchronize(:devices) do
         @devices ||= begin
-          params = {
-            'appid' => APP_ID,
-            'getTags' => 1,
-            'nonce' => nonce,
-            'ts' => Time.now.to_i,
-            'version' => VERSION,
-          }
-          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)" } }
+          devices = []
+          homes_ids.each do |home_id|
+            params = {
+              'familyid' => home_id,
+              'num' => 0,
+            }
+            headers = authentication_headers.merge(
+              'X-CK-Appid' => APP_ID,
+              'X-CK-Nonce' => nonce,
+            )
+            response = rest_request(:get, '/v2/device/thing', headers:, query: params)
+            raise('Invalid devices response') unless response['data'].is_a?(Hash) && response['data']['thingList'].is_a?(Array)
+            devices += response['data']['thingList']
+          end
+          Ewelink.logger.debug(self.class.name) { "Found #{devices.size} device(s)" }
+          devices
         end
       end
     end
@@ -294,6 +241,20 @@ module Ewelink
       switches.find { |switch| switch[:uuid] == uuid } || raise(Error.new("No such switch with UUID: #{uuid.inspect}"))
     end
 
+    def homes_ids
+      synchronize(:homes_ids) do
+        @homes_ids ||= begin
+          headers = authentication_headers.merge(
+            'X-CK-Appid' => APP_ID,
+            'X-CK-Nonce' => nonce,
+          )
+          response = rest_request(:get, '/v2/family', headers:)
+          raise('Invalid homes response') unless response['data'].is_a?(Hash) && response['data']['familyList'].is_a?(Array)
+          response['data']['familyList'].map { |home| home['id'] }.compact.uniq
+        end
+      end
+    end
+
     def nonce
       SecureRandom.hex[0, 8]
     end
@@ -311,191 +272,27 @@ module Ewelink
 
     def rest_request(method, path, options = {})
       url = "#{URL.gsub('#{region}', region)}#{path}"
+      url.gsub!(/#{Regexp.escape("#{region}-api")}/, "#{region}-disp") if options[:dispatch].present?
       method = method.to_s.upcase
       headers = (options[:headers] || {}).reverse_merge('Content-Type' => 'application/json')
       Ewelink.logger.debug(self.class.name) { "#{method} #{url}" }
       response = HTTParty.send(method.downcase, url, options.merge(headers:).reverse_merge(timeout: REQUEST_TIMEOUT))
       raise(Error.new("#{method} #{url}: #{response.code}")) unless response.success?
-      if response['error'] == 301 && response['region'].present?
-        @region = response['region']
+      if response['error'] == 10_004 && response['data'].present? && response['data']['region'].present?
+        @region = response['data']['region']
         Ewelink.logger.debug(self.class.name) { "Switched to region #{region.inspect}" }
         return rest_request(method, path, options)
       end
-      remove_instance_variable(:@authentication_infos) if instance_variable_defined?(:@authentication_infos) && [401, 403].include?(response['error'])
       raise(Error.new("#{method} #{url}: #{response['error']} #{response['msg']}".strip)) if response['error'].present? && response['error'] != 0
       response.to_h
     rescue Errno::ECONNREFUSED, OpenSSL::OpenSSLError, SocketError, Timeout::Error => e
       raise Error.new(e)
     end
 
-    def send_to_web_socket(message)
-      web_socket.send(message)
-    rescue => e
-      reload
-      raise Error.new(e)
-    end
-
-    def start_web_socket_authentication_check_thread
-      raise Error.new('WebSocket authentication check must only be started once') if @web_socket_authentication_check_thread.present?
-
-      @web_socket_authentication_check_thread = Thread.new do
-        loop do
-          Ewelink.logger.debug(self.class.name) { 'Checking if WebSocket is authenticated' }
-          begin
-            web_socket_wait_for(-> { web_socket_authenticated? }, initialize_web_socket: true) do
-              Ewelink.logger.debug(self.class.name) { 'WebSocket is authenticated' }
-            end
-          rescue => e
-            Ewelink.logger.error(self.class.name) { e }
-          end
-          sleep(WEB_SOCKET_CHECK_AUTHENTICATION_TIMEOUT)
-        end
-      end
-    end
-
-    def start_web_socket_ping_thread(interval)
-      @last_web_socket_pong_at = Time.now
-      @web_socket_ping_interval = interval
-      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
-
     def synchronize(name, &block)
       (@mutexs[name] ||= Mutex.new).synchronize(&block)
     end
 
-    def web_socket
-      if web_socket_outdated_ping?
-        Ewelink.logger.warn(self.class.name) { 'WebSocket ping is outdated' }
-        reload
-      end
-
-      synchronize(:web_socket) do
-        next @web_socket if @web_socket
-
-        # Initializes caches before opening WebSocket: important in order to
-        # NOT cumulate requests Timeouts from #web_socket_wait_for.
-        api_key
-        web_socket_url
-
-        Ewelink.logger.debug(self.class.name) { "Opening WebSocket to #{web_socket_url.inspect}" }
-
-        @web_socket_thread = Thread.new do
-          EventMachine.run do
-            @web_socket = Faye::WebSocket::Client.new(web_socket_url)
-
-            @web_socket.on(:close) do
-              Ewelink.logger.debug(self.class.name) { 'WebSocket closed' }
-              reload
-            end
-
-            @web_socket.on(:open) do
-              Ewelink.logger.debug(self.class.name) { 'WebSocket opened' }
-              @last_web_socket_pong_at = Time.now
-              authenticate_web_socket_api_key
-            end
-
-            @web_socket.on(:message) do |event|
-              message = event.data
-
-              if message == 'pong'
-                Ewelink.logger.debug(self.class.name) { "Received WebSocket #{message.inspect} message" }
-                @last_web_socket_pong_at = Time.now
-                next
-              end
-
-              begin
-                json = JSON.parse(message)
-              rescue
-                Ewelink.logger.error(self.class.name) { 'WebSocket JSON parse error' }
-                reload
-                next
-              end
-
-              if json.key?('error') && json['error'] != 0
-                Ewelink.logger.error(self.class.name) { "WebSocket message error: #{message.inspect}" }
-                reload
-                next
-              end
-
-              if !@web_socket_ping_thread && json.key?('config') && json['config']['hb'] == 1 && json['config']['hbInterval'].present?
-                start_web_socket_ping_thread(json['config']['hbInterval'] + 7)
-              end
-
-              if json['apikey'].present? && !@web_socket_authenticated && json['apikey'] == api_key
-                @web_socket_authenticated = true
-                Ewelink.logger.debug(self.class.name) { "WebSocket successfully authenticated API key: #{json['apikey'].truncate(16).inspect}" }
-                Thread.new { switches.each { |switch| switch_on?(switch[:uuid]) } } if update_devices_status_on_connect?
-              end
-
-              if json['deviceid'].present? && json['params'].is_a?(Hash) && json['params']['switch'].present?
-                switch = switches.find { |item| item[:device_id] == json['deviceid'] }
-                if switch.present?
-                  @web_socket_switches_statuses[switch[:uuid]] = json['params']['switch']
-                  Ewelink.logger.debug(self.class.name) { "Switch #{switch[:uuid].inspect} is #{@web_socket_switches_statuses[switch[:uuid]]}" }
-                end
-              end
-            end
-          end
-        end
-
-        web_socket_wait_for(-> { @web_socket.present? }) do
-          @web_socket
-        end
-      end
-    end
-
-    def web_socket_authenticated?
-      @web_socket_authenticated.present?
-    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, initialize_web_socket: false)
-      web_socket if initialize_web_socket
-      begin
-        Timeout.timeout(REQUEST_TIMEOUT) do
-          sleep(WEB_SOCKET_WAIT_INTERVAL) until condition.call
-          block_given? ? yield : true
-        end
-      rescue => e
-        reload
-        raise Error.new(e)
-      end
-    end
-
   end
 
 end

data/lib/ewelink.rb

@@ -1,8 +1,6 @@
 require 'active_support'
 require 'active_support/core_ext'
 require 'byebug' if ENV['DEBUGGER']
-require 'eventmachine'
-require 'faye/websocket'
 require 'httparty'
 require 'io/console'
 require 'json'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ewelink
 version: !ruby/object:Gem::Version
-  version: 4.1.0
+  version: 6.0.0
 platform: ruby
 authors:
 - Alexis Toulotte
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-20 00:00:00.000000000 Z
+date: 2023-04-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -30,26 +30,6 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: 8.0.0
-- !ruby/object:Gem::Dependency
-  name: faye-websocket
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.11.0
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: 0.12.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.11.0
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: 0.12.0
 - !ruby/object:Gem::Dependency
   name: httparty
   requirement: !ruby/object:Gem::Requirement