device_api-android 1.0.1 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d7f064ddcac962170d4089858a6a791625388805
-  data.tar.gz: 819b3797ef5b61c59383682c3758dcfa48ceb00d
+  metadata.gz: d056fdaa82d61147897272f7a3df98afd5f8e4af
+  data.tar.gz: ea866645ded8c453e60ac3baec01ee929d983c2e
 SHA512:
-  metadata.gz: 819d33204b007a4ddfad07262978c0832f980287810d170e23f0034f7b8e06a203699bf98da9538a71d6549121a8de2e5010d29367120e3820ba090a0a923aef
-  data.tar.gz: b55962d0d3e0511ea0877f4908c7d552916009b8d8ea43101ed16d90a2e656b58c5b67795766a2b4563fc502a850471408f9257ae42e2f8bfe52b7788edcc108
+  metadata.gz: 856ed8986cc089f9acc2098036a7e1deb95c93f86926f93bdbc2edd22f7cd5f5e4d7e255728049ee2d6321cde1910f54f810f1e3b5cdadba494385b86f9e40aa
+  data.tar.gz: 8b4a040ad4a5a01d652a7b1967ed3e1921726c5dcc1a6f916d76211616c465a9961607148e782f886444c245ac336127bf503c05b76684aa1d7ef1c2f1213caa

data/51-android.rules

@@ -50,6 +50,8 @@ SUBSYSTEM=="usb", ATTR{idVendor}=="1949", ATTR{idProduct}=="000b", MODE="0666",
 SUBSYSTEM=="usb", ATTR{idVendor}=="1949", ATTR{idProduct}=="000c", MODE="0666", OWNER="hive"
 # Kindle Fire (Pink Case)
 SUBSYSTEM=="usb", ATTR{idVendor}=="1949", ATTR{idProduct}=="00f2", MODE="0666", OWNER="hive"
+# Kindle Fire HDX 8.9 (3rd Generation) OS 4.5.5
+SUBSYSTEM=="usb", ATTR{idVendor}=="1949", ATTR{idProduct}=="000d", mode="0666", OWNER="hive"
 # Sony Ericsson ST25i 
 SUBSYSTEM=="usb", ATTR{idVendor}=="0fce", ATTR{idProduct}=="5171", MODE="0666", OWNER="hive"
 # Galaxy S2/S3

data/Gemfile.lock

@@ -1,20 +1,21 @@
 GEM
   remote: https://rubygems.org/
   specs:
-    device_api (1.0.0)
+    device_api (1.0.1)
     diff-lcs (1.2.5)
