da_funk 0.4.4

data/lib/device/helper.rb

@@ -0,0 +1,161 @@
+class Device
+  module Helper
+    def self.included(base)
+      base.extend Device::Helper
+    end
+
+    def form(label, options = {})
+      Device::Display.clear
+      options = form_default(options)
+      default = options.delete(:default)
+      puts "#{label} (#{default}):"
+      string = get_format(options.delete(:min), options.delete(:max), options)
+      return default if string.nil? || string.empty?
+      string
+    end
+
+    def attach
+      Device::Display.clear
+      puts "Connecting..."
+      if Device::Network.connected? < 0
+        if (ret = Device::Network.attach) == 0
+          puts "Connected #{ret}"
+        else
+          puts "Attach fail #{ret}"
+          sleep 4
+          return false
+        end
+      else
+        puts "Already connected"
+      end
+      true
+    end
+
+    # TODO Add i18n or something
+    def check_download_error(ret)
+      value = true
+      case ret
+      when Device::Transaction::Download::SERIAL_NUMBER_NOT_FOUND
+        puts "Serial number not found."
+        value =  false
+      when Device::Transaction::Download::FILE_NOT_FOUND
+        puts "File not found."
+        value = false
+      when Device::Transaction::Download::FILE_NOT_CHANGE
+        puts "File is the same."
+      when Device::Transaction::Download::SUCCESS
+        puts "Success."
+      when Device::Transaction::Download::COMMUNICATION_ERROR
+        puts "Communication failure."
+        value = false
+      when Device::Transaction::Download::MAPREDUCE_RESPONSE_ERROR
+        puts "Encoding error."
+        value = false
+      when Device::Transaction::Download::IO_ERROR
+        puts "IO Error."
+        value = false
+      else
+        puts "Communication fail."
+        value = false
+      end
+
+      value
+    end
+
+    # {
+    #   :default => {:detail => 10}, # default value to return if enter
+    #   :number => true, # Add number to label or not
+    #   "option X" => {:detail => 10},
+    #   "option Y" => {:detail => 11}
+    # }
+    def menu(title, selection, options = {})
+      options[:number] = true if options[:number].nil?
+
+      Device::Display.clear
+      print_title(title, options[:default])
+      values = Hash.new
+      selection.each_with_index do |value,i|
+        values[i.to_i] = value[1]
+        if options[:number]
+          Device::Display.print("#{i+1} - #{value[0]}", i+2, 0)
+        else
+          Device::Display.print(value[0], i+2, 0)
+        end
+      end
+
+      key = getc
+
+      return options[:default] if key == IO::ENTER || key == IO::CANCEL
+      [values[key.to_i - 1]].flatten.first
+    end
+
+    def number_to_currency(value, options = {})
+      options[:delimiter] ||= ","
+      options[:precision] ||= 2
+      options[:separator] ||= "."
+
+      if value.is_a? Float
+        number, unit = value.to_s.split(".")
+        len = number.size + unit.size
+      else
+        len    = value.to_s.size
+        unit   = value.to_s[(len - options[:precision])..-1]
+        if len <= options[:precision]
+          number = ""
+        else
+          number = value.to_s[0..(len - (options[:precision] + 1)).abs]
+        end
+      end
+
+      text = ""
+      i = 0
+      number.reverse.each_char do |ch|
+        i += 1
+        text << ch
+        text << options[:delimiter] if (i % 3 == 0) && (len - unit.size) != i
+      end
+      currency = [rjust(text.reverse, 1, "0"),rjust(unit, options[:precision], "0")].join options[:separator]
+      if options[:label]
+        options[:label] + currency
+      else
+        currency
+      end
+    end
+
+    def ljust(string, size, new_string)
+      string_plain = string.to_s
+      if size > string_plain.size
+        string_plain + (new_string * (size - string_plain.size))
+      else
+        string_plain
+      end
+    end
+
+    def rjust(string, size, new_string)
+      string_plain = string.to_s
+      if size > string_plain.size
+        (new_string * (size - string_plain.size)) + string_plain
+      else
+        string_plain
+      end
+    end
+
+    private
+    def form_default(options = {})
+      options[:default] ||= ""
+      options[:mode]    ||= Device::IO::IO_INPUT_LETTERS
+      options[:min]     ||= 0
+      options[:max]     ||= 20
+      options
+    end
+
+    def print_title(string, default)
+      if default
+        puts("#{string} (#{default}):")
+      else
+        puts("#{string}:")
+      end
+    end
+  end
+end
+

data/lib/device/io.rb

@@ -0,0 +1,86 @@
+class Device
+  class IO < ::IO
+    F1               = "\001"
+    F2               = "\002"
+    F3               = "\003"
+    F4               = "\004"
+    FUNC             = "\006"
+    UP               = "\007"
+    DOWN             = "\008"
+    MENU             = "\009"
+    ENTER            = 0x0D.chr
+    CLEAR            = 0x0F.chr
+    ALPHA            = 0x10.chr
+    SHARP            = 0x11.chr
+    KEY_TIMEOUT      = 0x12.chr
+    BACK             = "\017"
+    CANCEL           = 0x1B.chr
+    IO_INPUT_NUMBERS = :numbers
+    IO_INPUT_LETTERS = :letters
+    IO_INPUT_SECRET  = :secret
+    IO_INPUT_DECIMAL = :decimal
+    IO_INPUT_MONEY   = :money
+
+    NUMBERS = %w(1 2 3 4 5 6 7 8 9 0)
+
+    include Device::Helper
+
+    # Restricted to terminals, get strings and numbers.
+    # The switch method between uppercase, lowercase and number characters is to keep pressing a same button quickly. The timeout of this operation is 1 second.
+    #
+    # @param min [Fixnum] Minimum length of the input string.
+    # @param max [Fixnum] Maximum length of the input string (127 bytes maximum).
+    # @param options [Hash]
+    #
+    # :precision - Sets the level of precision (defaults to 2).
+    #
+    # :separator - Sets the separator between the units (defaults to “.”).
+    #
+    # :delimiter - Sets the thousands delimiter (defaults to “,”).
+    #
+    # :label - Sets the label display before currency, eg.: "U$:", "R$:"
+    #
+    # :mode - Define input modes:
+    #
+    #   :numbers (IO_INPUT_NUMBERS) - Only number.
+    #   :letters (IO_INPUT_LETTERS) - Letters and numbers.
+    #   :secret (IO_INPUT_SECRET) - Secret *.
+    #   :decimal (IO_INPUT_DECIMAL) - Decimal input, only number.
+    #   :money (IO_INPUT_MONEY) - Money input, only number.
+    #
+    # @return [String] buffer read from keyboard
+    def self.get_format(min, max, options = {})
+      options[:mode] ||= IO_INPUT_LETTERS
+      if options[:mode] == IO_INPUT_MONEY || options[:mode] == IO_INPUT_DECIMAL
+
+        text = ""
+        key = ""
+
+        while key != CANCEL
+          Device::Display.clear 2
+          Device::Display.print_line number_to_currency(text, options), 2, 0
+          key = getc
+          if key == BACK
+            text = text[0..-2]
+          elsif text.size >= max
+            next
+          elsif NUMBERS.include? key
+            text << key
+          elsif key == ENTER
+            return text
+          end
+        end
+      else
+        get_string(min, max, options[:mode])
+      end
+    end
+
+    # Read 1 byte on keyboard, wait until be pressed
+    #
+    # @param timeout [Fixnum] Timeout in milliseconds to wait for key.
+    #
+    # @return [String] key read from keyboard
+    def self.getc(timeout = 0); super(timeout); end
+  end
+end
+

data/lib/device/magnetic.rb

