framework_gem 0.1.0

data/lib/lib/platform/passport/passport.rb

@@ -0,0 +1,41 @@
+require './lib/platform/platform'
+require './lib/screens/passport/passport_screens'
+require './lib/rois/passport/passport_rois'
+require './lib/keys/passport/passport_keys'
+
+# Adds to or modifies the platform with Passport-specific functionality.
+
+class Passport < Platform
+
+  # Public: Initializes a Passport device.
+  def initialize(*args)
+    super(*args)
+    @screens = PassportScreens.new(self)
+    @roi = PassportRois.new(self)
+    set_keys(PassportKeys.new)
+  end
+
+  # Public: Initializes the Passport and brings it to the Live TV screen.
+  #
+  # Returns a Boolean true if the device was initialized, otherwise false.
+  def init?
+    super do
+      tries = 2
+      count = 0
+      while (tries > count) do
+        if has_power? 
+          return true
+        elsif power_on
+          sleep(2000)
+          #do nothing
+        end
+      end
+
+      if has_power? 
+        return true
+      else
+        return false
+      end
+    end
+  end
+end

data/lib/lib/platform/passport/passport1080/passport_1080.rb

@@ -0,0 +1,15 @@
+require './lib/platform/passport/passport'
+require './lib/rois/passport/passport_1080/passport_1080_rois'
+
+# Adds to or modifies the Passport platform with 1080p-specific functionality.
+
+class Passport1080 < Passport
+
+  # Public: Initializes an Passport 1080p device.
+  def initialize(*args)
+    super(*args)
+    @roi = Passport1080Rois.new(self)
+  end
+
+end
+

data/lib/lib/platform/passport/passport_720/passport_720.rb

@@ -0,0 +1,14 @@
+require './lib/platform/passport/passport'
+require './lib/rois/passport/passport_720/passport_720_rois'
+
+# Adds to or modifies the Passport platform with 720p-specific functionality.
+
+class Passport720 < Passport
+
+  # Public: Initializes an Passport 720p device.
+  def initialize(*args)
+    super(*args)
+    @roi = Passport720Rois.new(self)
+  end
+
+end

data/lib/lib/platform/platform.rb

