device_api-android 1.2.9 → 1.2.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c09f0413dc5506bd026fdaa5f8bf85af6a18a404
-  data.tar.gz: 2bc91a6a0affe29634f881f5592d3be10bde1efb
+  metadata.gz: f2949c4bb240ed0f093b79db016d0d36156db4b4
+  data.tar.gz: 18bf69ed9c381eee30d2229efff6481a5adab406
 SHA512:
-  metadata.gz: 5247d30f5ce2233891a6f3770c5283b753466f6e9fd81249e1184ec14ea9a9064843228f924c01ea07325449b95a76c3e119b933634d95f81558068188438856
-  data.tar.gz: 9fb2718ad39a1ceceaefa7ce4e1b2251d0b39d5afbbb109819f299b635d0d75b1438f8d76d7f28f8d4e48f3462775aaf1c2cfef578ffbc2fac41e97054c30855
+  metadata.gz: 77e3bd2c0c489a7a4334203bbc37ee3bb7a2792e048894aa845a998069b25016f73953af459ff724b2772749645820143334f29970fc24d8c829e5a5369913d4
+  data.tar.gz: 80b1257860b39542b8b088db4086d876fe9bb2cf4c82cd75668a4e69715e94fbd5712e3ef1e171dc101823f5cc1f032afc5879a7429efee7d870fdaec8db8f5a

data/README.md

@@ -1,6 +1,6 @@
 # DeviceAPI-Android
 
-*DeviceAPI-Android* is the android implementation of device_api -- an initiative to allow full automation of device activities.
+*DeviceAPI-Android* is the android implementation of device_api -- an initiative to allow full automation of device activities. For a full list of release notes, see the [change log](CHANGELOG.md)
 
 ## Dependencies
 
@@ -104,6 +104,7 @@ This allows you to setup a keystore with the options required by any testing fra
 ## Testing
 
 device_api-android is defended with unit and integration level rspec tests. You can run the tests with:
+
     bundle exec rspec
 
 ## Issues

data/lib/device_api/android/adb.rb

@@ -22,10 +22,10 @@ module DeviceAPI
       end
 
       # Retrieve device state for a single device
-      # @param serial serial number of device
+      # @param qualifier qualifier of device
       # @return (String) device state
-      def self.get_state(serial)
-        result = execute('adb get-state -s #{serial}')
+      def self.get_state(qualifier)
+        result = execute('adb get-state -s #{qualifier}')
 
         raise ADBCommandError.new(result.stderr) if result.exit != 0
 
@@ -35,10 +35,10 @@ module DeviceAPI
       end
 
       # Get the properties of a specified device
-      # @param serial serial number of device
+      # @param qualifier qualifier of device
       # @return (Hash) hash containing device properties
-      def self.getprop(serial)
-        result = shell(serial, 'getprop')
+      def self.getprop(qualifier)
+        result = shell(qualifier, 'getprop')
 
         lines = result.stdout.encode('UTF-16', 'UTF-8', invalid: :replace, replace: '').encode('UTF-8', 'UTF-16').split("\n")
 
@@ -46,37 +46,37 @@ module DeviceAPI
       end
 
       # Get the 'input' information from dumpsys
-      # @param serial serial number of device
+      # @param qualifier qualifier of device
       # @return (Hash) hash containing input information from dumpsys
-      def self.getdumpsys(serial)
-        lines = dumpsys(serial, 'input')
+      def self.getdumpsys(qualifier)
+        lines = dumpsys(qualifier, 'input')
         process_dumpsys('(.*):\s+(.*)', lines)
       end
 
       # Get the 'iphonesubinfo' from dumpsys
-      # @param serial serial number of device
+      # @param qualifier qualifier of device
       # @return (Hash) hash containing iphonesubinfo information from dumpsys