@@ -0,0 +1,79 @@
+class Device
+  class Magnetic
+    def self.adapter
+      Device.adapter::Magnetic
+    end
+
+    def adapter
+      Device.adapter::Magnetic
+    end
+
+    def self.read_card(timeout)
+      time = Time.now + (timeout.to_f / 1000.0)
+      magnetic = self.new
+      loop do
+        break if magnetic.swiped? || time <= Time.now
+      end
+      magnetic.tracks
+    ensure
+      magnetic.close if magnetic
+    end
+
+    HARDWARE_SUCCESSFUL_READ = 1
+    HARDWARE_NOT_READ        = 0
+    STATUS_SUCCESSFUL_READ = :success
+    STATUS_READ_TRACKS     = :read
+    STATUS_CLOSE           = :close
+    STATUS_OPEN            = :open
+    STATUS_OPEN_FAIL       = :open_fail
+
+    attr_reader :tracks, :track1, :track2, :track3, :status
+
+    def initialize
+      @status = STATUS_CLOSE
+      self.start
+    end
+
+    def start
+      if self.adapter.open == 1
+        @status = STATUS_OPEN
+        true
+      else
+        @status = STATUS_OPEN_FAIL
+        false
+      end
+    end
+
+    def swiped?
+      if self.read == HARDWARE_SUCCESSFUL_READ
+        @status = STATUS_SUCCESSFUL_READ
+        return true
+      end
+      false
+    end
+
+    def read
+      adapter.read
+    end
+
+    def close
+      adapter.close
+    end
+
+    def tracks
+      read_tracks unless @tracks
+      @tracks
+    end
+
+    private
+    def read_tracks
+      @tracks = adapter.tracks
+      @track1 = @tracks[:track1]
+      @track2 = @tracks[:track2]
+      @track3 = @tracks[:track3]
+
+      @status = STATUS_READ_TRACKS
+      @tracks
+    end
+  end
+end

data/lib/device/network.rb

@@ -0,0 +1,192 @@
+
+class Device
+  class Network
+
+    MEDIA_GPRS = "gprs"
+    MEDIA_WIFI = "wifi"
+
+    AUTH_NONE_OPEN       = "open"
+    AUTH_NONE_WEP        = "wep"
+    AUTH_NONE_WEP_SHARED = "wepshared"
+    AUTH_IEEE8021X       = "IEEE8021X"
+    AUTH_WPA_PSK         = "wpapsk"
+    AUTH_WPA_WPA2_PSK    = "wpawpa2psk"
+    AUTH_WPA2_PSK        = "wpa2psk"
+
+    PARE_CIPHERS_NONE   = "none"
+    PARE_CIPHERS_WEP64  = "wep64"
+    PARE_CIPHERS_WEP128 = "wep128"
+    PARE_CIPHERS_WEPX   = "wepx"
+    PARE_CIPHERS_CCMP   = "ccmp"
+    PARE_CIPHERS_TKIP   = "tkip"
+
+    MODE_IBSS    = "ibss"
+    MODE_STATION = "station"
+
+    TIMEOUT       = -3320
+    NO_CONNECTION = -1012
+    SUCCESS       = 0
+    PROCESSING    = 1
+
+    # Not Supported
+    #AUTH_WPA_EAP        = "wpa_eap"
+    #AUTH_WPA2_EAP       = "wpa2_eap"
+    #AUTH_WPA_WPA2_EAP   = "wpa_wpa2_eap"
+
+    class << self
+      attr_accessor :type, :apn, :user, :password, :socket, :socket_tcp, :socket_ssl, :ssl
+    end
+
+    def self.adapter
+      Device.adapter::Network
+    end
+
+    def self.init(type, options)
+      adapter.init(type, options)
+    end
+
+    def self.power(command)
+      adapter.power(command)
+    end
+
+    def self.connect
+      adapter.connect
+    end
+
+    def self.connected?
+      return NO_CONNECTION unless self.adapter.started?
+      adapter.connected?
+    end
+
+    def self.configured?
+      Device::Setting.network_configured == "1"
+    end
+
+    def self.ping(host, port)
+      adapter.ping(host, port)
+    end
+
+    def self.disconnect
+      adapter.disconnect
+    end
+
+    def self.dhcp_client(timeout)
+      time = Time.now + (timeout.to_f / 1000.0)
+      ret = adapter.dhcp_client_start
+      if (ret == SUCCESS)
+        ret = PROCESSING
+        while(ret == PROCESSING) # 1 - In process to attach
+          ret = adapter.dhcp_client_check
+          break ret = TIMEOUT unless (time >= Time.now)
+        end
+      end
+      ret
+    end
+
+    def self.handshake_ssl!
+      @socket_ssl = self.handshake_ssl(@socket_tcp)
+      @ssl = true
+      @socket = @socket_ssl
+    end
+
+    def self.handshake_ssl(tcp)
+      return if tcp.closed?
+      entropy = PolarSSL::Entropy.new
+      ctr_drbg = PolarSSL::CtrDrbg.new entropy
+      s_ssl = PolarSSL::SSL.new
+      s_ssl.set_endpoint PolarSSL::SSL::SSL_IS_CLIENT
+      s_ssl.set_rng ctr_drbg
+      s_ssl.set_socket tcp
+      s_ssl.handshake
+      s_ssl
+    end
+
+    def self.handshake!
+      handshake = "#{Device::System.serial};#{Device::System.app};#{Device::Setting.logical_number};#{Device.version}"
+      socket.write("#{handshake.size.chr}#{handshake}")
+
+      company_name = socket_tcp.closed? ? nil : socket.read(3)
+      return false if company_name == "err" || company_name.nil?
+
+      Device::Setting.company_name = company_name
+      true
+    end
+
+    # Create Socket in Walk Switch
+    def self.walk_socket
+      if @socket
+        @socket
+      else
+        @socket_tcp = create_socket
+        if Device::Setting.ssl == "1"
+          handshake_ssl!
+        else
+          @socket = @socket_tcp
+        end
+        handshake!
+        @socket
+      end
+    end
+
+    def self.create_socket
+      TCPSocket.new(Device::Setting.host, Device::Setting.host_port)
+    end
+
+    def self.close_socket
+      @socket.close
+      if @socket != @socket_tcp
+        @socket_tcp.close
+      end
+      @socket     = nil
+      @socket_tcp = nil
+      @socket_ssl = nil
+    end
+
+    def self.attach
+      Device::Network.init(*self.config)
+      ret = Device::Network.connect
+      ret = Device::Network.connected? if ret != SUCCESS
+      while(ret == PROCESSING)
+        ret = Device::Network.connected?
+      end
+      if ret == SUCCESS && wifi?
+        Device::Network.dhcp_client(20000)
+      end
+      ret
+    end
+
+    def self.config
+      # TODO raise some error if media was not set
+      [Device::Setting.media, self.config_media]
+    end
+
+    # TODO should check if WIFI, ETHERNET and etc
+    def self.config_media
+      if gprs?
+        {
+          apn:      Device::Setting.apn,
+          user:     Device::Setting.user,
+          password: Device::Setting.password
+        }
+      elsif wifi?
+        {
+          authentication: Device::Setting.authentication,
+          password:       Device::Setting.password,
+          essid:          Device::Setting.essid,
+          channel:        Device::Setting.channel,
+          cipher:         Device::Setting.cipher,
+          mode:           Device::Setting.mode
+        }
+      end
+    end
+
+    def self.gprs?
+      Device::Setting.media == "gprs"
+    end
+
+    def self.wifi?
+      Device::Setting.media == "wifi"
+    end
+  end
+end
+

