ewelink 3.0.0 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 558b7f50525eabfc0e0ac3cd32fd5a0ff5c0d4b6cc7658024dba4c6c0336f96a
-  data.tar.gz: cda09a44af6247436a22af9443a1dd3c078e8b86ab228f3ce12761baca606a7b
+  metadata.gz: 45f904d5e72d0038360340adc26dd7eb963f664804b43eee8235ee02d48f60ff
+  data.tar.gz: 98ee94c2d9187ea17250c3f32c1932f8c0df8a2123c341a47159c32e2aec66e9
 SHA512:
-  metadata.gz: 9607d6170f6e3f0cb00d599fa7a8258b25367423e6a87b2238079d336d6ee2a58389f78ffdcbc3eaf9726c1685ff3cb8b95fb0387d655ae6b81614d50d990c01
-  data.tar.gz: 4ad312d700e40c50f20cd47f5d66dec54937633e1162e21b3d131556752dc937e41c70d128e210d344d19a8bd0cb0fb4de1606f081cba50ad1189c84655440b6
+  metadata.gz: 42977ef17b87c9c6710973968ca739d642108d6595861a870090ef13fbe5332b7ff99fba0dc8444e8022dfba065f4334426daf2dc423ed08314b3939cc41e69a
+  data.tar.gz: 4fa2068348c252aecfa1f0d55f91013a17658a3403fa7813208f34f027757b2459181323aae9a9d8c71c915ac8c83e881150c4eacee77ed85832b1adaeadb451

data/VERSION

@@ -1 +1 @@
-3.0.0
+3.1.0

data/ewelink.gemspec

@@ -16,6 +16,7 @@ Gem::Specification.new do |s|
   s.required_ruby_version = '>= 2.0.0'
 
   s.add_dependency 'activesupport', '>= 6.0.0', '< 7.0.0'
+  s.add_dependency 'faye-websocket', '>= 0.11.0', '< 0.12.0'
   s.add_dependency 'httparty', '>= 0.18.0', '< 0.19.0'
 
   s.add_development_dependency 'byebug', '>= 11.0.0', '< 12.0.0'

data/lib/ewelink.rb

@@ -1,12 +1,16 @@
 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'
 require 'logger'
 require 'openssl'
 require 'optparse'
+require 'set'
+require 'timeout'
 
 module Ewelink
 

data/lib/ewelink/api.rb

@@ -5,12 +5,16 @@ 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_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
 
@@ -19,31 +23,73 @@ module Ewelink
       @mutexs = {}
       @password = password.presence || raise(Error.new(":password must be specified"))
       @phone_number = phone_number.presence.try(:strip)
-      raise(Error.new(":email or :phone_number must be specified")) if email.blank? && phone_number.blank?
+      @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 press_rf_bridge_button!(uuid)
       synchronize(:press_rf_bridge_button) do
         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,
-        }
-        rest_request(:post, '/api/user/device/status', body: JSON.generate(params), headers: authentication_headers)
-        true
+        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
       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, 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
+
+      [
+        :@authentication_infos,
+        :@devices,
+        :@last_web_socket_pong_at,
+        :@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
       self
@@ -56,10 +102,12 @@ 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,
@@ -83,15 +131,23 @@ module Ewelink
 
     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 = rest_request(:get, '/api/user/device/status', headers: authentication_headers, query: params)
-      response['params']['switch'] == 'on'
+      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
     end
 
     def switches
@@ -99,9 +155,11 @@ 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,
             }
@@ -119,29 +177,56 @@ 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
+    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,
-        'deviceid' => switch[:device_id],
+        'at' => authentication_token,
         'nonce' => nonce,
-        'params' => {
-          'switch' => on ? 'on' : 'off',
-        },
+        'sequence' => web_socket_sequence,
         'ts' => Time.now.to_i,
+        'userAgent' => 'app',
         'version' => VERSION,
       }
-      rest_request(:post, '/api/user/device/status', body: JSON.generate(params), headers: authentication_headers)
-      true
+      Ewelink.logger.debug(self.class.name) { "Authenticating WebSocket API key: #{api_key.truncate(16).inspect}" }
+      send_to_web_socket(JSON.generate(params))
     end
 
-    private
-
     def authentication_headers
       { 'Authorization' => "Bearer #{authentication_token}" }
     end
 
-    def authentication_token
-      synchronize(:authentication_token) do
-        @authentication_token ||= begin
+    def authentication_infos
+      synchronize(:authentication_infos) do
+        @authentication_infos ||= begin
           params = {
             'appid' => APP_ID,
             'imei' => SecureRandom.uuid.upcase,
@@ -158,11 +243,19 @@ module Ewelink
           body = JSON.generate(params)
           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' } }
+          raise(Error.new('API key not found')) if response['user'].blank? || response['user']['apikey'].blank?
+          {
+            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' } },
+          }
         end
       end
     end
 
+    def authentication_token
+      authentication_infos[:authentication_token]
+    end
+
     def devices
       synchronize(:devices) do
         @devices ||= begin
@@ -200,24 +293,189 @@ 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: TIMEOUT))
+      response = HTTParty.send(method.downcase, url, options.merge(headers: 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']
         Ewelink.logger.debug(self.class.name) { "Switched to region #{region.inspect}" }
         return rest_request(method, path, options)
       end
-      remove_instance_variable(:@authentication_token) if instance_variable_defined?(:@authentication_token) && [401, 403].include?(response['error'])
+      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
+      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 |event|
+              Ewelink.logger.debug(self.class.name) { 'WebSocket closed' }
+              reload
+            end
+
+            @web_socket.on(:open) do |event|
+              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 => e
+                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}" }
+              end
+
+              if json['deviceid'].present? && json['params'].is_a?(Hash) && json['params']['switch'].present?
+                switch = switches.find { |switch| switch[: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, &block)
+      web_socket if initialize_web_socket
+      begin
+        Timeout.timeout(REQUEST_TIMEOUT) do
+          while !condition.call
+            sleep(WEB_SOCKET_WAIT_INTERVAL)
+          end
+          block_given? ? yield : true
+        end
+      rescue => e
+        reload
+        raise Error.new(e)
+      end
+    end
+
   end
 
 end

metadata

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