-      def self.getphoneinfo(serial)
-        lines = dumpsys(serial, 'iphonesubinfo')
+      def self.getphoneinfo(qualifier)
+        lines = dumpsys(qualifier, 'iphonesubinfo')
         process_dumpsys('(.*) =\s+(.*)', lines)
       end
 
       # Get the 'battery' information from dumpsys
-      # @param [String] serial serial number of device
+      # @param [String] qualifier qualifier of device
       # @return [Hash] hash containing battery information from dumpsys
-      def self.get_battery_info(serial)
-        lines = dumpsys(serial, 'battery')
+      def self.get_battery_info(qualifier)
+        lines = dumpsys(qualifier, 'battery')
         process_dumpsys('(.*):\s+(.*)', lines)
       end
 
-      def self.get_network_interface(serial, interface)
-        result = shell(serial, "ifconfig #{interface}")
+      def self.get_network_interface(qualifier, interface)
+        result = shell(qualifier, "ifconfig #{interface}")
         result.stdout
       end
 
       # Get the network information
-      def self.get_network_info(serial)
-        lines = shell(serial, 'netcfg')
+      def self.get_network_info(qualifier)
+        lines = shell(qualifier, 'netcfg')
         lines.stdout.split("\n").map do |a|
           b = a.split(" ")
           { name: b[0], ip: b[2].split('/')[0], mac: b[4] }
@@ -100,15 +100,15 @@ module DeviceAPI
       end
 
       # Get the 'power' information from dumpsys
-      # @param [String] serial serial number of device
+      # @param [String] qualifier qualifier of device
       # @return [Hash] hash containing power information from dumpsys
-      def self.getpowerinfo(serial)
-        lines = dumpsys(serial, 'power')
+      def self.getpowerinfo(qualifier)
+        lines = dumpsys(qualifier, 'power')
         process_dumpsys('(.*)=(.*)', lines)
       end
 
-      def self.get_device_dpi(serial)
-        lines = dumpsys(serial, 'window')
+      def self.get_device_dpi(qualifier)
+        lines = dumpsys(qualifier, 'window')
         dpi = nil
         lines.each do |line|
           if /sw(\d*)dp/.match(line)
@@ -119,17 +119,17 @@ module DeviceAPI
       end
 
       # Returns the 'dumpsys' information from the specified device
-      # @param serial serial number of device
+      # @param qualifier qualifier of device
       # @return (Array) array of results from adb shell dumpsys
-      def self.dumpsys(serial, command)
-        result = shell(serial, "dumpsys #{command}")
+      def self.dumpsys(qualifier, command)
+        result = shell(qualifier, "dumpsys #{command}")
         result.stdout.split("\n").map { |line| line.strip }
       end
 
       # Installs a specified apk to a specific device
       # @param [Hash] options the options used for installing an apk
       # @option options [String] :apk path to apk to install
-      # @option options [String] :serial serial number of device
+      # @option options [String] :qualifier qualifier of device
       # @return (String) return result from adb install command
       def self.install_apk(options = {})
         options[:action] = :install
@@ -139,7 +139,7 @@ module DeviceAPI
       # Uninstalls a specified package from a specified device
       # @param [Hash] options the options used for uninstalling a package
       # @option options [String] :package_name package to uninstall
-      # @option options [String] :serial serial number of device
+      # @option options [String] :qualifier qualifier of device
       # @return (String) return result from adb uninstall command
       def self.uninstall_apk(options = {})
         options[:action] = :uninstall
@@ -149,14 +149,14 @@ module DeviceAPI
       def self.change_apk(options = {})
         package_name = options[:package_name]
         apk = options[:apk]
-        serial = options[:serial]
+        qualifier = options[:qualifier]
         action = options[:action]
 
         case action
           when :install
-            command = "adb -s #{serial} install #{apk}"
+            command = "adb -s #{qualifier} install #{apk}"
           when :uninstall
-            command = "adb -s #{serial} uninstall #{package_name}"
+            command = "adb -s #{qualifier} uninstall #{package_name}"
           else
             raise ADBCommandError.new('No action specified')
         end