-    rspec (3.0.0)
-      rspec-core (~> 3.0.0)
-      rspec-expectations (~> 3.0.0)
-      rspec-mocks (~> 3.0.0)
-    rspec-core (3.0.4)
-      rspec-support (~> 3.0.0)
-    rspec-expectations (3.0.4)
+    rspec (3.3.0)
+      rspec-core (~> 3.3.0)
+      rspec-expectations (~> 3.3.0)
+      rspec-mocks (~> 3.3.0)
+    rspec-core (3.3.1)
+      rspec-support (~> 3.3.0)
+    rspec-expectations (3.3.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.0.0)
-    rspec-mocks (3.0.4)
-      rspec-support (~> 3.0.0)
-    rspec-support (3.0.4)
+      rspec-support (~> 3.3.0)
+    rspec-mocks (3.3.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-support (3.3.0)
 
 PLATFORMS
   ruby

data/device_api-android.gemspec

@@ -1,10 +1,10 @@
 Gem::Specification.new do |s|
   s.name        = 'device_api-android'
-  s.version     = '1.0.1'
+  s.version     = '1.1.2'
   s.date        = Time.now.strftime("%Y-%m-%d")
   s.summary     = 'Android Device Management API'
   s.description = 'Android implementation of DeviceAPI'
-  s.authors     = ['BBC','David Buckhurst','Jitesh Gosai', 'Jon Wilson']
+  s.authors     = ['David Buckhurst','Jitesh Gosai', 'Jon Wilson']
   s.email       = 'david.buckhurst@bbc.co.uk'
   s.files       = `git ls-files`.split "\n"
   s.homepage    = 'https://github.com/bbc/device_api-android'

data/lib/device_api/android.rb

@@ -3,13 +3,21 @@ require 'device_api/android/adb'
 require 'device_api/android/device'
 require 'device_api/android/signing'
 
+# Load plugins
+require 'device_api/android/plugins/memory'
+require 'device_api/android/plugins/battery'
+require 'device_api/android/plugins/disk'
+
+# Load additional device types
+require 'device_api/android/device/kindle'
+
 module DeviceAPI
   module Android
     # Returns array of connected android devices
     def self.devices
       ADB.devices.map do |d|
         if d.keys.first && !d.keys.first.include?('?')
-          DeviceAPI::Android::Device.new(serial: d.keys.first, state: d.values.first)
+          DeviceAPI::Android::Device.create( self.get_device_type(d.keys.first), { serial: d.keys.first, state: d.values.first } )
         end
       end
     end
@@ -20,7 +28,19 @@ module DeviceAPI
         raise DeviceAPI::BadSerialString.new("serial was '#{serial.nil? ? 'nil' : serial}'")
       end
       state = ADB.get_state(serial)
-      DeviceAPI::Android::Device.new(serial: serial, state: state)
+      DeviceAPI::Android::Device.create( self.get_device_type(serial),  { serial: serial, state: state })
+    end
+
+    # Return the device type used in determining which Device Object to create
+    def self.get_device_type(serial)
+      return :default if Device.new(serial: serial).manufacturer.nil?
+      case Device.new(serial: serial).manufacturer.downcase
+        when 'amazon'
+          type = :kindle
+        else
+          type = :default
+      end
+      type
     end
   end
 

data/lib/device_api/android/aapt.rb

@@ -26,23 +26,7 @@ module DeviceAPI
 
         fail result.stderr if result.exit != 0
 
-        lines = result.stdout.split("\n")
-        results = []
-        lines.each do |l|
-          if /(.*): (.*)/.match(l)
-            # results.push(Regexp.last_match[1].strip => Regexp.last_match[2].strip)
-            values = {}
-
-            Regexp.last_match[2].strip.split(' ').each do |item| # split on an spaces
-              item = item.to_s.tr('\'', '') # trim off any excess single quotes
-              values[item.split('=')[0]] = item.split('=')[1] # split on the = and create a new hash
-            end
-
-            results << {Regexp.last_match[1].strip => values} # append the result tp new_result
-
-          end
-        end
-        results
+        result.stdout.scan(/(.*): (.*)/).map { |a,b| { a => Hash[b.split(' ').map { |c| c.tr('\'','').split('=') }] } }
       end
 
     end

data/lib/device_api/android/adb.rb

@@ -18,17 +18,7 @@ module DeviceAPI
         result = execute_with_timeout_and_retry('adb devices')
 
         raise ADBCommandError.new(result.stderr) if result.exit != 0
-
-        lines = result.stdout.split("\n")
-        results = []
-
-        lines.shift # Drop the message line
-        lines.each do |l|
-          if /(.*)\t(.*)/.match(l)
-            results.push(Regexp.last_match[1].strip => Regexp.last_match[2].strip)
-          end
-        end
-        results
+        result.stdout.scan(/(.*)\t(.*)/).map { |a,b| {a => b}}
       end
 
       # Retrieve device state for a single device
@@ -54,13 +44,7 @@ module DeviceAPI
 
         lines = result.stdout.split("\n")
 
-        props = {}
-        lines.each do |l|
-          if /\[(.*)\]:\s+\[(.*)\]/.match(l)
-            props[Regexp.last_match[1]] = Regexp.last_match[2]
-          end
-        end
-        props
+        process_dumpsys('\[(.*)\]:\s+\[(.*)\]', lines)
       end
 
       # Get the 'input' information from dumpsys
@@ -68,14 +52,7 @@ module DeviceAPI
       # @return (Hash) hash containing input information from dumpsys
       def self.getdumpsys(serial)
         lines = dumpsys(serial, 'input')
-
-        props = {}
-        lines.each do |l|
-          if /(.*):\s+(.*)/.match(l)
-            props[Regexp.last_match[1]] = Regexp.last_match[2]
-          end
-        end
-        props
+        process_dumpsys('(.*):\s+(.*)', lines)
       end
 
       # Get the 'iphonesubinfo' from dumpsys
@@ -83,16 +60,52 @@ module DeviceAPI
       # @return (Hash) hash containing iphonesubinfo information from dumpsys
       def self.getphoneinfo(serial)
         lines = dumpsys(serial, 'iphonesubinfo')
+        process_dumpsys('(.*) =\s+(.*)', lines)
+      end
+
+      # Get the 'battery' information from dumpsys
+      # @param [String] serial serial number of device
+      # @return [Hash] hash containing battery information from dumpsys
+      def self.get_battery_info(serial)
+        lines = dumpsys(serial, 'battery')
+        process_dumpsys('(.*):\s+(.*)', lines)
+      end
 
+      # Processes the results from dumpsys to format them into a hash
+      # @param [String] regex_string regex string used to separate the results from the keys
+      # @param [Array] data data returned from dumpsys
+      # @return [Hash] hash containing the keys and values as distinguished by the supplied regex
+      def self.process_dumpsys(regex_string, data)
         props = {}
-        lines.each do |l|
-          if /(.*) =\s+(.*)/.match(l)
+        regex = Regexp.new(regex_string)
+        data.each do |line|
+          if regex.match(line)
             props[Regexp.last_match[1]] = Regexp.last_match[2]
           end
         end
+
         props
       end
 
+      # Get the 'power' information from dumpsys
+      # @param [String] serial serial number of device
+      # @return [Hash] hash containing power information from dumpsys
+      def self.getpowerinfo(serial)
+        lines = dumpsys(serial, 'power')
+        process_dumpsys('(.*)=(.*)', lines)
+      end
+
+      def self.get_device_dpi(serial)
+        lines = dumpsys(serial, 'window')
+        dpi = nil
+        lines.each do |line|
+          if /sw(\d*)dp/.match(line)
+            dpi = Regexp.last_match[1]
+          end
+        end
+        dpi
+      end
+
       # Returns the 'dumpsys' information from the specified device
       # @param serial serial number of device
       # @return (Array) array of results from adb shell dumpsys
@@ -108,18 +121,8 @@ module DeviceAPI
       # @option options [String] :serial serial number of device
       # @return (String) return result from adb install command
       def self.install_apk(options = {})
-        apk = options[:apk]
-        serial = options[:serial]
-        result = execute("adb -s #{serial} install #{apk}")
-
-        raise ADBCommandError.new(result.stderr) if result.exit != 0
-
-        lines = result.stdout.split("\n").map { |line| line.strip }
-        # lines.each do |line|
-        #  res=:success if line=='Success'
-        # end
-
-        lines.last
+        options[:action] = :install
+        change_apk(options)
       end
 
       # Uninstalls a specified package from a specified device
@@ -128,9 +131,27 @@ module DeviceAPI
       # @option options [String] :serial serial number of device
       # @return (String) return result from adb uninstall command
       def self.uninstall_apk(options = {})
+        options[:action] = :uninstall
+        change_apk(options)
+      end
+
+      def self.change_apk(options = {})
         package_name = options[:package_name]
+        apk = options[:apk]
         serial = options[:serial]
-        result = execute("adb -s #{serial} uninstall #{package_name}")
+        action = options[:action]
+
+        case action
+          when :install
+            command = "adb -s #{serial} install #{apk}"
+          when :uninstall
+            command = "adb -s #{serial} uninstall #{package_name}"
+          else
+            raise ADBCommandError.new('No action specified')
+        end
+
+        result = execute(command)
+
         raise ADBCommandError.new(result.stderr) if result.exit != 0
 
         lines = result.stdout.split("\n").map { |line| line.strip }
@@ -203,6 +224,51 @@ module DeviceAPI
         execute(cmd)
       end
 
+      # Returns wifi status and access point name
+      # @param serial serial number of device
+      # @example
+      #   DeviceAPI::ADB.wifi(serial)
+      def self.wifi(serial)
+        result = execute("adb -s #{serial} shell dumpsys wifi | grep mNetworkInfo")
+        if result.exit != 0
+          raise ADBCommandError.new(result.stderr) 
+        else
+          result = {:status => result.stdout.match("state:(.*?),")[1].strip, :access_point => result.stdout.match("extra:(.*?),")[1].strip.gsub(/"/,'')}
+        end
+        result
+      end
+
+      # Sends a key event to the specified device
+      # @param [String] serial serial number of device
+      # @param [String] keyevent keyevent to send to the device
+      def self.keyevent(serial, keyevent)
+        result = execute("adb -s #{serial} shell input keyevent #{keyevent}")
+        raise ADBCommandError.new(result.stderr) if result.exit != 0
+      end
+
+      # Sends a swipe command to the specified device
+      # @param [String] serial serial number 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, x_to: 0, y_from: 0, y_to: 0 })
+        execute("adb -s #{serial} shell input swipe #{coords[:x_from]} #{coords[:x_to]} #{coords[:y_from]} #{coords[:y_to]}")
+        raise ADBCommandError.new(result.stderr) if result.exit != 0
+      end
+
+      # Starts intent using adb 
+      # Returns stdout
+      # @param serial serial number of device 
+      # @param command -option activity 
+      # @example
+      # DeviceAPI::ADB.am(serial, "-a android.intent.action.MAIN -n com.android.settings/.wifi.WifiSettings")
+      def self.am(serial, command)
+        result = execute("adb -s #{serial} shell am start #{command}")
+        raise ADBCommandError.new(result.stderr) if result.exit != 0
+        return result.stdout
+      end
     end
 
     # ADB Error class

data/lib/device_api/android/device.rb

@@ -9,6 +9,21 @@ module DeviceAPI
   module Android
     # Device class used for containing the accessors of the physical device information
     class Device < DeviceAPI::Device
+
+      @@subclasses; @@subclasses = {}
+
+      # Called by any inheritors to register themselves with the parent class
+      def self.inherited(klass)
+        key = /::([^:]+)$/.match(klass.to_s.downcase)[1].to_sym
+        @@subclasses[key] = klass
+      end
+
+      # Returns an object of the specified type, if it exists. Defaults to returning self
+      def self.create(type, options = {} )
+        return @@subclasses[type.to_sym].new(options) if @@subclasses[type.to_sym]
+        return self.new(options)
+      end
+
       def initialize(options = {})
         @serial = options[:serial]
         @state = options[:state]
@@ -58,13 +73,25 @@ module DeviceAPI
         get_prop('ro.build.version.release')
       end
 
+      # Return the battery level
+      # @return (String) device battery level
+      def battery_level
+        get_battery_info['level']
+      end
+
+      # Is the device currently being powered?
+      # @return (Boolean) true if it is being powered in some way, false if it is unpowered
+      def powered?
+        !get_battery_info.select { |keys| keys.include?('powered')}.select { |_,v| v == 'true' }.empty?
+      end
+
       # Return the device orientation
       # @return (String) current device orientation
       def orientation
         res = get_dumpsys('SurfaceOrientation')
 
         case res
-          when '0'
+          when '0','2'
             :portrait
           when '1', '3'
             :landscape
@@ -141,8 +168,94 @@ module DeviceAPI
         get_phoneinfo['Device ID']
       end
 
+      # Get the memory information for the current device
+      # @return [DeviceAPI::Android::Plugins::Memory] the memory plugin containing relevant information
+      def memory
+        get_memory_info
+      end
+
+      def battery
+        get_battery_info
+      end
+
+      # Check if the devices screen is currently turned on
+      # @return [Boolean] true if the screen is on, otherwise false
+      def screen_on?
+        return true if get_powerinfo['mScreenOn'].to_s.downcase == 'true'
+        false
+      end
+
+      # Unlock the device by sending a wakeup command
+      def unlock
+        ADB.keyevent(serial, '26') unless screen_on?
+      end
+
+      # Return the DPI of the attached device
+      # @return [String] DPI of attached device
+      def dpi
+        get_dpi(serial)
+      end
+
+      # Return the device type based on the DPI
+      # @return [Symbol] :tablet or :mobile based upon the devices DPI
+      def type
+        if get_dpi.to_i > 533
+          :tablet
+        else
+          :mobile
+        end
+      end
+
+      # Returns wifi status and access point name
+      # @return [Hash] :status and :access_point
+      def wifi_status
+        ADB.wifi(serial)
+      end
+
+      def battery_info
+        ADB.get_battery_info(serial)
+      end
+
+      # @param [String] command to start the intent
+      # Return the stdout of executed intent
+      # @return [String] stdout
+      def start_intent(command)
+        ADB.am(serial,command)
+      end
+
+      #Reboots the device
+      def reboot
+        ADB.reboot(serial)
+      end
+
+      # Returns disk status
+      # @return [Hash] containing disk statistics
+      def diskstat
+        get_disk_info
+      end
+
+      # Returns the device uptime
+      def uptime
+        ADB.get_uptime(serial)
+      end
+      
       private
 
+      def get_disk_info
+        @diskstat = DeviceAPI::Android::Plugin::Disk.new(serial: serial) unless @diskstat
+        @diskstat.process_stats      
+      end
+
+      def get_battery_info
+        @battery = DeviceAPI::Android::Plugin::Battery.new(serial: serial) unless @battery
+        @battery
+      end
+
+      def get_memory_info
+        @memory = DeviceAPI::Android::Plugin::Memory.new(serial: serial) unless @memory
+        @memory
+      end
+
       def get_app_props(key)
         unless @app_props
           @app_props = AAPT.get_app_props(@apk)
@@ -162,6 +275,11 @@ module DeviceAPI
         @props[key]
       end
 
+      def get_powerinfo
+        ADB.getpowerinfo(serial)
+      end
+
+
       def get_phoneinfo
         ADB.getphoneinfo(serial)
       end
@@ -173,6 +291,10 @@ module DeviceAPI
       def uninstall_apk(package_name)
         ADB.uninstall_apk(package_name: package_name, serial: serial)
       end
+
+      def get_dpi
+        ADB.get_device_dpi(serial)
+      end
     end
   end
 end

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

@@ -0,0 +1,14 @@
+module DeviceAPI
+  module Android
+    # Kindle specific device class
+    class Kindle < Device
+      # On non-Kindle devices, if a device is locked without a password (i.e. 'Swipe to unlock'), then
+      # 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.swipe(serial, { x_from: 900, x_to: 300, y_from: 100, y_to: 100 } )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module DeviceAPI
+  module Android
+    module Plugin
+      class Battery
+        attr_reader :current_temp, :max_temp, :max_current, :voltage, :level, :health, :status
+
+        def initialize(options = {})
+          serial = options[:serial]
+          props = ADB.get_battery_info(serial)
+          @current_temp   = props["temperature"]
+          @max_temp       = props["mBatteryMaxTemp"]
+          @max_current    = props["mBatteryMaxCurrent"]
+          @voltage        = props["voltage"]
+          @level          = props["level"]
+          @health         = props["health"]
+          @status         = props["status"]
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,29 @@
+module DeviceAPI
+  module Android
+    module Plugin
+      class Disk
+
+        attr_reader :serial
+        def initialize(options = {})
+          @serial = options[:serial]
+        end
+
+        def process_stats(options = {})
+          disk_info = {}
+          stats = options[:data] || ADB.dumpsys(@serial, '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]
+              disk_info["#{Regexp.last_match[1].downcase}_free"] = Regexp.last_match[4]
+              disk_info["#{Regexp.last_match[1].downcase}_used"] = Regexp.last_match[2]
+            elsif /(.*):\s(\S*)/.match(stat)
+              disk_info[Regexp.last_match[1].downcase] = Regexp.last_match[2]
+            end
+          end 
+          disk_info
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+module DeviceAPI
+  module Android
+    # Plugins contain extra information about the attached device(s)
+    module Plugin
+      # Class used to provide information about process memory usage
+      # and device memory usage
+      class Memory
+
+        # Class used for holding process information
+        class MemInfo
+          attr_reader :process, :memory, :pid
+          def initialize(options = {})
+            @process = options[:process]
+            @memory = options[:memory]
+            @pid = options[:pid]
+          end
+        end
+
+        # Class used for storing process information
+        class RAM
+          attr_accessor :total, :free, :used, :lost, :tuning
+          def initialize(options = {})
+            @total  = options[:total]
+            @free   = options[:free]
+            @used   = options[:used]
+            @lost   = options[:lost]
+            @tuning = options[:tuning]
+          end
+        end
+
+        attr_accessor :processes, :mem_info
+
+        def initialize(options = {})
+          @serial = options[:serial]
+          info = options[:data] || ADB.dumpsys(@serial, 'meminfo')
+          process_data(info)
+        end
+
+        def process_data(memory_info)
+          groups = memory_info.chunk { |a| a == '' }.reject { |a,_| a  }.map { |_,b| b }
+
+          raise 'A different ADB result has been received' unless groups[1].first == 'Total PSS by process:'
+          @processes = []
+          process_total_pss_by_process(groups[1])
+          process_ram_info(groups[4])
+        end
+
+        def update
+          meminfo = ADB.dumpsys(@serial, 'meminfo')
+          process_data(meminfo)
+        end
+
+        # Processes memory used by each running process
+        def process_total_pss_by_process(data)
+          data.each do |l|
+            if /(.*):\s+(.*)\s+\(.*pid\s+(\S*).*\)/.match(l)
+              @processes << MemInfo.new(process: Regexp.last_match[2], memory: Regexp.last_match[1], pid: Regexp.last_match[3] )
+            end
+          end
+        end
+
+        # Processes memory used by the device
+        def process_ram_info(data)
+          ram_info = {}
+          data.each do |l|
+            if /Tuning:\s+(.*)/.match(l)
+              ram_info['tuning'] = Regexp.last_match[1]
+            elsif /(.*):\s(-?[0-9]*\s\S*)/.match(l)
+              ram_info[Regexp.last_match[1].downcase] = Regexp.last_match[2]
+            end
+          end
+          @mem_info = RAM.new(total: ram_info['total ram'], free: ram_info['free ram'], used: ram_info['used ram'], lost: ram_info['lost'], tuning: ram_info['tuning'])
+        end
+      end
+    end
+  end
+end

data/lib/device_api/android/signing.rb

@@ -54,7 +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)
-        result = execute("aapt list #{apk_path} | grep '^META-INF.*\.RSA$'")
+        result = execute("aapt list #{apk_path} | grep '^META-INF\/.*'")
         return false if result.stdout.empty?
         true
       end
@@ -63,7 +63,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)
-        file_list = execute("aapt list #{apk_path} | grep '^META-INF.*\.RSA$'")
+        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
         true

data/spec/adb_spec.rb

@@ -135,4 +135,23 @@ _______________________________________________________
     end
   end
 
+   describe ".wifi" do
+    it "returns wifi info" do
+      out= <<_______________________________________________________
+mNetworkInfo [type: WIFI[], state: CONNECTED/CONNECTED, reason: (unspecified), extra: "TVMP-DevNet", roaming: false, failover: false, isAvailable: true, isConnectedToProvisioningNetwork: false]
+_______________________________________________________
+    allow(Open3).to receive(:capture3) { [out, '', $STATUS_ZERO] }
+    expect( DeviceAPI::Android::ADB.wifi('12345').class).to eq(Hash)
+    end
+  end
+
+  describe ".am" do
+    it "returns the stdout" do
+      out= <<_______________________________________________________
+Starting: Intent { act=android.intent.action.MAIN cmp=com.android.settings/.wifi.WifiSettings }
+_______________________________________________________
+    allow(Open3).to receive(:capture3) { [out, '', $STATUS_ZERO] }
+    expect( DeviceAPI::Android::ADB.am('03157df373208426' ,'12345').class).to eq(String)
+    end
+  end
 end

data/spec/android_device_spec.rb

@@ -7,7 +7,7 @@ describe DeviceAPI::Android do
 
     it 'Returns an empty array when no devices are connected' do
       out = <<_______________________________________________________
-    List of devices attached
+List of devices attached
 
 _______________________________________________________
       allow(Open3).to receive(:capture3) { [out, '', $STATUS_ZERO] }
@@ -16,8 +16,8 @@ _______________________________________________________
 
     it "returns an array with a single item when there's one device attached" do
       out = <<_______________________________________________________
-    List of devices attached
-    SH34RW905290	device
+List of devices attached
+SH34RW905290	device
 
 _______________________________________________________
       allow(Open3).to receive(:capture3) { [out, '', $STATUS_ZERO] }

metadata

@@ -1,17 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: device_api-android
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.2
 platform: ruby
 authors:
-- BBC
 - David Buckhurst
 - Jitesh Gosai
 - Jon Wilson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-22 00:00:00.000000000 Z
+date: 2015-10-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: device_api
@@ -64,7 +63,10 @@ files:
 - lib/device_api/android/aapt.rb
 - lib/device_api/android/adb.rb
 - lib/device_api/android/device.rb
-- lib/device_api/android/devices/default.rb
+- lib/device_api/android/device/kindle.rb
+- lib/device_api/android/plugins/battery.rb
+- lib/device_api/android/plugins/disk.rb
+- lib/device_api/android/plugins/memory.rb
 - lib/device_api/android/signing.rb
 - spec/adb_spec.rb
 - spec/android_device_spec.rb
@@ -90,9 +92,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Android Device Management API
 test_files: []
-has_rdoc: