adb_driver 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cc283d720879afb304052b394d127b396c971ff784cb0d6dab39051cc50f88c7
+  data.tar.gz: ad04b403c6f63cce562a78150d7db53f7b8eabb8e89d5aeb1d27732377c3e6ba
+SHA512:
+  metadata.gz: 790517ac22172520ee9b870cc5a290ae7cb32668b2a5e9be231db9996d9a51f0a5733bbf2245a5439c942b7603977bb0954b38adaf35bfd6f9d38b6a39869581
+  data.tar.gz: d446dd2027f102329d4c00ac0f432e476eb965136a6328681830bc714ec92c571e5dca6fc5ae2ac8e5d8f4251cf2abd5c4d4c21c9e136291acde77a6d2c52a73

data/lib/adb_driver.rb

@@ -0,0 +1,11 @@
+require_relative 'adb_driver/wait'
+
+require_relative 'adb_driver/element'
+require_relative 'adb_driver/finder'
+require_relative 'adb_driver/driver'
+require_relative 'adb_driver/navigation'
+require_relative 'adb_driver/error'
+
+require_relative 'adb_driver/dsl'
+require_relative 'adb_driver/source_cleaner'
+require_relative 'adb_driver/adb'

data/lib/adb_driver/adb.rb

@@ -0,0 +1,123 @@
+require 'timeout'
+
+module Adb
+  extend Timeout
+  extend self
+
+  def execute_command(command, timeout_in_seconds = 10)
+    timeout(timeout_in_seconds) { `adb #{command}` }
+  end
+
+  def app_version(package_name)
+    output = execute_command("shell dumpsys package #{package_name}")
+    version_line = output.lines.grep(/versionName/).first.strip
+    version_line[/=(.*)/, 1]
+  end
+
+  def package_exists?(package_name)
+    execute_command('shell pm list packages').lines.grep(/#{package_name}\s*$/).one?
+  end
+
+  def android_5_or_greater?
+    android_version[0].to_i >= 5
+  end
+
+  def android_6_or_greater?
+    android_version[0].to_i >= 6
+  end
+
+  def android_6?
+    android_version.start_with?('6')
+  end
+
+  def android_7?
+    android_version.start_with?('7')
+  end
+
+  def real_device?
+    output = execute_command('devices -l')
+    output = output.lines.grep(/#{ENV['ANDROID_SERIAL']}/).first
+    output.include?('usb')
+  end
+
+  def emulator?
+    !real_device?
+  end
+
+  def samsung?
+    brand == 'samsung'
+  end
+
+  def htc?
+    brand == 'htc'
+  end
+
+  def asus?
+    brand == 'asus'
+  end
+
+  def lenovo?
+    brand == 'Lenovo'
+  end
+
+  def density
+    @density ||= execute_command('shell getprop ro.sf.lcd_density').to_i
+  end
+
+  def brand
+    execute_command('shell getprop ro.product.brand').strip
+  end
+
+  def model
+    execute_command('shell getprop ro.product.model').strip
+  end
+
+  def remove_package(name)
+    return unless package_exists?(name)
+    `adb uninstall #{name}`
+    fail "#{name} package wasn't removed" if package_exists?(name)
+  end
+
+  def restart_adb
+    `adb kill-server; adb start-server`
+  end
+
+  def portrait?
+    @orientation_enum ||= `adb shell dumpsys input`.lines.find { |l| l =~ /SurfaceOrientation/ }.strip[-1].to_i
+    @orientation_enum.even?
+  end
+
+  def connected_device_udid
+    case
+    when devices.none?                            then fail('No devices detected')
+    when devices.one?                             then devices.first.udid
+    when devices.count > 1 && emulators.none?     then fail('Several devices detected. Set ANDROID_SERIAL to pick one')
+    when devices.count > 1 && emulators.one?      then emulators.first.udid
+    when devices.count > 1 && emulators.count > 1 then fail('Several emulators detected. Close all but one')
+    end
+  end
+
+  private
+
+  def android_version
+    execute_command('shell getprop ro.build.version.release').lines.last.strip
+  end
+
+  def devices
+    @device_list ||= begin
+                       execute_command('devices -l').lines.grep(/model/).inject([]) do |dl, device_string|
+                         dl << Device.new(device_string[/^\S+/])
+                       end
+                     end
+  end
+
+  def emulators
+    @emulators_list ||= begin
+                       execute_command('devices -l').lines.grep(/model/).grep_v(/usb/).inject([]) do |dl, device_string|
+                         dl << Device.new(device_string[/^\S+/])
+                       end
+                     end
+  end
+
+  Device = Struct.new(:udid)
+end

data/lib/adb_driver/driver.rb

@@ -0,0 +1,35 @@
+require 'logger'
+
+module AdbDriver
+  class Driver
+    include Finder
+    include Wait
+
+    SCREENSHOT_TIMEOUT = 5
+
+    attr_reader :logger
+
+    def initialize
+      @logger = Logger.new('adb_driver.log')
+      @logger.level = Logger::DEBUG
+      @logger.info 'Initializing Adb driver'
+    end
+
+    def save_screenshot(filepath)
+      if Adb.android_5_or_greater?
+        wait(SCREENSHOT_TIMEOUT) { `adb exec-out screencap -p > #{filepath}` }
+      else
+        wait(SCREENSHOT_TIMEOUT) { `adb shell screencap -p /sdcard/screenshot.png; adb pull /sdcard/screenshot.png #{filepath}` }
+      end
+    rescue Wait::Error => e
+      raise e.class, 'Cannot take a screenshot'
+    end
+
+    def navigate
+      @navigation ||= Navigation.new
+    end
+
+    def quit
+    end
+  end
+end

data/lib/adb_driver/dsl.rb

@@ -0,0 +1,225 @@
+module DSL
+  def active?
+    new.active?
+  end
+
+  def button(name, options)
+    define_active_method(name) if options.delete(:distinctive)
+    define_scroll_to_bottom_method(name) if options.delete(:bottom)
+    wait_for_class = options.delete(:wait_for_class)
+    wait_for_class_timeout = options.delete(:wait_for_class_timeout)
+    index = options.delete(:index)
+
+    locator = options
+    define_name_method(name, wait_for_class, wait_for_class_timeout)
+    define_query_method(name, locator, index)
+    define_button_method(name, locator, index)
+  end
+
+  def buttons(locator, &block)
+    ButtonsBuilder.new(locator, &block)
+  end
+
+  def radio_buttons(locator, &block)
+    ButtonsBuilder.new(locator, &block)
+    define_selected_method
+  end
+
+  def text_field(name, options)
+    define_active_method(name) if options.delete(:distinctive)
+
+    locator = options
+    define_text_field_method(name, locator)
+    define_query_method(name, locator)
+    define_setter(name, locator)
+    define_getter(name, locator)
+  end
+
+  def switch(name, options)
+    define_active_method(name) if options.delete(:distinctive)
+    wait_for_class = options.delete(:wait_for_class)
+
+    locator = options
+    define_query_method(name, locator)
+    define_switch_methods(name, locator, wait_for_class)
+  end
+  alias checkbox switch
+
+  def view(name, options)
+    define_active_method(name) if options.delete(:distinctive)
+
+    locator = options
+    define_query_method(name, locator)
+    define_view_method(name, locator)
+  end
+
+  private
+
+  def define_active_method(name)
+    define_method(:active?) do
+      send("#{name}?")
+    end
+  end
+
+  def define_scroll_to_bottom_method(name)
+    define_method(:scroll_to_bottom) do
+      start = Time.now
+      until send("#{name}?")
+        fling_down
+        sleep 0.1
+        fail "Unable to scroll to the bottom (#{name} button)" if Time.now > start + 60
+      end
+    end
+  end
+
+  def define_name_method(name, wait_for_class, wait_for_class_timeout)
+    wait_for_class_timeout = 10 unless wait_for_class_timeout
+
+    define_method(name) do
+      send("#{name}_button").click
+      if wait_for_class
+        wait(wait_for_class_timeout, "Screen #{wait_for_class} hasn't became active") do
+          self.class.const_get(wait_for_class).active?
+        end
+      end
+    end
+  end
+
+  def define_text_field_method(name, locator)
+    define_method("#{name}_text_field") do
+      begin
+        find_element(locator)
+      rescue Selenium::WebDriver::Error::NoSuchElementError => e
+        fail e.class, "'#{name}' text field cannot be found using #{locator}", caller.reject { |line| line =~ /#{__FILE__}/ }
+      end
+    end
+  end
+
+  def define_query_method(name, locator, index = nil)
+    define_method("#{name}?") do
+      if index
+        !!find_elements(locator)[index] || false
+      else
+        begin
+          !!find_element(locator)
+        rescue Selenium::WebDriver::Error::NoSuchElementError
+          false
+        end
+      end
+    end
+  end
+
+  def define_button_method(name, locator, index)
+    define_method("#{name}_button") do
+      if index
+        button = find_elements(locator)[index]
+        unless button
+          fail Selenium::WebDriver::Error::NoSuchElementError,
+               "'#{name}' button cannot be found using #{locator} with index #{index}",
+               caller.reject { |line| line =~ /#{__FILE__}/ }
+        end
+        button
+      else
+        begin
+          find_element(locator)
+        rescue Selenium::WebDriver::Error::NoSuchElementError => e
+          fail e.class, "'#{name}' button cannot be found using #{locator}", caller.reject { |line| line =~ /#{__FILE__}/ }
+        end
+      end
+    end
+  end
+
+  def define_view_method(name, locator)
+    define_method("#{name}_view") do
+      begin
+        find_element(locator)
+      rescue Selenium::WebDriver::Error::NoSuchElementError
+        fail %(Element "#{name}" with locator "#{locator}" wasn't found)
+      end
+    end
+  end
+
+  def define_setter(name, locator)
+    define_method("#{name}=") do |text|
+      find_element(locator).send_keys text
+    end
+  end
+
+  def define_getter(name, locator, index = nil)
+    define_method(name) do
+      if index
+        find_elements(locator)[index].name
+      else
+        find_element(locator).name
+      end
+    end
+  end
+
+  def define_switch_methods(name, locator, wait_for_class)
+    define_method("#{name}_switch") do
+      find_element(locator)
+    end
+
+    define_method("toggle_#{name}") do
+      find_element(locator).click
+    end
+
+    define_method("#{name}_on?") do
+      find_element(locator).attribute(:checked) == 'true'
+    end
+    alias_method "#{name}_selected?".to_sym, "#{name}_on?".to_sym
+
+    define_method("turn_on_#{name}") do
+      unless send("#{name}_on?")
+        send("toggle_#{name}")
+        if wait_for_class
+          wait(5, "Screen #{wait_for_class} hasn't became active") do
+            Module.const_get(wait_for_class).active?
+          end
+        end
+      end
+    end
+
+    define_method("turn_off_#{name}") do
+      if send("#{name}_on?")
+        send("toggle_#{name}")
+        if wait_for_class
+          wait(5, "Screen #{wait_for_class} hasn't became active") do
+            Module.const_get(wait_for_class).active?
+          end
+        end
+      end
+    end
+  end
+
+  def define_selected_method
+    button_methods = instance_methods.grep(/_button/)
+    define_method(:selected) do
+      result = button_methods.map do |button_method|
+        send(button_method).checked? && button_method.to_s.sub(/_button/, '').to_sym
+      end
+      result.grep_v(false).first
+    end
+  end
+
+  class ButtonsBuilder
+    def initialize(locator, &block)
+      @locator = locator
+      @block = block
+      @index = 0
+      instance_exec(&block)
+    end
+
+    def method_missing(method, *args)
+      button_name = args[0]
+      button_params = args[1] || {}
+
+      unless button_params.key?(:index)
+        button_params[:index] = @index
+        @index += 1
+      end
+
+      @block.binding.receiver.button button_name, @locator.merge(button_params)
+    end
+  end
+end

data/lib/adb_driver/element.rb

@@ -0,0 +1,72 @@
+class Element
+  Point = Struct.new(:x, :y)
+  Size = Struct.new(:width, :height)
+
+  def initialize(xml_representation)
+    @xml_representation = xml_representation
+  end
+
+  def click
+    `adb shell input tap #{center.x} #{center.y}`
+  end
+
+  def long_click
+    `adb shell input swipe #{center.x} #{center.y} #{center.x} #{center.y} 800`
+  end
+
+  def send_keys(text)
+    click
+    sleep 2
+    text.scan(/.{1,10}/).each do |part|
+      `adb shell "input text '#{part}'"`
+    end
+  end
+
+  def text
+    @xml_representation.attributes['text']
+  end
+
+  def checked?
+    @xml_representation.attributes['checked'] == 'true'
+  end
+
+  def content_desc
+    @xml_representation.attributes['content-desc']
+  end
+
+  def top_left
+    Point.new(coordinates[0], coordinates[1])
+  end
+  alias_method :location, :top_left
+
+  def lower_right
+    Point.new(coordinates[2], coordinates[3])
+  end
+
+  def width
+    lower_right.x - top_left.x
+  end
+
+  def height
+    lower_right.y - top_left.y
+  end
+
+  def center
+    Point.new(top_left.x + width / 2, top_left.y + height / 2)
+  end
+
+  def size
+    Size.new(width, height)
+  end
+
+  def class_name
+    @xml_representation.attributes['class']
+  end
+
+  private
+
+  def coordinates
+    @coordinates ||= @xml_representation.attributes['bounds'].scan(/\d+/).map(&:to_i)
+  end
+end
+

data/lib/adb_driver/error.rb

@@ -0,0 +1,16 @@
+unless defined?(Selenium)
+  module Selenium
+    module WebDriver
+      module Error
+        class NoSuchElementError < StandardError; end
+      end
+    end
+  end
+end
+
+module AdbDriver
+  module Error
+    class NoSuchElementError < Selenium::WebDriver::Error::NoSuchElementError; end
+    class TimeOutError < StandardError; end
+  end
+end

data/lib/adb_driver/finder.rb

@@ -0,0 +1,61 @@
+module AdbDriver
+  module Finder
+    include Wait
+
+    FIND_ELEMENT_TIMEOUT = 1
+    PAGE_SOURCE_TIMEOUT = 15
+    MIN_TIME_BETWEEN_FIND_ATTEMPTS = 0.250
+
+    def find_element(locator)
+      wait(FIND_ELEMENT_TIMEOUT) { find_elements(locator).first }
+    rescue Wait::Error
+      logger.info "Element with locator '#{locator}' has not been found"
+      logger.debug "Current hierarchy: #{@last_view_hierarchy}"
+      raise Error::NoSuchElementError
+    end
+
+    def find_elements(locator)
+      logger.info "Searching for element by: #{locator}"
+
+      locator_type = locator.first.first
+      locator_value = locator.first.last
+
+      case locator_type
+      when :xpath        then find_elements_by_xpath(locator_value)
+      when :id           then find_elements_by_xpath("//*[contains(@resource-id,'#{locator_value}')]")
+      when :class_name   then find_elements_by_xpath("//*[@class='#{locator_value}']")
+      when :content_desc then find_elements_by_xpath("//*[@content-desc='#{locator_value}']")
+      end
+    end
+
+    def find_elements_by_xpath(xpath)
+      sleep 0.05 until Time.now >= (@last_find_attempt_time ||= Time.now) + MIN_TIME_BETWEEN_FIND_ATTEMPTS
+
+      view_hierarchy = REXML::Document.new(page_source)
+      @last_view_hierarchy = view_hierarchy
+
+      result = view_hierarchy.get_elements(xpath).map { |element| Element.new(element) }
+      @last_find_attempt_time = Time.now
+      logger.debug "Returning element(s): #{result}"
+      result
+    end
+
+    def page_source
+      adb_command = Adb.android_7? ? 'exec-out uiautomator dump /dev/tty' : 'shell uiautomator dump /dev/tty'
+      logger.info "Getting view hierarchy"
+      result = Adb.execute_command(adb_command, PAGE_SOURCE_TIMEOUT)
+
+      if result.empty? || result.strip == 'Killed'
+        logger.info "Result is empty or 'Killed'. Restarting adb..."
+        Adb.restart_adb
+        logger.info "Adb restarted. Getting result..."
+        result = Adb.execute_command(adb_command, PAGE_SOURCE_TIMEOUT)
+      end
+
+      logger.debug "Result received: #{result}"
+      result
+    rescue Wait::Error
+      raise TimeOutError, "Couldn't get page_source in reasonable time (#{PAGE_SOURCE_TIMEOUT} seconds)"
+    end
+  end
+end

data/lib/adb_driver/navigation.rb

@@ -0,0 +1,7 @@
+module AdbDriver
+  class Navigation
+    def back
+      `adb shell input keyevent KEYCODE_BACK`
+    end
+  end
+end

data/lib/adb_driver/source_cleaner.rb

@@ -0,0 +1,60 @@
+require 'rexml/document'
+require 'rexml/sax2listener'
+require 'rexml/parsers/sax2parser'
+
+module SourceCleaner
+  def self.call(page_source)
+    p = REXML::Parsers::SAX2Parser.new(page_source)
+    p.listen(MrProper.new)
+    p.parse
+  end
+
+  class MrProper
+    include REXML::SAX2Listener
+
+    BORING_ATTRS = %w(class index package
+                    checkable checked clickable
+                    enabled focusable focused
+                    scrollable long-clickable password
+                    selected bounds instance)
+
+    INDENT_WIDTH = 2
+    ATTRIBUTES_INDENT = 4
+
+    def initialize
+      @indent = 0
+    end
+
+    def start_element(uri, localname, qname, attributes)
+      return if localname == 'hierarchy'
+
+      @indent += 1
+
+      node = ' ' * INDENT_WIDTH * @indent
+      node << "class_name: '#{attributes['class']}'"
+
+      clean_attributes = attributes.delete_if { |k, v| BORING_ATTRS.include?(k) || v.empty? }
+
+      if value = clean_attributes.delete('resource-id')
+        clean_attributes[:id] = value
+      end
+
+      if value = clean_attributes.delete('content-desc')
+        clean_attributes[:content_desc] = value
+      end
+
+      unless clean_attributes.empty?
+        node << ' ' * ATTRIBUTES_INDENT
+        node << clean_attributes.map { |k, v| "#{k}: '#{v}'" }.join(', ')
+      end
+
+      puts node
+    end
+
+    def end_element(uri, localname, qname)
+      @indent -= 1
+    end
+  end
+end
+
+SourceCleaner.call(ARGF.read) if $PROGRAM_NAME == __FILE__

data/lib/adb_driver/wait.rb

@@ -0,0 +1,24 @@
+module Wait
+  Error = Class.new(StandardError)
+
+  def self.included(mod)
+    mod.extend self
+  end
+
+  def wait(duration = 10, message = nil, &block)
+    polling_interaval = 0.1 # 100 msec
+    start = Time.now
+
+    loop do
+      sleep polling_interaval
+
+      result = block.call
+      break result if result
+
+      next if Time.now < start + duration
+
+      cleaned_stacktrace = caller.reverse.take_while { |line| line !~ /#{__FILE__}.*#{__method__}/ }.reverse
+      raise Error, (message || 'Wait::Error'), cleaned_stacktrace
+    end
+  end
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: adb_driver
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Anton Petrov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-05-03 00:00:00.000000000 Z
+dependencies: []
+description: A driver with Seleium-like interface to interact with Android devices
+  directly via ADB
+email: givemeletter@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/adb_driver.rb
+- lib/adb_driver/adb.rb
+- lib/adb_driver/driver.rb
+- lib/adb_driver/dsl.rb
+- lib/adb_driver/element.rb
+- lib/adb_driver/error.rb
+- lib/adb_driver/finder.rb
+- lib/adb_driver/navigation.rb
+- lib/adb_driver/source_cleaner.rb
+- lib/adb_driver/wait.rb
+homepage: https://github.com/sofaking/adb_driver
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.4
+signing_key: 
+specification_version: 4
+summary: A driver with Seleium-like interface to interact with Android devices directly
+  via ADB
+test_files: []