@@ -171,10 +171,10 @@ module DeviceAPI
       end
 
       # Returns the uptime of the specified device
-      # @param serial serial number of device
+      # @param qualifier qualifier of device
       # @return (Float) uptime in seconds
-      def self.get_uptime(serial)
-        result = shell(serial, 'cat /proc/uptime')
+      def self.get_uptime(qualifier)
+        result = shell(qualifier, 'cat /proc/uptime')
 
         lines = result.stdout.split("\n")
         uptime = 0
@@ -187,23 +187,23 @@ module DeviceAPI
       end
 
       # Reboots the specified device
-      # @param serial serial number of device
+      # @param qualifier qualifier of device
       # @return (nil) Nil if successful, otherwise an error is raised
-      def self.reboot(serial)
-        result = execute("adb -s #{serial} reboot")
+      def self.reboot(qualifier)
+        result = execute("adb -s #{qualifier} reboot")
         raise ADBCommandError.new(result.stderr) if result.exit != 0
       end
 
       # Runs monkey testing
-      # @param serial serial number of device
+      # @param qualifier qualifier of device
       # @param [Hash] args hash of arguments used for starting testing
       # @option args [String] :events (10000) number of events to run
       # @option args [String] :package name of package to run the tests against
       # @option args [String] :seed pass the seed number (optional)
       # @option args [String] :throttle throttle value (optional)
       # @example
-      #   DeviceAPI::ADB.monkey( serial, :package => 'my.lovely.app' )
-      def self.monkey(serial, args)
+      #   DeviceAPI::ADB.monkey( qualifier, :package => 'my.lovely.app' )
+      def self.monkey(qualifier, args)
 
         events = args[:events] || 10000
         package = args[:package] or raise "package name not provided (:package => 'bbc.iplayer')"
@@ -214,71 +214,81 @@ module DeviceAPI
         cmd = cmd + " -s #{seed}" if seed
         cmd = cmd + " -t #{throttle}" if throttle
 
-        shell(serial, cmd)
+        shell(qualifier, cmd)
       end
       
       # Take a screenshot from the device
-      # @param serial serial number of device
+      # @param qualifier qualifier of device
       # @param [Hash] args hash of arguments
       # @option args [String] :filename name (with full path) required to save the image
       # @example
-      #   DeviceAPI::ADB.screenshot( serial, :filename => '/tmp/filename.png' )
-      def self.screencap( serial, args )
+      #   DeviceAPI::ADB.screenshot( qualifier, :filename => '/tmp/filename.png' )
+      def self.screencap( qualifier, args )
         
         filename = args[:filename] or raise "filename not provided (:filename => '/tmp/myfile.png')"
         
         convert_carriage_returns = %q{perl -pe 's/\x0D\x0A/\x0A/g'}
         cmd = "screencap -p | #{convert_carriage_returns} > #{filename}"
         
-        shell(serial, cmd)
+        shell(qualifier, cmd)
       end
-
-      def self.connect(ipaddress, port = 5555)
-        ipaddressandport = "#{ipaddress}:#{port}"
-        check_ip_address(ipaddressandport)
-        cmd = "adb connect #{ipaddressandport}"
+      
+      # Connects to remote android device
+      # @param [String] ip_address 
+      # @param [String] port
+      # @example
+      #  DeviceAPI::ADB.connect(ip_address, port)  
+      def self.connect(ip_address, port=5555)
+        ip_address_and_port = "#{ip_address}:#{port}"
+        check_ip_address(ip_address_and_port)
+        cmd = "adb connect #{ip_address_and_port}"
         result = execute(cmd)
         if result.stdout.to_s =~ /.*already connected to.*/
-          raise DeviceAlreadyConnectedError.new("Device #{ipaddressandport} already connected")
+          raise DeviceAlreadyConnectedError.new("Device #{ip_address_and_port} already connected")
         else 
           unless result.stdout.to_s =~ /.*connected to.*/