@@ -0,0 +1,884 @@
+require './lib/screens/screens'
+require './lib/rois/rois'
+require './lib/keys/base_keys'
+require './lib/remotes/remotes'
+require './lib/test_case/test_case'
+require 'tmpdir'
+
+# The Platform class contains DUT behaviors. It should define all cross-platform methods as stubs which call
+# `raise_not_implemented'.
+
+class Platform
+
+  attr_reader(:id, :screens, :roi, :keys, :remotes)
+
+  # Public: Initializes a new Platform. NOT FOR USE IN TESTS.
+  #
+  # Returns nothing.
+  def initialize(test_case, id: nil, config: nil)
+    # Default the test case attribute to a new Object. The screens initialized for syntax eval delegate to this
+    # attribute, so if it is nil, then they will have no methods; if it is a TestCase, then they will have all the
+    # test case methods in addition to their own. A blank Object is best as it will have only the screen methods.
+    @test_case = test_case || Object.new
+    @platform = nil
+    @model = nil
+    @ip_address = nil
+    @mac_address = nil
+    @id = id
+    @remotes = Remotes.new
+    @remote_type = nil
+    @screens = Screens.new(self)
+    @roi = Rois.new(self)
+    @key_presser = nil
+    @keys = nil
+    set_keys(BaseKeys.new)
+    @resolution = nil
+    @config = config
+    @initted = false
+    @name = nil
+  end
+
+  # Public: Gets the device slot.
+  #
+  # Returns the Integer device slot or nil.
+  def slot
+    @id
+  end
+
+  # Public: Presses keys. When no arguments are given, this returns the key presser, which defines methods for all of
+  #         the valid keys for this platform. See examples.
+  #
+  # Examples
+  #
+  #   press_key.ARROW_DOWN
+  #   # => nil
+  #
+  #   press_key.NUM_3(:sleep_time => 1.sec)
+  #   # => nil
+  #
+  #   press_key('0123', :delay_between_keys => 250.ms, :sleep_time => 5.sec)
+  #   # => nil
+  #
+  # Returns the key presser or the Time at which the key(s) were pressed.
+  def press_key(*args)
+    if args.empty?
+      @key_presser
+    else
+      keys = args[0]
+      raise 'Key cannot be nil.' if keys.empty? || keys.nil?
+      args = args.fetch(1, {})
+      delay_between_keys = args.fetch(:delay_between_keys, 500.ms)
+      sleep_time = args.fetch(:sleep_time, 3.sec)
+      if keys.is_a?(Integer) || keys =~ /\A\d+\z/
+        keys = keys.to_s.chars.to_a
+        keys << 'select' if keys.length > 1 && keys.length < 4 && self.class <= Stb
+      end
+      unless keys.is_a?(Array)
+        keys = [keys]
+      end
+      logger.keypress(keys, message: %Q(Pressing keys: #{keys.join(', ')}))
+      json_keys = keys.each_with_index.map do |k, i|
+        {key: "KEY_#{k}".upcase, delayMs: (i + 1) == keys.count ? 0.ms : delay_between_keys}
+      end
+      resp = @test_case.send(:tmc_put, '/api/ir/send', json: 
+        {devices: [@id], remote: @remote_type, irData: json_keys, script: @test_case.send(:path)})
+      sleep(sleep_time)
+      resp['stop'].to_time
+    end
+  end
+
+  # Public: Checks if the device has physical power.
+  #
+  # Returns Boolean true if device has physical power, otherwise false.
+  def has_power?
+    resp = @test_case.send(:tmc_get, "/api/power/#{@id}")
+    resp['state']
+  end
+
+  # Public: Powers on the device.
+  #
+  # Returns nothing.
+  def power_on
+    @test_case.send(:tmc_put, "/api/power/#{@id}", :json => {:state => true})
+  end
+
+  # Public: Powers off the device.
+  #
+  # Returns nothing.
+  def power_off
+    @test_case.send(:tmc_put, "/api/power/#{@id}", :json => {:state => false})
+  end
+
+  # Public: Power cycles the device.
+  #
+  # delay - Integer milliseconds to wait before powering the device on again (default: 3.sec).
+  #
+  # Returns nothing.
+  def power_cycle(args={})
+    power_off
+    sleep(args.fetch(:delay, 3.sec))
+    power_on
+  end
+
+  # Public: Powers on the device via remote control.
+  #
+  # Returns a Boolean true if the device powered on successfully, otherwise false.
+  # Raises an Exception with a "Not implemented!" message if it is not implemented by this platform.
+  def power_on?
+    raise_not_implemented(__method__)
+  end
+
+  # Public: Checks if the device is HD.
+  #
+  # Returns a Boolean true if the device is HD, otherwise false.
+  def high_def?
+    h = resolution[:height]
+    [720, 1080].include?(h)
+  end
+
+  # Public: Saves the last captured dut screen to disk.
+  #
+  # filename - String desired path to the file, relative to the test image folder (default: nil).
+  #            If default, generates a filename like 'device_<id>_<timestamp>.jpg'.
+  # format   - Symbol desired format, can be :raw, :base64 (default: nil).
+  #
+  # Returns the String path to the file relative to the test image folder, or image data in the desired format.
+  def save_last_screen_captured(args={})
+    capture_screen(args.merge(_last_captured: true))
+  end
+
+  # Public: Captures the dut screen to disk.
+  #
+  # filename - String desired path to the file, relative to the test image folder (default: nil).
+  #            If default, generates a filename like 'device_<id>_<timestamp>.jpg'.
+  # format   - Symbol desired format, can be :raw, :base64 (default: nil).
+  # size     - Integer desired image size as a percent of original dimensions from 0 - 100 (default: nil).
+  # quality  - Integer desired quality as a percent 0 - 100 (default: nil).
+  #
+  # Returns the String path to the file relative to the test image folder, or image data in the desired format.
+  def capture_screen(args={})
+    if self.class <= Web
+      # special case for web platform
+      meth = :selenium
+    else
+      # other platforms
+      meth = nil
+    end
+    format = args[:format]
+    filename = args[:filename]
+    last_captured = args.fetch(:_last_captured, false)
+    unless filename.nil?
+      logger.warn('`filename\' parameter deprecated and will be removed in future release.', tag: :DEPRECATED)
+      raise 'Filename must end in .jpg!' unless filename.end_with?('.jpg')
+    end
+    case meth
+      when :selenium
+        # take screenshot via selenium
+        resp = self.send(:selenium_request, :post, 'screenshot', {})
+      else
+        # platform default
+        json = get_json_for_iter.merge(path: filename, fromStash: last_captured)
+        json[:percentSize] = args[:size] if args.key?(:size)
+        json[:quality] = args[:quality] if args.key?(:quality)
+        resp = @test_case.send(:tmc_post, "/api/images/#{@id}", json: json)
+    end
+    if resp.nil?
+      if last_captured
+        logger.warn('No last screen capture to save', screenshot: false)
+        return nil
+      else
+        raise 'Failed to capture screen!'
+      end
+    end
+    path = resp['path'].gsub('\\', '/')  # just in case
+    if format.nil?
+      path
+    else
+      resp = @test_case.send(:tmc_get, "/api/images/#{path}?job=#{@test_case.job}&test=#{@test_case.id}", attr: :body)
+      if format == :base64
+        Base64.encode64(resp)
+      elsif format == :raw
+        resp
+      end
+    end
+  end
+
+  # Public: Uploads a screenshot to the reporting system.
+  #
+  # filename - String path to an existing screenshot (default: nil).
+  #            If default, a new screenshot will be captured.
+  #
+  # Returns nothing.
+  def upload_screenshot(args={})
+    case test_case.options[:reporting_mode]
+      when 'twb' # send it to twb
+        twb_post_screenshot(:ss_filename => args[:filename])
+      else # send it to SWORD
+        sword_attach_screenshot("Screenshot from TMC slot #{@id}", nil, args[:filename])
+    end
+  end
+
+  # Public: Checks if the device is generic.
+  #
+  # Returns a Boolean true if the device is generic, otherwise false.
+  def is_generic?
+    @platform.nil?
+  end
+
+  # Public: Gets the current device resolution, retrieving it first if necessary.
+  #
+  # update - Boolean indicating whether to force update of resolution (default: false).
+  #
+  # Returns the resolution as a Hash of :width, :height.
+  def resolution(update: false)
+    if @resolution.nil? || update
+      resp = @test_case.send(:tmc_get, "/api/video/info?devices=#{@id}")
+      video_inf = resp['videoInfo'][0]
+      @resolution = {width: video_inf['width'], height: video_inf['height']}
+    end
+    @resolution
+  end
+
+  # Public: Resets video on the dut. This should be called after changing resolution on a device.
+  #
+  # Returns nothing.
+  def reset_video
+    logger.info("Resetting video on slot #{@id}")   
+    @test_case.send(:tmc_put, "/api/video/reset/#{@id}", :json => {})
+  end
+
+  # Public: Gets the specified SNMP object from the dut.
+  #
+  # object          - String object OID to retrieve.
+  # port            - Integer SNMP port (default: 161).
+  # trap_port       - Integer SNMP trap port (default: 162).
+  # community       - String SNMP community string (default: 'public').
+  # write_community - String SNMP community string (default: 'public').
+  # version         - Symbol SNMP version (default: :SNMPv2c).
+  # timeout         - Integer timeout in seconds (default: 1).
+  # retries         - Integer retries (default: 5).
+  # transport       - Class SNMP transport (default: UDPTransport).
+  # max_recv_bytes  - Integer maximum receive bytes (default: 8000).
+  # use_IPv6        - Boolean indicating whether to use IPv6 (default: false).
+  #                   True if :host is formatted like an IPv6 address.
+  #
+  # Returns a String of value retrieved.
+  def snmp_get(object, args={})
+    @test_case.snmp_get(ip_address, object, args)
+  end
+
+  # Public: Sets the specified SNMP object on the dut.
+  #
+  # object          - String object OID to set.
+  # value           - String value to set.
+  # port            - Integer SNMP port (default: 161).
+  # trap_port       - Integer SNMP trap port (default: 162).
+  # community       - String SNMP community string (default: 'public').
+  # write_community - String SNMP community string (default: 'public').
+  # version         - Symbol SNMP version (default: :SNMPv2c).
+  # timeout         - Integer timeout in seconds (default: 1).
+  # retries         - Integer retries (default: 5).
+  # transport       - Class SNMP transport (default: UDPTransport).
+  # max_recv_bytes  - Integer maximum receive bytes (default: 8000).
+  # use_IPv6        - Boolean indicating whether to use IPv6 (default: false).
+  #                   True if :host is formatted like an IPv6 address.
+  #
+  # Returns the result.
+  def snmp_set(object, value, args={})
+    @test_case.snmp_set(ip_address, object, value, args)
+  end
+
+  # Public: Gets the MAC address for the dut.
+  #  Format is xx:xx:xx:xx:xx:xx
+  #
+  # Returns String MAC address.
+  def mac_address
+    if @mac_address.nil? && !config['macAddress'].nil?
+      @mac_address = config['macAddress']
+      if @mac_address.length.eql?(12)
+        # add separator
+        @mac_address = @mac_address.split(/(\w{2})/).select{|x| !x.empty?}.join(':')
+      end
+    end
+    @mac_address
+  end
+
+  # Public: Gets the IP address for the dut.
+  #  Format is xxx.xxx.xxx.xxx
+  #
+  # Returns String IP address.
+  def ip_address
+    if @ip_address.nil?
+      @ip_address = config['ipAddress']
+    end
+    @ip_address
+  end
+
+  # Public: Gets the current device resolution width.
+  #
+  # Returns the Integer width in pixels.
+  def width
+    resolution[:width]
+  end
+
+  # Public: Gets the current device resolution height.
+  #
+  # Returns the Integer height in pixels.
+  def height
+    resolution[:height]
+  end
+
+  # Public: Gets the platform name for the dut.
+  #
+  # Returns String platform.
+  def platform
+    if @platform.nil?
+      @platform = config['platform']
+    end
+    @platform
+  end
+
+  # Public: Gets the current device model.
+  #
+  # Returns the String model name.
+  def model
+    if @model.nil?
+      @model = config['model']
+    end
+    @model
+  end
+
+  # Public: Gets the current device entitlements.
+  #
+  # Returns an Array of String entitlement package names.
+  def entitlements
+    if @entitlements.nil?
+      @entitlements = config['entitlements']
+    end
+    @entitlements
+  end
+  
+  # Public : Gets the name for the dut.
+  #
+  # Returns the String device name.
+  def name
+    if @name.nil?
+      @name = config['name']
+    end
+    @name
+  end
+
+  # Public: Checks if the device type is one of those given.
+  #
+  # device_types - Splat Array of String or Symbol device types to check.
+  #
+  # Returns a Boolean true if the device type is in the provided list, otherwise false.
+  def device_type_is?(*device_types)
+    device_types.include?(model.to_sym)
+  end
+
+  # Public: Checks if the device type is NOT one of those given.
+  #
+  # device_types - Splat Array of String or Symbol device types to check.
+  #
+  # Returns a Boolean true if the device type is NOT in the provided list, otherwise false.
+  def device_type_not?(*device_types)
+    !device_type_is?(*device_types)
+  end
+
+  # Public: Gets the device software version.
+  #
+  # Returns the String software version.
+  def software_version
+    # Search for a software version defined in script options, in order of specificity.
+    # Try the device type first.
+    device_type_key = "#{platform}_software_version".downcase.to_sym
+    if @test_case.options.include?(device_type_key)
+      @test_case.options[:build_code] = @test_case.options[device_type_key]
+    end
+    # Next, try the platform hierarchy.
+    cls = self.class
+    loop do
+      platform_key = "#{cls.name}_software_version".downcase.to_sym
+      if @test_case.options.include?(platform_key)
+        @test_case.options[:build_code] = @test_case.options[platform_key]
+        break
+      end
+      break if cls == Platform || cls == cls.superclass
+      cls = cls.superclass
+    end
+    # Next, try the base app_version.
+    if @test_case.options.include?(:software_version)
+      @test_case.options[:build_code] = @test_case.options[:software_version]
+    end
+    # Finally, default to build_code.
+    @test_case.options[:build_code]
+  end
+
+  # Deprecated: Use software_version instead.
+  def app_version
+    software_version
+  end
+
+  # Public: Gets the DUT username from test data.
+  #   Expected format: "dut_credentials": {1: {username: 'foo', ...}}
+  #
+  # Returns the String username.
+  def username
+    creds[:username]
+  end
+
+  # Public: Gets the DUT password from test data.
+  #   Expected format: "dut_credentials": {1: {..., password: 'baz'}}
+  #
+  # Returns the String password.
+  def password
+    creds[:password]
+  end
+
+  # Public: Gets the parental controls PIN. Must be implemented by each Platform subclass.
+  #
+  # Returns the String parental controls PIN.
+  def parental_controls_pin
+    $parental_controls_pin || '0000'
+  end
+
+  # Public: Gets the alternate parental controls PIN. Must be implemented by each Platform subclass.
+  #
+  # Returns the String alternate parental controls PIN.
+  def alt_parental_controls_pin
+    $alt_parental_controls_pin || '1111'
+  end
+
+
+  # Public: Initializes the device. Must be implemented by each Platform subclass.
+  #
+  # block -- Block that performs initialization.
+  #
+  # Returns a Boolean true if the device was initialized, otherwise false.
+  def init?(&block)
+    return true if @initted  # no-op if already initted
+    unless has_power?
+      power_on  # platforms should override this, call super, and add whatever wait/verification is needed
+    end
+    @initted = block.call
+  end
+
+  # Public: Checks if audio is present on the device.
+  #
+  # threshold     - Integer threshold 0 - 32k audio level must exceed to be considered present (default: 0).
+  # sample_length - Integer milliseconds to sample audio (default: 5000).
+  #
+  # Returns a Boolean true if audio is present, otherwise false.
+  def audio_present?(args={})
+    threshold = args.fetch(:threshold, 0)
+    lvl = audio_level(args)
+    lvl > threshold
+  end
+
+  # Public: Gets audio level from the device.
+  #
+  # sample_length - Integer milliseconds to sample audio (default: 5000).
+  # threshold - Integer unit of PCM to return no audio. Humans can't hear under 1000 (default: 100)
+  #
+  # Returns the Integer peak audio level 0 - 32k, where 0 indicates no audio,
+  #   or nil if the level could not be determined.
+  def audio_level(args={})
+    lvls = audio_levels(args)
+    lev = [lvls[:left], lvls[:right]].max
+    (lev > args.fetch(:threshold, 100)) ? lev : 0
+  end
+
+  # Public: Gets left channel audio level from the device.
+  #
+  # sample_length - Integer milliseconds to sample audio (default: 5000).
+  #
+  # Returns the Integer peak audio level of the left channel 0 - 32k, where 0 indicates no audio,
+  #   or nil if the level could not be determined.
+  def audio_level_left(args={})
+    audio_levels(args)[:left]
+  end
+
+  # Public: Gets right channel audio level from the device.
+  #
+  # sample_length - Integer milliseconds to sample audio (default: 5000).
+  #
+  # Returns the Integer peak audio level of the right channel 0 - 32k, where 0 indicates no audio,
+  #   or nil if the level could not be determined.
+  def audio_level_right(args={})
+    audio_levels(args)[:right]
+  end
+
+  # Public: Captures audio on the device.
+  #
+  # duration - Integer total milliseconds to capture audio.
+  # key      - String name or Array of keys to press to trigger audio capture (default: nil).
+  #            If default, no keys will be pressed.
+  # delay    - Integer milliseconds to delay after pressing key and before starting frame capture (default: 0).
+  # cleanup  - Boolean indicating whether to automatically clean up audio during teardown (default: true).
+  #
+  # Returns a Hash with the following keys:
+  # :audio      - String path to audio file.
+  # :start_time - Time at which audio capture began.
+  def capture_audio(duration, args={})
+    key = args[:key]
+    delay = args.fetch(:delay, 0)
+    cleanup = args.fetch(:cleanup, true)
+    press_key(key) unless key.nil?
+    ret = {audio: nil, start_time: Time.now}
+    sleep(delay) if delay > 0
+    json = get_json_for_iter.merge(block: true, durationMs: duration)
+    resp = @test_case.send(:tmc_post, "/api/audio/record/#{id}", json: json)
+    ret[:audio] = resp['filename']
+    if cleanup && !ret[:audio].nil?
+      @test_case.add_teardown('Cleaning up captured audio') do
+        delete_files = [ ret[:audio] ]
+        @test_case.send(:tmc_delete, '/api/audio', json: get_json_for_test.merge(files: delete_files))
+      end
+    end
+    ret
+  end
+
+  # Public: Records audio on the device.
+  #
+  # duration - Integer total milliseconds to record audio. Required if block or window is true (default: nil).
+  # block    - Boolean block until the recording is finished (default: true).
+  # window   - Boolean limit recording length to the specified duration (default: true).
+  # format   - String desired audio format, can be 'mp3', 'wav', 'wma' (default: 'mp3').
+  #
+  # Returns a Hash with the following keys:
+  # :id         - String unique identifier for the recording.
+  # :path       - String path to the recording on the server.
+  # :start_time - Time at which recording began.
+  # :end_time   - Time at which recording stopped.
+  def record_audio(duration: nil, block: true, window: true, format: 'mp3')
+    record_media(:audio, duration, block, window, format)
+  end
+
+  # Public: Stops audio recording on the device.
+  #
+  # id - String unique identifier for the recording to stop.
+  #
+  # Returns a Hash with the following keys:
+  # :id         - String unique identifier for the recording.
+  # :path       - String path to the recording on the server.
+  # :start_time - Time at which recording began.
+  # :end_time   - Time at which recording stopped.
+  def stop_audio(id)
+    stop_media(:audio, id)
+  end
+
+  # Public: Records video on the device.
+  #
+  # duration - Integer total milliseconds to record video. Required if block or window is true (default: nil).
+  # block    - Boolean block until the recording is finished (default: true).
+  # window   - Boolean limit recording length to the specified duration (default: true).
+  # format   - String desired video format, can be 'mp4', 'avi', 'wmv' (default: 'mp4').
+  #
+  # Returns a Hash with the following keys:
+  # :id         - String unique identifier for the recording.
+  # :path       - String path to the recording on the server.
+  # :start_time - Time at which recording began.
+  # :end_time   - Time at which recording stopped.
+  def record_video(duration: nil, block: true, window: true, format: 'mp4')
+    record_media(:video, duration, block, window, format)
+  end
+
+  # Public: Stops video recording on the device.
+  #
+  # id - String unique identifier for the recording to stop.
+  #
+  # Returns a Hash with the following keys:
+  # :id         - String unique identifier for the recording.
+  # :path       - String path to the recording on the server.
+  # :start_time - Time at which recording began.
+  # :end_time   - Time at which recording stopped.
+  def stop_video(id)
+    stop_media(:video, id)
+  end
+
+  # Public: Captures frames on the device.
+  #
+  # duration     - Integer total milliseconds to capture frames.
+  # key          - String name or Array of keys to press to trigger audio capture (default: nil).
+  #                If default, no keys will be pressed.
+  # delay        - Integer milliseconds to delay after pressing key and before starting frame capture (default: 0).
+  # cleanup      - Boolean indicating whether to automatically clean up frames during teardown (default: true).
+  #                If true, all frames in the output which have :keep => false will be deleted at the end of the test.
+  #
+  # Returns a Hash with the following keys:
+  # :frames     - Array of captured frames, each being a Hash with the following keys:
+  #               :filename   - String full path to the frame on the server.
+  #               :capturedAt - Time at which the frame was captured.
+  #               :keep       - Boolean indicating whether to keep the frame if cleanup is true. Initializes false.
+  # :start_time - Time at which frame capture began.
+  def capture_frames(duration, args={})
+    key = args[:key]
+    cleanup = args.fetch(:cleanup, true)
+    frames = []
+    if cleanup
+      @test_case.add_teardown('Cleaning up captured frames', frames) do |frame_arr|
+        delete_files = frame_arr.reject { |frm| frm[:keep] }.map { |frm| frm[:filename] }
+        json = get_json_for_test.merge(files: delete_files)
+        @test_case.send(:tmc_delete, '/api/images', json: json)
+      end
+    end
+    # Capture frames
+    delay = args.fetch(:delay, 0)
+    ret = {}
+    if key.nil?
+      # this is the best we can do since there is no key. as long as the script runs locally on the TMC,
+      # we do not need to worry about clock drift issues
+      ret[:start_time] = Time.now
+    else
+      # use the key press time
+      ret[:start_time] = press_key(key, sleep_time: 0) unless key.nil?
+    end
+    if delay > 0
+      sleep(delay)
+    end
+    json = get_json_for_iter.merge(durationMs: duration)
+    result = @test_case.send(:tmc_post, "/api/images/record/#{@id}", json: json)
+    raise 'Failed to capture frames!' if result.nil?
+    #ret[:start_time] ||= @test_case.to_time(result['startTime'])  # use this start time ONLY if no key and no delay
+    result.fetch('images').each do |frm|
+      capture_time = frm.fetch('captureTime')
+      capture_time = capture_time / 1000.0 unless capture_time.is_a?(String)
+      frames << {filename: frm.fetch('path'), capturedAt: @test_case.to_time(capture_time), keep: false}
+    end
+    ret[:frames] = frames
+    # Calculate average FPS and maximum/average margin of error
+    max_i, max = [0, 0]
+    frame_deltas = frames.each_with_index.map do |f, i|
+      if i == 0
+        delta = @test_case.get_time_delta(ret[:start_time], f[:capturedAt])
+      else
+        delta = @test_case.get_time_delta(frames[i - 1][:capturedAt], f[:capturedAt])
+      end
+      if delta > max
+        max_i, max = [i, delta]
+      end
+      delta
+    end
+    deltas_sum = frame_deltas.inject(0) {|sum, x| sum + x}
+    sec = deltas_sum / 1000.0
+    avg_fps = frames.count / sec
+    avg_delta = deltas_sum / frame_deltas.count
+    logger.debug("Captured #{frames.count} frames in #{sec} s [avg frames/s: #{avg_fps}, " +
+                     "max error: #{max} ms (frame #{max_i}), avg error: #{avg_delta} ms]")
+    ret
+  end
+
+  # Public: Locks the specified resource to perform an action.
+  #
+  # resource   - String resource to lock.
+  # timeout    - Integer lock timeout in milliseconds.
+  # block      - Block to perform..
+  #
+  # Returns the result of the specified block.
+  def lock(resource, timeout, &block)
+    @test_case.lock(resource, timeout, device: @id, &block)
+  end
+
+  # Public: Checks if the current remote type matches the given type.
+  #
+  # type - String remote type to check. Available remotes can be retrieved from `dut.remotes'.
+  #
+  # Returns a Boolean true if the remote type matches, otherwise false.
+  def remote_type_is?(type)
+    if @remote_type.nil?
+      @remote_type = config['remoteType']
+    end
+    @remote_type == type
+  end
+
+  # Public: Sets the remote type for the dut. This persists only for the current script. To configure the remote type
+  #  permanently, the device configuration must be updated.
+  #
+  # type - String remote type to set. Available remotes can be retrieved from `dut.remotes'.
+  #
+  # Returns nothing.
+  def remote_type=(type)
+    unless remote_type_is?(type)
+      @remote_type = type
+    end
+  end
+
+  private
+
+  # Internal: Gets DUT credentials from test data.
+  def creds
+    if @creds.nil?
+      creds = @test_case.test_data.fetch(:dut_credentials, []).find {|c| c[0] == @id}
+      if creds.nil?
+        return {}
+      else
+        @creds = creds[1]
+      end
+    end
+    @creds
+  end
+
+  # Internal: Starts recording the specified media type.
+  def record_media(type, duration, block, window, format)
+    json = get_json_for_iter
+    json[:durationMs] = duration unless duration.nil?
+    json[:block] = block
+    json[:window] = window
+    json[:format] = format unless format.nil?
+    result = @test_case.send(:tmc_post, "/api/#{type}/record/#{@id}", json: json)
+    ret = @test_case.rubify(result)
+    begin
+      # always stop recording during teardown
+      if type == :video
+        recordings_attr = :@video_recording_ids
+      elsif type == :audio
+        recordings_attr = :@audio_recording_ids
+      else
+        raise 'Invalid media type!'
+      end
+      @test_case.instance_variable_get(recordings_attr)[ret[:id]] = @id
+      if block
+        log_and_upload_media(type, ret)
+      end
+    ensure
+      if block
+        json = get_json_for_test.merge(files: [ret[:path]])
+        @test_case.send(:tmc_delete, "/api/#{type}", json: json)
+      end
+    end
+    ret
+  end
+
+  # Internal: Stops recording the specified media.
+  def stop_media(type, id)
+    result = @test_case.send(:tmc_delete, "/api/#{type}/record/#{@id}", json: {id: id})
+    ret = @test_case.rubify(result)
+    begin
+      if type == :video
+        recordings_attr = :@video_recording_ids
+      elsif type == :audio
+        recordings_attr = :@audio_recording_ids
+      else
+        raise 'Invalid media type!'
+      end
+      @test_case.instance_variable_get(recordings_attr).delete(id)
+      log_and_upload_media(type, ret)
+    ensure
+      json = get_json_for_test.merge(files: [ret[:path]])
+      @test_case.send(:tmc_delete, "/api/#{type}", json: json)
+    end
+    ret
+  end
+
+  # Internal: Logs recording details and uploads the specified media.
+  def log_and_upload_media(type, response)
+    path = response[:path]
+    full_path = response[:full_path]
+    download_path = nil
+    name = File.join('tmc', 'jobs', @test_case.job, @test_case.id.to_s, File.basename(path))
+    unless File.exists?(full_path)
+      # The file does not exist locally. Download it.
+      media_resource = "/api/#{type}/play/#{path.gsub('\\', '/')}?job=#{@test_case.job}&test=#{@test_case.id}"
+      data = @test_case.send(:tmc_get, media_resource, :attr => :body)
+      dl_dir = Dir.mktmpdir
+      download_path = File.join(dl_dir, File.basename(path))
+      File.open(download_path, 'wb') {|f| f.write(data)}
+    end
+    begin
+      response[:url] = @test_case.aws_upload_s3(ENV['AWS_DEFAULT_BUCKET'], name, download_path || full_path)
+      duration_ms = @test_case.get_time_delta(response[:start_time], response[:end_time])
+      logger.info("Recorded #{duration_ms / 1000.0} seconds of #{type}", screen_image: response[:url])
+    ensure
+      unless download_path.nil?
+        File.delete(download_path)
+      end
+    end
+  end
+
+  # Internal: Calls the test case sleep method.
+  def sleep(*args)
+    test_case.sleep(*args)
+  end
+
+  # Internal: Gets a handle to the test case logger.
+  def logger
+    test_case.send(:logger_for_device, @id)
+  end
+
+  # Internal: Gets device config.
+  def config
+    if @config.nil?
+      resp = @test_case.send(:tmc_get, "/api/config/hardware/devices?devices=#{@id}")
+      @config = resp['devices'].first
+    end
+    @config
+  end
+
+  # Internal: Gets JSON for job and test.
+  def get_json_for_test
+    {job: @test_case.job, test: @test_case.id}
+  end
+
+  # Internal: Gets JSON for job, test, and iteration.
+  def get_json_for_iter
+    get_json_for_test.merge(iteration: @test_case.iteration)
+  end
+
+  # Internal: Gets audio levels from the device.
+  #
+  # sample_length - Integer milliseconds to sample audio (default: 5000).
+  #
+  # Returns a Hash of the peak audio levels with keys :left and :right.
+  def audio_levels(args={})
+    duration = args.fetch(:sample_length, 5.sec)
+    resp = @test_case.send(:tmc_get, "/api/audio/levels/#{@id}?sampleLength=#{duration.to_f / 1000}")
+    lvls = {
+        left: resp['leftPeak'].abs,
+        right: resp['rightPeak'].abs
+    }
+    logger.debug("Got audio levels [ L: #{lvls[:left]}, R: #{lvls[:right]} ]", tag: 'AUDIO')
+    lvls
+  end
+
+  # Internal: Raises a "not implemented" exception for the given method.
+  #
+  # Returns nothing.
+  # Raises an Exception with a "not implemented" message.
+  def raise_not_implemented(method)
+    raise "(#{self.class}.#{method} not implemented!"
+  end
+
+  # Internal: Exposes the TestCase object.
+  #
+  # Returns the TestCase object.
+  def test_case
+    @test_case
+  end
+
+  # Internal: Exposes the service reference.
+  #
+  # Returns the service reference.
+  def service
+    @test_case.send(:service)
+  end
+
+  # Internal: Assigns the keys instance.
+  #
+  # Returns nothing.
+  def set_keys(keys_obj)
+    if @key_presser.nil?
+      @key_presser = Class.new.new
+      @key_presser.instance_variable_set(:@kp_dut, self)
+    end
+    @keys = keys_obj
+    @keys.instance_variable_get(:@enum).each do |k,v|
+      press_this_key = Proc.new do |*a|
+        kwargs = {:sleep_time => 0.sec}.update(a.last || {})
+        @kp_dut.press_key(v, kwargs)
+      end
+      @key_presser.class.send(:define_method, k, press_this_key)
+    end
+  end
+
+end