ewelink 2.1.1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bb352abf05d6bb6ef2f3b277c6f551d436bed969086478d3e121fd2e178fe4f9
-  data.tar.gz: b74266f2cbc92457a3bb0dc087752299a5a9f8348d3928a79d8c3c0719653e6a
+  metadata.gz: 558b7f50525eabfc0e0ac3cd32fd5a0ff5c0d4b6cc7658024dba4c6c0336f96a
+  data.tar.gz: cda09a44af6247436a22af9443a1dd3c078e8b86ab228f3ce12761baca606a7b
 SHA512:
-  metadata.gz: 2c5bb695c7d0094436454694008dd3c05c660fb1c7dfe2436ec1fa2fae3341559f901f3b9ae4ebfa99fcc276dcd4ceee02205ed1608d03e515b8da64b52f8a25
-  data.tar.gz: 4713a948c736a40496b3b33fff3b83253a4559693d692cfaa7251a4fc2d3f0e67699834f6513226edcbfe6cf7759ab54b1cb6c5a24cbe1559f54a75d6cbda6fd
+  metadata.gz: 9607d6170f6e3f0cb00d599fa7a8258b25367423e6a87b2238079d336d6ee2a58389f78ffdcbc3eaf9726c1685ff3cb8b95fb0387d655ae6b81614d50d990c01
+  data.tar.gz: 4ad312d700e40c50f20cd47f5d66dec54937633e1162e21b3d131556752dc937e41c70d128e210d344d19a8bd0cb0fb4de1606f081cba50ad1189c84655440b6

data/VERSION

@@ -1 +1 @@
-2.1.1
+3.0.0

data/ewelink.gemspec

@@ -17,7 +17,6 @@ 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,9 +7,6 @@ require 'json'
 require 'logger'
 require 'openssl'
 require 'optparse'
-require 'set'
-require 'timeout'
-require 'websocket-client-simple'
 
 module Ewelink
 

data/lib/ewelink/api.rb

@@ -5,14 +5,12 @@ module Ewelink
     APP_ID = 'oeVkj2lYFGnJu5XUtWisfW4utiN4u9Mq'
     APP_SECRET = '6Nz4n0xA8s8qdxQf2GqurZj2Fs55FUvM'
     DEFAULT_REGION = 'us'
-    REQUEST_TIMEOUT = 10.seconds
     RF_BRIDGE_DEVICE_UIID = 28
     SWITCH_DEVICES_UIIDS = [1, 5, 6, 24]
+    TIMEOUT = 10
     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
 
@@ -21,45 +19,31 @@ module Ewelink
       @mutexs = {}
       @password = password.presence || raise(Error.new(":password must be specified"))
       @phone_number = phone_number.presence.try(:strip)
-      @web_socket_authenticated_api_keys = Set.new
-      @web_socket_switches_statuses = {}
       raise(Error.new(":email or :phone_number must be specified")) if email.blank? && phone_number.blank?
     end
 
     def press_rf_bridge_button!(uuid)
       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
+        params = {
+          'appid' => APP_ID,
+          'deviceid' => button[:device_id],
+          'nonce' => nonce,
+          'params' => {
+            'cmd' => 'transmit',
+            'rfChl' => button[:channel],
+          },
+          'ts' => Time.now.to_i,
+          'version' => VERSION,
+        }
+        rest_request(:post, '/api/user/device/status', body: JSON.generate(params), headers: authentication_headers)
+        true
       end
     end
 
     def reload
-      Ewelink.logger.debug(self.class.name) { 'Reloading API (authentication token, devices, region, connections,...)' }
-      dispose_web_socket
-      [
-        :@api_keys,
-        :@authentication_token,
-        :@devices,
-        :@region,
-        :@rf_bridge_buttons,
-        :@switches,
-      ].each do |variable|
+      Ewelink.logger.debug(self.class.name) { 'Reloading API (authentication token, devices & region cache)' }
+      [:@authentication_token, :@devices, :@rf_bridge_buttons, :@region, :@switches].each do |variable|
         remove_instance_variable(variable) if instance_variable_defined?(variable)
       end
       self
@@ -72,12 +56,10 @@ module Ewelink
             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|
               button = {
-                api_key: api_key,
                 channel: rf['rfChl'],
                 device_id: device_id,
                 device_name: device_name,
@@ -101,24 +83,15 @@ module Ewelink
 
     def switch_on?(uuid)
       switch = find_switch!(uuid)
-      if @web_socket_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(-> { !@web_socket_switches_statuses[switch[:uuid]].nil? }) do
-        Ewelink.logger.debug(self.class.name) { "Switch #{switch[:uuid].inspect} is #{@web_socket_switches_statuses[switch[:uuid]]}" }
-        @web_socket_switches_statuses[switch[:uuid]] == 'on'
-      end
+      params = {
+        'appid' => APP_ID,
+        'deviceid' => switch[:device_id],
+        'nonce' => nonce,
+        'ts' => Time.now.to_i,
+        'version' => VERSION,
+      }
+      response = rest_request(:get, '/api/user/device/status', headers: authentication_headers, query: params)
+      response['params']['switch'] == 'on'
     end
 
     def switches
@@ -126,11 +99,9 @@ module Ewelink
         @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,
             }
@@ -148,34 +119,22 @@ module Ewelink
         on = false
       end
       switch = find_switch!(uuid)
-      @web_socket_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
+      params = {
+        'appid' => APP_ID,
+        'deviceid' => switch[:device_id],
+        'nonce' => nonce,
+        'params' => {
+          'switch' => on ? 'on' : 'off',
+        },
+        'ts' => Time.now.to_i,
+        'version' => VERSION,
+      }
+      rest_request(:post, '/api/user/device/status', body: JSON.generate(params), headers: authentication_headers)
       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
@@ -220,37 +179,6 @@ module Ewelink
       end
     end
 
-    def dispose_web_socket
-      @web_socket_authenticated_api_keys.clear
-      @web_socket_switches_statuses.clear
-
-      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
@@ -272,7 +200,7 @@ module Ewelink
       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: headers).reverse_merge(timeout: REQUEST_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']
@@ -281,163 +209,15 @@ module Ewelink
       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.to_h
+      response
     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 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.inspect}" }
-
-            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']['hb'] == 1 && response['config']['hbInterval'].present?
-                  @last_web_socket_pong_at = Time.now
-                  @web_socket_ping_interval = response['config']['hbInterval'] + 7
-                  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'] }
-                  @web_socket_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(REQUEST_TIMEOUT) do
-        loop do
-          if condition.call
-            return yield if block_given?
-            return true
-          end
-          sleep(WEB_SOCKET_WAIT_INTERVAL)
-        end
-      end
-    end
-
   end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ewelink
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 3.0.0
 platform: ruby
 authors:
 - Alexis Toulotte
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-09-02 00:00:00.000000000 Z
+date: 2020-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -50,26 +50,6 @@ 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