-            raise ADBCommandError.new("Unable to adb connect to #{ipaddressandport} result was: #{result.stdout}")
+            raise ADBCommandError.new("Unable to adb connect to #{ip_address_and_port} result was: #{result.stdout}")
           end
         end 
       end
-
-      def self.disconnect(ipaddress, port = 5555)
-        ipaddressandport = "#{ipaddress}:#{port}"
-        check_ip_address(ipaddressandport)
-        cmd = "adb disconnect #{ipaddressandport}"
+    
+      # Disconnects from remote android device
+      # @param [String] ip_address
+      # @param [String] port
+      # @example
+      #  DeviceAPI::ADB.disconnect(ip_address, port) 
+      def self.disconnect(ip_address, port=5555)
+        ip_address_and_port = "#{ip_address}:#{port}"
+        check_ip_address(ip_address_and_port)
+        cmd = "adb disconnect #{ip_address_and_port}"
         result = execute(cmd)
         unless result.exit == 0
-          raise ADBCommandError.new("Unable to adb disconnect to #{ipaddressandport} result was: #{result.stdout}")
+          raise ADBCommandError.new("Unable to adb disconnect to #{ip_address_and_port} result was: #{result.stdout}")
         end
       end
 
       # Returns wifi status and access point name
-      # @param serial serial number of device
+      # @param qualifier qualifier of device
       # @example
-      #   DeviceAPI::ADB.wifi(serial)
-      def self.wifi(serial)
-        result = shell(serial, 'dumpsys wifi | grep mNetworkInfo')
+      #   DeviceAPI::ADB.wifi(qualifier)
+      def self.wifi(qualifier)
+        result = shell(qualifier, 'dumpsys wifi | grep mNetworkInfo')
 
         {:status => result.stdout.match("state:(.*?),")[1].strip, :access_point => result.stdout.match("extra:(.*?),")[1].strip.gsub(/"/,'')}
       end
 
       # Sends a key event to the specified device
-      # @param [String] serial serial number of device
+      # @param [String] qualifier qualifier of device
       # @param [String] keyevent keyevent to send to the device
-      def self.keyevent(serial, keyevent)
-        shell(serial, "input keyevent #{keyevent}").stdout
+      def self.keyevent(qualifier, keyevent)
+        shell(qualifier, "input keyevent #{keyevent}").stdout
       end
 
       # ADB Shell command
-      # @param [String] serial serial number of device
+      # @param [String] qualifier qualifier of device
       # @param [String] command command to execute
-      def self.shell(serial, command)
-        result = execute("adb -s '#{serial}' shell #{command}")
+      def self.shell(qualifier, command)
+        result = execute("adb -s '#{qualifier}' shell #{command}")
         case result.stderr
         when /^error: device unauthorized./
           raise DeviceAPI::UnauthorizedDevice, result.stderr
@@ -292,55 +302,55 @@ module DeviceAPI
       end
 
       # Sends a swipe command to the specified device
-      # @param [String] serial serial number of the device
+      # @param [String] qualifier qualifier of the device
       # @param [Hash] coords hash of coordinates to swipe from / to
       # @option coords [String] :x_from (0) Coordinate to start from on the X axis
       # @option coords [String] :x_to (0) Coordinate to end on on the X axis
       # @option coords [String] :y_from (0) Coordinate to start from on the Y axis
       # @option coords [String] :y_to (0) Coordinate to end on on the Y axis
-      def self.swipe(serial, coords = {x_from: 0, y_from: 0, x_to: 0, y_to: 0 })
-        shell(serial, "input swipe #{coords[:x_from]} #{coords[:y_from]} #{coords[:x_to]} #{coords[:y_to]}").stdout
+      def self.swipe(qualifier, coords = {x_from: 0, y_from: 0, x_to: 0, y_to: 0 })
+        shell(qualifier, "input swipe #{coords[:x_from]} #{coords[:y_from]} #{coords[:x_to]} #{coords[:y_to]}").stdout
       end
 
       # Starts intent using adb 
       # Returns stdout
-      # @param serial serial number of device 
+      # @param qualifier qualifier of device 
       # @param command -option activity 
       # @example
-      # DeviceAPI::ADB.am(serial, "start -a android.intent.action.MAIN -n com.android.settings/.wifi.WifiSettings")
-      def self.am(serial, command)
-        shell(serial, "am #{command}").stdout
+      # DeviceAPI::ADB.am(qualifier, "start -a android.intent.action.MAIN -n com.android.settings/.wifi.WifiSettings")
+      def self.am(qualifier, command)
+        shell(qualifier, "am #{command}").stdout
       end
 
       # Package manager commands
-      # @param serial serial of device
+      # @param qualifier qualifier of device
       # @param command command to issue to the package manager
-      # @example DeviceAPI::ADB.pm(serial, 'list packages')
-      def self.pm(serial, command)
-        shell(serial, "pm #{command}").stdout
+      # @example DeviceAPI::ADB.pm(qualifier, 'list packages')
+      def self.pm(qualifier, command)
+        shell(qualifier, "pm #{command}").stdout
       end
 
       # Blocks a package, used on Android versions less than KitKat
       # Returns boolean
-      # @param serial serial of device
+      # @param qualifier qualifier of device
       # @param package to block
-      def self.block_package(serial, package)
-        result = pm(serial, "block #{package}")
+      def self.block_package(qualifier, package)
+        result = pm(qualifier, "block #{package}")
         result.include?('true')
       end
 
       # Blocks a package on KitKat and above
       # Returns boolean
-      # @param serial serial of device
+      # @param qualifier qualifier of device
       # @param package to hide
-      def self.hide_package(serial, package)
-        result = pm(serial, "hide #{package}")
+      def self.hide_package(qualifier, package)
+        result = pm(qualifier, "hide #{package}")
         result.include?('true')
       end
 
-      def self.check_ip_address(ipaddressandport)
-        unless ipaddressandport =~ /\A(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3}):[0-9]+\Z/ 
-             raise ADBCommandError.new("Invalid IP address and port #{ipaddressandport}")
+      def self.check_ip_address(ip_address_and_port)
+        unless ip_address_and_port =~ /\A(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3}):[0-9]+\Z/ 
+             raise ADBCommandError.new("Invalid IP address and port #{ip_address_and_port}")
         end
       end
     end