data/lib/device/notification.rb

@@ -0,0 +1,116 @@
+class Device
+  class Notification
+    DEFAULT_TIMEOUT        = 15
+    DEFAULT_INTERVAL       = 10
+    DEFAULT_STREAM_TIMEOUT = 0
+
+    class << self
+      attr_accessor :callbacks, :current
+    end
+
+    self.callbacks = Hash.new
+
+    attr_reader :fiber, :timeout, :interval, :last_check, :stream_timeout
+
+    def self.check
+      self.current.check if self.current
+    end
+
+    def self.execute(event)
+      calls = self.callbacks[event.callback]
+      return unless calls
+      [:before, :on, :after].each do |moment|
+        calls.each{|callback| callback.call(event, moment)}
+      end
+    end
+
+    def self.schedule(callback)
+      self.callbacks[callback.description] ||= []
+      self.callbacks[callback.description] << callback
+    end
+
+    def self.config
+      notification_timeout        = Device::Setting.notification_timeout.empty? ? DEFAULT_TIMEOUT : Device::Setting.notification_timeout.to_i
+      notification_interval       = Device::Setting.notification_interval.empty? ? DEFAULT_INTERVAL : Device::Setting.notification_interval.to_i
+      notification_stream_timeout = Device::Setting.notification_stream_timeout.empty? ? DEFAULT_STREAM_TIMEOUT : Device::Setting.notification_stream_timeout.to_i
+      [notification_timeout, notification_interval, notification_stream_timeout]
+    end
+
+    def self.start
+      unless Device::Setting.logical_number.empty? || Device::Setting.company_name.empty? || (! Device::Network.connected?)
+        unless Device::Notification.current && Device::Notification.current.closed?
+          self.new(*self.config)
+        end
+      end
+    end
+
+    def self.setup
+      NotificationCallback.new "APP_UPDATE", :on => Proc.new { Device::ParamsDat.update_apps(true) }
+      NotificationCallback.new "SETUP_DEVICE_CONFIG", :on => Proc.new { Device::ParamsDat.update_apps(true) }
+      NotificationCallback.new "RESET_DEVICE_CONFIG", :on => Proc.new { Device::ParamsDat.format! }
+
+      NotificationCallback.new "SYSTEM_UPDATE", :on => Proc.new { |file| }
+      NotificationCallback.new "CANCEL_SYSTEM_UPDATE", :on => Proc.new { }
+    end
+
+    def initialize(timeout = DEFAULT_TIMEOUT, interval = DEFAULT_INTERVAL, stream_timeout = DEFAULT_STREAM_TIMEOUT)
+      @timeout        = timeout
+      @stream_timeout = stream_timeout
+      @interval       = interval
+      Device::Notification.current = self
+      @fiber = create_fiber
+    end
+
+    # Check if there is any notification
+    def check
+      if @fiber.alive? && valid_interval? && Device::Network.connected?
+        if (notification = @fiber.resume)
+          Notification.execute(NotificationEvent.new(notification))
+        end
+        @last_check = Time.now
+      end
+    end
+
+    # Close socket and finish Fiber execution
+    def close
+      @fiber.resume "close"
+    end
+
+    def closed?
+      ! @fiber.alive?
+    end
+
+    def valid_interval?
+      if @last_check
+        (@last_check + self.interval) < Time.now
+      else
+        true
+      end
+    end
+
+    private
+    def create_fiber
+      Fiber.new do
+        Serfx.connect(socket_block: socket_callback, timeout: timeout, stream_timeout: stream_timeout) do |conn|
+          conn.stream("user:#{Device::Setting.company_name};#{Device::Setting.logical_number}")
+        end
+        true
+      end
+    end
+
+    def socket_callback
+      Proc.new do
+        socket_tcp = Device::Network.create_socket
+        socket_tcp.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true)
+
+        if Device::Setting.ssl == "1"
+          socket = Device::Network.handshake_ssl(socket_tcp)
+        else
+          socket = socket_tcp
+        end
+        [socket, socket_tcp]
+      end
+    end
+  end
+end
+