data/lib/device_api/android/device.rb

@@ -9,6 +9,7 @@ module DeviceAPI
   module Android
     # Device class used for containing the accessors of the physical device information
     class Device < DeviceAPI::Device
+      attr_reader :qualifier
 
       @@subclasses; @@subclasses = {}
 
@@ -25,11 +26,22 @@ module DeviceAPI
       end
 
       def initialize(options = {})
-        @serial = options[:serial]
+        # For devices connected with USB, qualifier and serial are same
+        @qualifier = @serial = options[:serial] 
         @state = options[:state]
         @remote = options[:remote] ? true : false
+        if is_remote?
+          set_ip_and_port
+          @serial = self.serial_no
+        end
       end
 
+      def set_ip_and_port
+        address = @qualifier.split(":")
+        @ip_address = address.first
+        @port = address.last
+      end     
+ 
       def is_remote?
         @remote || false
       end
@@ -45,12 +57,21 @@ module DeviceAPI
             'no permissions' => :no_permissions
         }[@state]
       end
+      
+      def connect
+        ADB.connect(@ip_address, @port)
+      end
 
       def disconnect
         unless is_remote?
-          raise DeviceAPI::Android::DeviceDisconnectedWhenNotARemoteDevice.new("Asked to disconnect device #{serial} when it is not a remote device")
+          raise DeviceAPI::Android::DeviceDisconnectedWhenNotARemoteDevice.new("Asked to disconnect device #{qualifier} when it is not a remote device")
         end
-        ADB.disconnect(serial)
+        ADB.disconnect(@ip_address, @port)
+      end
+
+      # Return whether device is connected or not
+      def is_connected?
+        ADB.devices.any? {|device| device.include? qualifier}
       end
 
       # Return the device range
@@ -63,6 +84,12 @@ module DeviceAPI
         "#{device}_#{model}"
       end
 
+      # Return the serial number of device
+      # @return (String) serial number
+      def serial_no
+        get_prop('ro.serialno')
+      end
+
       # Return the device type
       # @return (String) device type string
       def device
@@ -101,9 +128,9 @@ module DeviceAPI
 
       def block_package(package)
         if version < "5.0.0"
-          ADB.block_package(serial, package)
+          ADB.block_package(qualifier, package)
         else
-          ADB.hide_package(serial, package)
+          ADB.hide_package(qualifier, package)
         end
       end
 
@@ -163,7 +190,7 @@ module DeviceAPI
       end
 
       def list_installed_packages
-        packages = ADB.pm(serial, 'list packages')
+        packages = ADB.pm(qualifier, 'list packages')
         packages.split("\r\n")
       end
 
@@ -180,13 +207,13 @@ module DeviceAPI
       # Initiate monkey tests
       # @param [Hash] args arguments to pass on to ADB.monkey
       def monkey(args)
-        ADB.monkey(serial, args)
+        ADB.monkey(qualifier, args)
       end
 
       # Capture screenshot on device
       # @param [Hash] args arguments to pass on to ADB.screencap
       def screenshot(args)
-        ADB.screencap(serial, args)
+        ADB.screencap(qualifier, args)
       end
 
       # Get the IMEI number of the device
@@ -215,13 +242,13 @@ module DeviceAPI
 
       # Unlock the device by sending a wakeup command
       def unlock
-        ADB.keyevent(serial, '26') unless screen_on?
+        ADB.keyevent(qualifier, '26') unless screen_on?
       end
 
       # Return the DPI of the attached device
       # @return [String] DPI of attached device
       def dpi
-        get_dpi(serial)
+        get_dpi(qualifier)
       end
 
       # Return the device type based on the DPI
@@ -237,23 +264,23 @@ module DeviceAPI
       # Returns wifi status and access point name
       # @return [Hash] :status and :access_point
       def wifi_status
-        ADB.wifi(serial)
+        ADB.wifi(qualifier)
       end
 
       def battery_info
-        ADB.get_battery_info(serial)
+        ADB.get_battery_info(qualifier)
       end
 
       # @param [String] command to start the intent
       # Return the stdout of executed intent
       # @return [String] stdout
       def intent(command)
-        ADB.am(serial, command)
+        ADB.am(qualifier, command)
       end
 
       #Reboots the device
       def reboot
-        ADB.reboot(serial)
+        ADB.reboot(qualifier)
       end
 
       # Returns disk status
@@ -264,12 +291,12 @@ module DeviceAPI
 
       # Returns the device uptime
       def uptime
-        ADB.get_uptime(serial)
+        ADB.get_uptime(qualifier)
       end
 
       # Returns the Wifi IP address
       def ip_address
-        interface = ADB.get_network_interface(serial, 'wlan0')
+        interface = ADB.get_network_interface(qualifier, 'wlan0')
         if interface.match(/ip (.*) mask/)
           Regexp.last_match[1]
         elsif interface.match(/inet addr:(.*)\s+Bcast/)
@@ -281,7 +308,7 @@ module DeviceAPI
 
       # Returns the Wifi mac address
       def wifi_mac_address
-        interface = ADB.get_network_interface(serial, 'wlan0')
+        interface = ADB.get_network_interface(qualifier, 'wlan0')
         if interface.match(/HWaddr (.*)/)
           Regexp.last_match[1].strip
         else
@@ -294,21 +321,21 @@ module DeviceAPI
       private
 
       def get_network_info
-        ADB.get_network_info(serial)
+        ADB.get_network_info(qualifier)
       end
 
       def get_disk_info