data/lib/device/notification_callback.rb

@@ -0,0 +1,47 @@
+class Device
+  class NotificationCallback
+    attr_reader :on, :before, :after, :description
+    attr_accessor :results
+
+    CallbackResult = Struct.new(:before_execute, :result, :after_execute)
+
+    def initialize(description, procs = {})
+      @description = description
+      @on          = procs[:on]
+      @before      = procs[:before]
+      @after       = procs[:after]
+      @results     = {:on => [], :before => [], :after => []}
+      schedule!
+    end
+
+    def schedule!
+      Notification.schedule(self)
+    end
+
+    def call(event, moment = :on)
+      if support?(moment)
+        results[moment] << CallbackResult.new(
+          Time.now,
+          perform(event, moment),
+          Time.now
+        )
+      end
+    end
+
+    private
+    def perform(event, moment)
+      unless equal_arity?(event, moment)
+        return "Error Arity not Match: Event arity #{event.parameters.size} Proc arity #{send(moment).arity}"
+      end
+      self.send(moment).call(*event.parameters)
+    end
+
+    def support?(moment)
+      ! send(moment).nil?
+    end
+
+    def equal_arity?(event, moment)
+      send(moment).arity == event.parameters.size
+    end
+  end
+end

data/lib/device/notification_event.rb

@@ -0,0 +1,29 @@
+class Device
+  class NotificationEvent
+    attr_reader :values, :coalesce, :ltime, :payload, :name, :event, :message, :value, :body, :callback, :parameters
+
+    def initialize(values)
+      @values = values
+      parse(values)
+    end
+
+    def type
+      @event
+    end
+
+    private
+    def parse(values)
+      @coalesce = values["Coalesce"]
+      @ltime    = values["LTime"]
+      @payload  = values["Payload"]
+      @name     = values["Name"]
+      @event    = values["Event"]
+
+      @message  = payload.gsub('=>', ' : ')
+      @value    = JSON.parse(message)
+      @body     = value["Body"]
+
+      @callback, *@parameters = @body.to_s.split("|")
+    end
+  end
+end