-        @diskstat = DeviceAPI::Android::Plugin::Disk.new(serial: serial) unless @diskstat
+        @diskstat = DeviceAPI::Android::Plugin::Disk.new(qualifier: qualifier) unless @diskstat
         @diskstat.process_stats      
       end
 
       def get_battery_info
-        @battery = DeviceAPI::Android::Plugin::Battery.new(serial: serial) unless @battery
+        @battery = DeviceAPI::Android::Plugin::Battery.new(qualifier: qualifier) unless @battery
         @battery
       end
 
       def get_memory_info
-        @memory = DeviceAPI::Android::Plugin::Memory.new(serial: serial) unless @memory
+        @memory = DeviceAPI::Android::Plugin::Memory.new(qualifier: qualifier) unless @memory
         @memory
       end
 
@@ -321,34 +348,34 @@ module DeviceAPI
 
       def get_prop(key)
         if !@props || !@props[key]
-          @props = ADB.getprop(serial)
+          @props = ADB.getprop(qualifier)
         end
         @props[key]
       end
 
       def get_dumpsys(key)
-        @props = ADB.getdumpsys(serial)
+        @props = ADB.getdumpsys(qualifier)
         @props[key]
       end
 
       def get_powerinfo
-        ADB.getpowerinfo(serial)
+        ADB.getpowerinfo(qualifier)
       end
 
       def get_phoneinfo
-        ADB.getphoneinfo(serial)
+        ADB.getphoneinfo(qualifier)
       end
 
       def install_apk(apk)
-        ADB.install_apk(apk: apk, serial: serial)
+        ADB.install_apk(apk: apk, qualifier: qualifier)
       end
 
       def uninstall_apk(package_name)
-        ADB.uninstall_apk(package_name: package_name, serial: serial)
+        ADB.uninstall_apk(package_name: package_name, qualifier: qualifier)
       end
 
       def get_dpi
-        ADB.get_device_dpi(serial)
+        ADB.get_device_dpi(qualifier)
       end
     end
 

data/lib/device_api/android/device/kindle.rb

@@ -6,11 +6,12 @@ module DeviceAPI
       # you can unlock that device by broadcasting a 'WakeUp' intent. On Kindle devices, this does not
       # work due to Amazons implementation of the Keyguard.
       def unlock
-        ADB.keyevent(serial, '26') unless screen_on?
+        ADB.keyevent(qualifier, '26') unless screen_on?
         if orientation == :landscape
-          ADB.swipe(serial, { x_from: 500, y_from: 575, x_to: 500, y_to: 250 } )
+          ADB.swipe(qualifier, { x_from: 500, y_from: 750, x_to: 500, y_to: 250 } ) if version.split('.').first.to_i >= 5
+          ADB.swipe(qualifier, { x_from: 900, y_from: 500, x_to: 300, y_to: 500 } ) if version.split('.').first.to_i < 5
         else
-          ADB.swipe(serial, { x_from: 300, y_from: 900, x_to: 300, y_to: 600 } )
+          ADB.swipe(qualifier, { x_from: 300, y_from: 900, x_to: 300, y_to: 600 } )
         end
       end
     end

data/lib/device_api/android/plugins/audio.rb

@@ -3,14 +3,14 @@ module DeviceAPI
     module Plugin
       class Audio
 
-        attr_reader :serial
+        attr_reader :qualifier
 
         def initialize(options)
-          @serial = options #[:serial]
+          @qualifier = options #[:serial]
         end
 
         def get_volume_steps
-          audio = ADB.dumpsys( @serial, 'audio' )
+          audio = ADB.dumpsys( @qualifier, 'audio' )
           vol_steps = audio.detect { |a| a.include?('volume steps:') }
           return nil if vol_steps.nil?
 
@@ -58,12 +58,12 @@ module DeviceAPI
 
         def change_volume(op, key)
           op.times do
-            ADB.keyevent(@serial, key )
+            ADB.keyevent(@qualifier, key )
           end
         end
 
         def get_system_volume
-          audio = ADB.dumpsys( @serial, 'audio' )
+          audio = ADB.dumpsys( @qualifier, 'audio' )
           index = audio.index('- STREAM_SYSTEM:')
 
           return nil if index.nil?

data/lib/device_api/android/plugins/battery.rb

@@ -5,8 +5,8 @@ module DeviceAPI
         attr_reader :current_temp, :max_temp, :max_current, :voltage, :level, :health, :status
 
         def initialize(options = {})
-          serial = options[:serial]
-          props = ADB.get_battery_info(serial)
+          qualifier = options[:qualifier]
+          props = ADB.get_battery_info(qualifier)
           @current_temp   = props["temperature"]
           @max_temp       = props["mBatteryMaxTemp"]
           @max_current    = props["mBatteryMaxCurrent"]

data/lib/device_api/android/plugins/disk.rb

@@ -3,14 +3,14 @@ module DeviceAPI
     module Plugin
       class Disk
 
-        attr_reader :serial
+        attr_reader :qualifier
         def initialize(options = {})
-          @serial = options[:serial]
+          @qualifier = options[:qualifier]
         end
 
         def process_stats(options = {})
           disk_info = {}
-          stats = options[:data] || ADB.dumpsys(@serial, 'diskstats')
+          stats = options[:data] || ADB.dumpsys(@qualifier, 'diskstats')
           stats.each do |stat|
             if /(.*)-.*:\s(.*)\s\/\s([0-9]*[A-Z])\s[a-z]*\s=\s([0-9]*%)/.match(stat)
               disk_info["#{Regexp.last_match[1].downcase}_total"] = Regexp.last_match[3]

data/lib/device_api/android/plugins/memory.rb

@@ -31,8 +31,8 @@ module DeviceAPI
         attr_accessor :processes, :mem_info
 
         def initialize(options = {})
-          @serial = options[:serial]
-          info = options[:data] || ADB.dumpsys(@serial, 'meminfo')
+          @qualifier = options[:qualifier]
+          info = options[:data] || ADB.dumpsys(@qualifier, 'meminfo')
           process_data(info)
         end
 
@@ -46,7 +46,7 @@ module DeviceAPI
         end
 
         def update
-          meminfo = ADB.dumpsys(@serial, 'meminfo')
+          meminfo = ADB.dumpsys(@qualifier, 'meminfo')
           process_data(meminfo)
         end
 

data/lib/device_api/android/signing.rb

@@ -54,6 +54,7 @@ module DeviceAPI
       # @param [String] apk_path full path to apk to check
       # @return returns false if the apk is unsigned, true if it is signed
       def self.is_apk_signed?(apk_path)
+        raise SigningCommandError.new('AAPT not available') unless DeviceAPI::Android::AAPT.aapt_available?
         result = execute("aapt list #{apk_path} | grep '^META-INF\/.*'")
         return false if result.stdout.empty?
         true
@@ -63,6 +64,7 @@ module DeviceAPI
       # @param [String] apk_path full path to the apk
       # @return [Boolean, Exception] returns true if the apk is successfully unsigned, otherwise an exception is raised
       def self.unsign_apk(apk_path)
+        raise SigningCommandError.new('AAPT not available') unless DeviceAPI::Android::AAPT.aapt_available?
         file_list = execute("aapt list #{apk_path} | grep '^META-INF\/.*'")
         result = execute("aapt remove #{apk_path} #{file_list.stdout.split(/\s+/).join(' ')}")
         raise SigningCommandError.new(result.stderr) if result.exit != 0

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: device_api-android
 version: !ruby/object:Gem::Version
-  version: 1.2.9
+  version: 1.2.10
 platform: ruby
 authors:
 - David Buckhurst
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-09 00:00:00.000000000 Z
+date: 2016-10-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: device_api
@@ -79,7 +79,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.6
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Android Device Management API