device_api-android 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d7f064ddcac962170d4089858a6a791625388805
+  data.tar.gz: 819b3797ef5b61c59383682c3758dcfa48ceb00d
+SHA512:
+  metadata.gz: 819d33204b007a4ddfad07262978c0832f980287810d170e23f0034f7b8e06a203699bf98da9538a71d6549121a8de2e5010d29367120e3820ba090a0a923aef
+  data.tar.gz: b55962d0d3e0511ea0877f4908c7d552916009b8d8ea43101ed16d90a2e656b58c5b67795766a2b4563fc502a850471408f9257ae42e2f8bfe52b7788edcc108

data/.gitignore

@@ -0,0 +1,2 @@
+.idea
+

data/51-android.rules

@@ -0,0 +1,60 @@
+# adb protocol on passion (Nexus One)
+SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", ATTR{idProduct}=="4e12", MODE="0600", OWNER="hive"
+# fastboot protocol on passion (Nexus One)
+SUBSYSTEM=="usb", ATTR{idVendor}=="0bb4", ATTR{idProduct}=="0fff", MODE="0600", OWNER="hive"
+# adb protocol on crespo/crespo4g (Nexus S)
+SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", ATTR{idProduct}=="4e22", MODE="0600", OWNER="hive"
+# fastboot protocol on crespo/crespo4g (Nexus S)
+SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", ATTR{idProduct}=="4e20", MODE="0600", OWNER="hive"
+# adb protocol on stingray/wingray (Xoom)
+SUBSYSTEM=="usb", ATTR{idVendor}=="22b8", ATTR{idProduct}=="70a9", MODE="0600", OWNER="hive"
+# fastboot protocol on stingray/wingray (Xoom)
+SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", ATTR{idProduct}=="708c", MODE="0600", OWNER="hive"
+# adb protocol on maguro/toro (Galaxy Nexus)
+SUBSYSTEM=="usb", ATTR{idVendor}=="04e8", ATTR{idProduct}=="6860", MODE="0600", OWNER="hive"
+# fastboot protocol on maguro/toro (Galaxy Nexus)
+SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", ATTR{idProduct}=="4e30", MODE="0600", OWNER="hive"
+# adb protocol on panda (PandaBoard)
+SUBSYSTEM=="usb", ATTR{idVendor}=="0451", ATTR{idProduct}=="d101", MODE="0600", OWNER="hive"
+# adb protocol on panda (PandaBoard ES)
+SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", ATTR{idProduct}=="d002", MODE="0600", OWNER="hive"
+# fastboot protocol on panda (PandaBoard)
+SUBSYSTEM=="usb", ATTR{idVendor}=="0451", ATTR{idProduct}=="d022", MODE="0600", OWNER="hive"
+# usbboot protocol on panda (PandaBoard)
+SUBSYSTEM=="usb", ATTR{idVendor}=="0451", ATTR{idProduct}=="d00f", MODE="0600", OWNER="hive"
+# usbboot protocol on panda (PandaBoard ES)
+SUBSYSTEM=="usb", ATTR{idVendor}=="0451", ATTR{idProduct}=="d010", MODE="0600", OWNER="hive"
+# adb protocol on grouper/tilapia (Nexus 7)
+SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", ATTR{idProduct}=="4e42", MODE="0600", OWNER="hive"
+# fastboot protocol on grouper/tilapia (Nexus 7)
+SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", ATTR{idProduct}=="4e40", MODE="0600", OWNER="hive"
+# adb protocol on manta (Nexus 10)
+SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", ATTR{idProduct}=="4ee2", MODE="0600", OWNER="hive"
+# fastboot protocol on manta (Nexus 10)
+SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", ATTR{idProduct}=="4ee0", MODE="0600", OWNER="hive"
+# moto G 22b8:2e76
+SUBSYSTEM=="usb", ATTR{idVendor}=="22b8", ATTR{idProduct}=="2e76", MODE="0666", OWNER="hive"
+# Oneplus One
+SUBSYSTEM=="usb", ATTR{idVendor}=="05c6", ATTR{idProduct}=="6765", MODE="0666", OWNER="hive"
+# Tesco Hudl
+SUBSYSTEM=="usb", ATTR{idVendor}=="0e79", ATTR{idProduct}=="5009", MODE="0666", OWNER="hive"
+# Nexus 7 (Grouper)
+SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", ATTR{idProduct}=="4e42", MODE="0666", OWNER="hive"
+# Nexus 7 (Flo)
+SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", ATTR{idProduct}=="4ee2", MODE="0666", OWNER="hive"
+# Kindle Fire HD 8.9"
+SUBSYSTEM=="usb", ATTR{idVendor}=="1949", ATTR{idProduct}=="0008", MODE="0666", OWNER="hive"
+# Kindle Fire
+SUBSYSTEM=="usb", ATTR{idVendor}=="1949", ATTR{idProduct}=="000b", MODE="0666", OWNER="hive"
+# Kindle Fire
+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"
+# Sony Ericsson ST25i 
+SUBSYSTEM=="usb", ATTR{idVendor}=="0fce", ATTR{idProduct}=="5171", MODE="0666", OWNER="hive"
+# Galaxy S2/S3
+SUBSYSTEM=="usb", ATTR{idVendor}=="04e8", ATTR{idProduct}=="6860", MODE="0666", OWNER="hive"
+# LG G2
+SUBSYSTEM=="usb", ATTR{idVendor}=="1004", ATTR{idProduct}=="631f", MODE="0666", OWNER="hive"
+# Tesco Hudl 2
+SUBSYSTEM=="usb", ATTR{idVendor}=="1d4d", ATTR{idProduct}=="504b", MODE="0666", OWNER="hive"

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gem 'device_api', '>=1.0.0'
+
+group :test do
+  gem 'rspec'
+end

data/Gemfile.lock

@@ -0,0 +1,24 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    device_api (1.0.0)
+    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)
+      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)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  device_api (>= 1.0.0)
+  rspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 BBC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,118 @@
+# DeviceAPI-Android
+
+*DeviceAPI-Android* is the android implementation of device_api -- an initiative to allow full automation of device activities.
+
+## Dependencies
+
+device_api-android shells out to a number of android command line tools. You will need to make sure the android sdk is installed and you have the following commands on your path:
+
+* adb
+* aapt
+
+## Using the gem
+
+Add the device_api-android gem to your gemfile -- this will automatically bring in the device_api base gem on which the android gem is built.
+
+    gem 'device_api-android'
+  
+You'll need to require the library in your code:
+
+    require 'device_api/android'
+
+Try connecting an android device with usb, and run:
+
+    devices = DeviceAPI::Android.devices
+
+You might need to set your device to developer mode, and turn on usb debugging so that the android debug bridge can detect your device.
+
+### Detecting devices
+
+There are two methods for detecting devices:
+
+    DeviceAPI::Android.devices 
+
+This returns an array of objects representing the connected devices. You get an empty array if there are no connected devices.
+
+    DeviceAPI::Android.device(serial_id)
+    
+This looks for a device with a matching serial_id and returns a single device object.
+
+### Device object
+
+When device-api detects a device, it returns a device object that lets you interact with and query the device with various android tools.
+
+For example:
+
+    device = DeviceAPI::Android.device(serial_id)
+    device.serial # "01498A0004005015"
+    device.model # "Galaxy Nexus"
+
+#### Device orientation
+
+    device.orientation # :landscape / :portrait
+
+#### Install/uninstall apk
+
+    device.install('location/apk_to_install.apk') # will install the apk on the device
+    device.uninstall('my.package.name') # will uninstall the package matching the package name
+
+#### APK Signing
+
+An APK can be signed using *DeviceAPI*. To do so you can simply run:
+
+    DeviceAPI::Android::Signing.sign_apk({apk: apk_path, resign: true})
+
+If you don't already have a keystore setup then one will be created for you with some defaults already set. If you wish to setup a keystore using your own options you can do so using something like the following:
+
+    DeviceAPI::Android::Signing.generate_keystore( { keystore: '~/new_kestore.keystore', password: 'new_password' } )
+
+This allows you to setup a keystore with the options required by any testing framework
+
+### Package details
+
+    device.package_name('app.apk') # returns some.package.name
+    device.app_version_number('app.apk') # returns v#.#.#
+
+## Testing
+
+device_api-android is defended with unit and integration level rspec tests. You can run the tests with:
+    bundle exec rspec
+
+## Issues
+
+If you plug in a device and adb shows the device as having no permissions as seen here:
+
+            hive@hive-04:~$ adb devices
+            List of devices attached
+            ????????????	no permissions
+
+This is caused by the current user not having permission to access the USB interface. To resolve this, copy the 51-android.rules file to the /etc/udev/rules.d/ directory and restart adb by using the folliowing command
+
+            adb kill-server
+            adb start-server
+
+If, after copying the rules file to the correct location, you're still seeing the no permission message it may be due to the fact that the device does not have a rule setup for it. To add a new rule, type:
+
+            lsusb
+
+You should be presented with something similar to this:
+
+            Bus 002 Device 001: ID 1d6b:0003 Linux Foundation 3.0 root hub
+            Bus 001 Device 020: ID 0e79:5009 Archos, Inc.
+            Bus 001 Device 003: ID 05ac:8242 Apple, Inc. Built-in IR Receiver
+            Bus 001 Device 006: ID 05ac:8289 Apple, Inc.
+            Bus 001 Device 002: ID 0a5c:4500 Broadcom Corp. BCM2046B1 USB 2.0 Hub (part of BCM2046 Bluetooth)
+            Bus 001 Device 011: ID 05c6:6765 Qualcomm, Inc.
+            Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
+            
+The important thing to note here is the Vendor ID and Product ID for the device. In the case of the above, the device is a Tesco Hudl (showing as an Archos device) with the combinded ID of 0e79:5009 - 0e79 is the Vendor ID while 5009 is the Product ID. Open the 51-android.rules file and add the following line:
+
+            SUBSYSTEM=="usb", ATTR{idVendor}=="0e79", ATTR{idProduct}=="5009", MODE="0666", OWNER="hive"
+
+Change the Vendor and Product IDs where appropriate, also check that the owner matches the name of the account that will be running the Hive.
+
+## License
+
+*DeviceAPI-Android* is available to everyone under the terms of the MIT open source licence. Take a look at the LICENSE file in the code.
+
+Copyright (c) 2015 BBC

data/device_api-android.gemspec

@@ -0,0 +1,14 @@
+Gem::Specification.new do |s|
+  s.name        = 'device_api-android'
+  s.version     = '1.0.1'
+  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.email       = 'david.buckhurst@bbc.co.uk'
+  s.files       = `git ls-files`.split "\n"
+  s.homepage    = 'https://github.com/bbc/device_api-android'
+  s.license     = 'MIT'
+  s.add_runtime_dependency 'device_api', '>=1.0', '<2.0'
+  s.add_development_dependency 'rspec'
+end

data/lib/device_api/android.rb

@@ -0,0 +1,30 @@
+# Encoding: utf-8
+require 'device_api/android/adb'
+require 'device_api/android/device'
+require 'device_api/android/signing'
+
+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)
+        end
+      end
+    end
+
+    # Retrieve an Device object by serial id
+    def self.device(serial)
+      if serial.to_s.empty?
+        raise DeviceAPI::BadSerialString.new("serial was '#{serial.nil? ? 'nil' : serial}'")
+      end
+      state = ADB.get_state(serial)
+      DeviceAPI::Android::Device.new(serial: serial, state: state)
+    end
+  end
+
+  # Serial error class
+  class BadSerialString < StandardError
+  end
+end

data/lib/device_api/android/aapt.rb

@@ -0,0 +1,50 @@
+# Encoding: utf-8
+require 'open3'
+require 'ostruct'
+require 'device_api/execution'
+
+# DeviceAPI - an interface to allow for automation of devices
+module DeviceAPI
+  # Android component of DeviceAPI
+  module Android
+    # Namespace for all methods encapsulating aapt calls
+    class AAPT < DeviceAPI::Execution
+
+      # Check to ensure that aapt has been setup correctly and is available
+      # @return (Boolean) true if aapt is available, false otherwise
+      def self.aapt_available?
+        result = execute('which aapt')
+        result.exit == 0
+      end
+
+      # Gets properties from the apk and returns them in a hash
+      # @param apk path to the apk
+      # @return (Hash) list of properties from the apk
+      def self.get_app_props(apk)
+        raise StandardError.new('aapt not found - please create a symlink in $ANDROID_HOME/tools') unless aapt_available?
+        result = execute("aapt dump badging #{apk}")
+
+        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
+      end
+
+    end
+  end
+end

data/lib/device_api/android/adb.rb

@@ -0,0 +1,217 @@
+# Encoding: utf-8
+# TODO: create new class for aapt that will get the package name from an apk using: JitG
+# aapt dump badging packages/bbciplayer-debug.apk
+require 'open3'
+require 'ostruct'
+require 'device_api/execution'
+
+# DeviceAPI - an interface to allow for automation of devices
+module DeviceAPI
+  # Android component of DeviceAPI
+  module Android
+    # Namespace for all methods encapsulating adb calls
+    class ADB < Execution
+      # Returns an array representing connected devices
+      # DeviceAPI::ADB.devices #=> { '1232132' => 'device' }
+      # @return (Array) list of attached devices
+      def self.devices
+        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
+      end
+
+      # Retrieve device state for a single device
+      # @param serial serial number of device
+      # @return (String) device state
+      def self.get_state(serial)
+        result = execute('adb get-state -s #{serial}')
+
+        raise ADBCommandError.new(result.stderr) if result.exit != 0
+
+        lines = result.stdout.split("\n")
+        /(.*)/.match(lines.last)
+        Regexp.last_match[0].strip
+      end
+
+      # Get the properties of a specified device
+      # @param serial serial number of device
+      # @return (Hash) hash containing device properties
+      def self.getprop(serial)
+        result = execute("adb -s #{serial} shell getprop")
+
+        raise ADBCommandError.new(result.stderr) if result.exit != 0
+
+        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
+      end
+
+      # Get the 'input' information from dumpsys
+      # @param serial serial number of device
+      # @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
+      end
+
+      # Get the 'iphonesubinfo' from dumpsys
+      # @param serial serial number of device
+      # @return (Hash) hash containing iphonesubinfo information from dumpsys
+      def self.getphoneinfo(serial)
+        lines = dumpsys(serial, 'iphonesubinfo')
+
+        props = {}
+        lines.each do |l|
+          if /(.*) =\s+(.*)/.match(l)
+            props[Regexp.last_match[1]] = Regexp.last_match[2]
+          end
+        end
+        props
+      end
+
+      # Returns the 'dumpsys' information from the specified device
+      # @param serial serial number of device
+      # @return (Array) array of results from adb shell dumpsys
+      def self.dumpsys(serial, command)
+        result = execute("adb -s #{serial} shell dumpsys #{command}")
+        raise ADBCommandError.new(result.stderr) if result.exit != 0
+        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
+      # @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
+      end
+
+      # 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
+      # @return (String) return result from adb uninstall command
+      def self.uninstall_apk(options = {})
+        package_name = options[:package_name]
+        serial = options[:serial]
+        result = execute("adb -s #{serial} uninstall #{package_name}")
+        raise ADBCommandError.new(result.stderr) if result.exit != 0
+
+        lines = result.stdout.split("\n").map { |line| line.strip }
+
+        lines.last
+      end
+
+      # Returns the uptime of the specified device
+      # @param serial serial number of device
+      # @return (Float) uptime in seconds
+      def self.get_uptime(serial)
+        result = execute("adb -s #{serial} shell cat /proc/uptime")
+
+        raise ADBCommandError.new(result.stderr) if result.exit != 0
+
+        lines = result.stdout.split("\n")
+        uptime = 0
+        lines.each do |l|
+          if /([\d.]*)\s+[\d.]*/.match(l)
+            uptime = Regexp.last_match[0].to_f.round
+          end
+        end
+        uptime
+      end
+
+      # Reboots the specified device
+      # @param serial serial number of device
+      # @return (nil) Nil if successful, otherwise an error is raised
+      def self.reboot(serial)
+        result = execute("adb -s #{serial} reboot")
+        raise ADBCommandError.new(result.stderr) if result.exit != 0
+      end
+
+      # Runs monkey testing
+      # @param serial serial number 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)
+
+        events = args[:events] || 10000
+        package = args[:package] or raise "package name not provided (:package => 'bbc.iplayer')"
+        seed = args[:seed]
+        throttle = args[:throttle]
+
+        cmd = "adb -s #{serial} shell monkey -p #{package} -v #{events}"
+        cmd = cmd + " -s #{seed}" if seed
+        cmd = cmd + " -t #{throttle}" if throttle
+
+        execute(cmd)
+      end
+      
+      # Take a screenshot from the device
+      # @param serial serial number 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 )
+        
+        filename = args[:filename] or raise "filename not provided (:filename => '/tmp/myfile.png')"
+        
+        convert_carriage_returns = %q{perl -pe 's/\x0D\x0A/\x0A/g'}
+        cmd = "adb -s #{serial} shell screencap -p | #{convert_carriage_returns} > #{filename}"
+        
+        execute(cmd)
+      end
+
+    end
+
+    # ADB Error class
+    class ADBCommandError < StandardError
+      def initialize(msg)
+        super(msg)
+      end
+    end
+
+
+  end
+end

data/lib/device_api/android/device.rb

@@ -0,0 +1,178 @@
+# Encoding: utf-8
+require 'device_api/device'
+require 'device_api/android/adb'
+require 'device_api/android/aapt'
+
+# DeviceAPI - an interface to allow for automation of devices
+module DeviceAPI
+  # Android component of DeviceAPI
+  module Android
+    # Device class used for containing the accessors of the physical device information
+    class Device < DeviceAPI::Device
+      def initialize(options = {})
+        @serial = options[:serial]
+        @state = options[:state]
+      end
+
+      # Mapping of device status - used to provide a consistent status across platforms
+      # @return (String) common status string
+      def status
+        {
+            'device' => :ok,
+            'no device' => :dead,
+            'offline' => :offline
+        }[@state]
+      end
+
+      # Return the device range
+      # @return (String) device range string
+      def range
+        device = self.device
+        model  = self.model
+
+        return device if device == model
+        "#{device}_#{model}"
+      end
+
+      # Return the device type
+      # @return (String) device type string
+      def device
+        get_prop('ro.product.device')
+      end
+
+      # Return the device model
+      # @return (String) device model string
+      def model
+        get_prop('ro.product.model')
+      end
+
+      # Return the device manufacturer
+      # @return (String) device manufacturer string
+      def manufacturer
+        get_prop('ro.product.manufacturer')
+      end
+
+      # Return the Android OS version
+      # @return (String) device Android version
+      def version
+        get_prop('ro.build.version.release')
+      end
+
+      # Return the device orientation
+      # @return (String) current device orientation
+      def orientation
+        res = get_dumpsys('SurfaceOrientation')
+
+        case res
+          when '0'
+            :portrait
+          when '1', '3'
+            :landscape
+          when nil
+            fail StandardError, 'No output returned is there a device connected?', caller
+          else
+            fail StandardError, "Device orientation not returned got: #{res}.", caller
+        end
+      end
+
+      # Install a specified apk
+      # @param [String] apk string containing path to the apk to install
+      # @return [Symbol, Exception] :success when the apk installed successfully, otherwise an error is raised
+      def install(apk)
+        fail StandardError, 'No apk specified.', caller if apk.empty?
+        res = install_apk(apk)
+
+        case res
+          when 'Success'
+            :success
+          else
+            fail StandardError, res, caller
+        end
+      end
+
+      # Uninstall a specified package
+      # @param [String] package_name name of the package to uninstall
+      # @return [Symbol, Exception] :success when the package is removed, otherwise an error is raised
+      def uninstall(package_name)
+        res = uninstall_apk(package_name)
+        case res
+          when 'Success'
+            :success
+          else
+            fail StandardError, "Unable to install 'package_name' Error Reported: #{res}", caller
+        end
+      end
+
+      # Return the package name for a specified apk
+      # @param [String] apk string containing path to the apk
+      # @return [String, Exception] package name if it can be found, otherwise an error is raised
+      def package_name(apk)
+        @apk = apk
+        result = get_app_props('package')['name']
+        fail StandardError, 'Package name not found', caller if result.nil?
+        result
+      end
+
+      # Return the app version number for a specified apk
+      # @param [String] apk string containing path to the apk
+      # @return [String, Exception] app version number if it can be found, otherwise an error is raised
+      def app_version_number(apk)
+        @apk = apk
+        result = get_app_props('package')['versionName']
+        fail StandardError, 'Version number not found', caller if result.nil?
+        result
+      end
+
+      # Initiate monkey tests
+      # @param [Hash] args arguments to pass on to ADB.monkey
+      def monkey(args)
+        ADB.monkey(serial, args)
+      end
+
+      # Capture screenshot on device
+      # @param [Hash] args arguments to pass on to ADB.screencap
+      def screenshot(args)
+        ADB.screencap(serial, args)
+      end
+
+      # Get the IMEI number of the device
+      # @return (String) IMEI number of current device
+      def imei
+        get_phoneinfo['Device ID']
+      end
+
+      private
+
+      def get_app_props(key)
+        unless @app_props
+          @app_props = AAPT.get_app_props(@apk)
+        end
+        @app_props.each { |x| break x[key] }
+      end
+
+      def get_prop(key)
+        if !@props || !@props[key]
+          @props = ADB.getprop(serial)
+        end
+        @props[key]
+      end
+
+      def get_dumpsys(key)
+        @props = ADB.getdumpsys(serial)
+        @props[key]
+      end
+
+      def get_phoneinfo
+        ADB.getphoneinfo(serial)
+      end
+
+      def install_apk(apk)
+        ADB.install_apk(apk: apk, serial: serial)
+      end
+
+      def uninstall_apk(package_name)
+        ADB.uninstall_apk(package_name: package_name, serial: serial)
+      end
+    end
+  end
+end

data/lib/device_api/android/signing.rb

@@ -0,0 +1,80 @@
+# DeviceAPI - an interface to allow for automation of devices
+module DeviceAPI
+  # Android component of DeviceAPI
+  module Android
+    # Namespace for all methods encapsulating adb calls
+    class Signing < Execution
+
+      # Creates a keystore used for signing apks
+      # @param [Hash] options options to pass through to keytool
+      # @option options [String] :keystore ('~/.android/debug.keystore') full path to location to create keystore
+      # @option options [String] :alias ('androiddebugkey') keystore alias name
+      # @option options [String] :dname ('CN=hive') keystore dname
+      # @option options [String] :password ('android') keystore password
+      # @return [Boolean, Exception] returns true if a keystore is created, otherwise an exception is raised
+      def self.generate_keystore(options = {})
+        keystore    = options[:keystore]  || '~/.android/debug.keystore'
+        alias_name  = options[:alias]     || 'androiddebugkey'
+        dname       = options[:dname]     || 'CN=hive'
+        password    = options[:password]  || 'android'
+
+        result = execute("keytool -genkey -noprompt -alias #{alias_name} -dname '#{dname}' -keystore #{keystore} -storepass #{password} -keypass #{password} -keyalg RSA -keysize 2048 -validity 10000")
+        raise SigningCommandError.new(result.stderr) if result.exit != 0
+        true
+      end
+
+      # Signs an apk using the specified keystore
+      # @param [Hash] options options to pass through to jarsigner
+      # @option options [String] :apk full path to the apk to sign
+      # @option options [String] :alias ('androiddebugkey') alias of the keystore
+      # @option options [String] :keystore ('~/.android/debug.keystore') full path to the location of the keystore
+      # @option options [String] :keystore_password ('android') password required to open the keystore
+      # @option options [Boolean] :resign if true then an already signed apk will be stripped of previous signing and resigned
+      # @return [Boolean, Exception] return true if the apk is signed, false if the apk is already signed and resigning is anything other than true
+      #   otherwise an exception is raised
+      def self.sign_apk(options = {})
+        apk               = options[:apk]
+        alias_name        = options[:alias]             || 'androiddebugkey'
+        keystore          = options[:keystore]          || '~/.android/debug.keystore'
+        keystore_password = options[:keystore_password] || 'android'
+        resign            = options[:resign]
+
+        # Check to see if the APK has already been signed
+        if is_apk_signed?(apk)
+          return false unless resign
+          unsign_apk(apk)
+        end
+        generate_keystore({ keystore: keystore, password: keystore_password, alias_name: alias_name }) unless File.exists?(File.expand_path(keystore))
+        result = execute("jarsigner -verbose -sigalg MD5withRSA -digestalg SHA1 -keystore #{File.expand_path(keystore)} -storepass #{keystore_password} #{apk} #{alias_name}")
+        raise SigningCommandError.new(result.stderr) if result.exit != 0
+        true
+      end
+
+      # Checks to see if an apk has already been signed
+      # @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$'")
+        return false if result.stdout.empty?
+        true
+      end
+
+      # Removes any previous signatures from an apk
+      # @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$'")
+        result = execute("aapt remove #{apk_path} #{file_list.stdout.split(/\s+/).join(' ')}")
+        raise SigningCommandError.new(result.stderr) if result.exit != 0
+        true
+       end
+    end
+
+    # Signing error class
+    class SigningCommandError < StandardError
+      def initialize(msg)
+        super(msg)
+      end
+    end
+  end
+end

data/spec/adb_spec.rb

@@ -0,0 +1,138 @@
+$LOAD_PATH.unshift('./lib/')
+
+require 'device_api'
+require 'device_api/android/adb'
+
+include RSpec
+
+#
+#
+# FIRST
+describe DeviceAPI::Android::ADB do
+  describe '.devices' do
+
+    it 'returns an empty array when there are no devices' do
+      out = <<eos
+List of devices attached
+
+
+eos
+      allow(Open3).to receive(:capture3) {
+        [out, '', $STATUS_ZERO]
+      }
+      expect(DeviceAPI::Android::ADB.devices).to eq([])
+    end
+
+    it "returns an array with a single item when there's one device attached" do
+      out = <<_______________________________________________________
+List of devices attached
+SH34RW905290	device
+
+_______________________________________________________
+      allow(Open3).to receive(:capture3) { [out, '', $STATUS_ZERO] }
+      expect(DeviceAPI::Android::ADB.devices).to eq([{ 'SH34RW905290' => 'device' }])
+    end
+
+    it 'returns an an array with multiple items when there are multiple items attached' do
+      out = <<_______________________________________________________
+List of devices attached
+SH34RW905290	device
+123456324	no device
+
+_______________________________________________________
+      allow(Open3).to receive(:capture3) { [out, '', $STATUS_ZERO] }
+      expect(DeviceAPI::Android::ADB.devices).to eq([{ 'SH34RW905290' => 'device' }, { '123456324' => 'no device' }])
+    end
+    
+    it 'can deal with extra output when adb starts up' do
+      out = <<_______________________________________________________
+* daemon not running. starting it now on port 5037 *
+* daemon started successfully *
+List of devices attached
+SH34RW905290	device
+_______________________________________________________
+      allow(Open3).to receive(:capture3) { [out, '', $STATUS_ZERO] }
+      expect(DeviceAPI::Android::ADB.devices).to eq([{ 'SH34RW905290' => 'device' }])
+    end
+
+    it 'can deal with no devices connected' do
+      allow(Open3).to receive(:capture3) { ["error: device not found\n", '', $STATUS_ZERO] }
+      expect(DeviceAPI::Android::ADB.devices).to be_empty
+    end
+  end
+
+  describe ".get_uptime" do
+    it "can process an uptime" do
+      out = <<_______________________________________________________
+12307.23 48052.0
+_______________________________________________________
+      allow(Open3).to receive(:capture3) { [ out, '', $STATUS_ZERO] }
+      expect( DeviceAPI::Android::ADB.get_uptime('SH34RW905290')).to eq( 12307 )
+    end
+  end
+  
+  describe ".getprop" do
+    
+    it "Returns a hash of name value pair properties" do
+      out = <<________________________________________________________
+[net.hostname]: [android-f1e4efe3286b0785]
+[dhcp.wlan0.ipaddress]: [10.0.1.34]
+[ro.build.version.release]: [4.1.2]
+[ro.build.version.sdk]: [16]
+[ro.product.bluetooth]: [4.0]
+[ro.product.device]: [m7]
+[ro.product.display_resolution]: [4.7 inch 1080p resolution]
+[ro.product.manufacturer]: [HTC]
+[ro.product.model]: [HTC One]
+[ro.product.name]: [m7]
+[ro.product.processor]: [Quadcore]
+[ro.product.ram]: [2GB]
+[ro.product.version]: [1.28.161.7]
+[ro.product.wifi]: [802.11 a/b/g/n/ac]
+[ro.revision]: [3]
+[ro.serialno]: [SH34RW905290]
+[ro.sf.lcd_density]: [480]
+________________________________________________________
+
+      allow(Open3).to receive(:capture3) { [out, '', $STATUS_ZERO] }
+
+      props = DeviceAPI::Android::ADB.getprop('SH34RW905290')
+
+      expect(props).to be_a Hash
+      expect(props['ro.product.model']).to eq('HTC One')
+    end
+  end
+  
+  describe ".get_status" do
+    
+    it "Returns a state for a single device" do
+      out = <<_______________________________________________________
+device
+_______________________________________________________
+      allow(Open3).to receive(:capture3) { [out, '', $STATUS_ZERO] }
+    
+      state = DeviceAPI::Android::ADB.get_state('SH34RW905290')
+    
+      expect(state).to eq 'device'
+    end
+  end
+  
+  describe ".monkey" do
+    
+    it "Constructs and executes monkey command line" do
+      out = <<_______________________________________________________
+** Monkey aborted due to error.
+Events injected: 3082
+:Sending rotation degree=0, persist=false
+:Dropped: keys=88 pointers=180 trackballs=0 flips=0 rotations=0
+## Network stats: elapsed time=14799ms (0ms mobile, 0ms wifi, 14799ms not connected)
+** System appears to have crashed at event 3082 of 5000000 using seed 1409644708681
+  end
+_______________________________________________________
+      allow(Open3).to receive(:capture3) { [out, '', $STATUS_ZERO] }
+ 
+      expect( DeviceAPI::Android::ADB.monkey( '1234323', :events => 5000, :package => 'my.app.package' )).to be_a OpenStruct
+    end
+  end
+
+end

data/spec/android_device_spec.rb

@@ -0,0 +1,49 @@
+require 'device_api/android'
+include RSpec
+
+describe DeviceAPI::Android do
+
+  describe '.devices' do
+
+    it 'Returns an empty array when no devices are connected' do
+      out = <<_______________________________________________________
+    List of devices attached
+
+_______________________________________________________
+      allow(Open3).to receive(:capture3) { [out, '', $STATUS_ZERO] }
+      expect(DeviceAPI::Android.devices).to eq([])
+    end
+
+    it "returns an array with a single item when there's one device attached" do
+      out = <<_______________________________________________________
+    List of devices attached
+    SH34RW905290	device
+
+_______________________________________________________
+      allow(Open3).to receive(:capture3) { [out, '', $STATUS_ZERO] }
+
+      devices = DeviceAPI::Android.devices
+
+      expect(devices.count).to eq(1)
+      expect(devices[0]).to be_a DeviceAPI::Android::Device
+      expect(devices[0].serial).to eq('SH34RW905290')
+      expect(devices[0].status).to eq(:ok)
+    end
+  end
+
+  describe ".device" do
+
+    it "Returns an object representing a device" do
+      out = <<_______________________________________________________
+    device
+_______________________________________________________
+      allow(Open3).to receive(:capture3) { [out, '', $STATUS_ZERO] }
+
+      device = DeviceAPI::Android.device('SH34RW905290')
+      expect(device).to be_a DeviceAPI::Android::Device
+      expect(device.serial).to eq('SH34RW905290')
+      expect(device.status).to eq(:ok)
+    end
+
+  end
+end

data/spec/android_spec.rb

@@ -0,0 +1,207 @@
+require 'device_api/android/device'
+include RSpec
+
+describe DeviceAPI::Android::Device do
+
+    describe '.model' do
+
+      it 'Returns model name' do
+        device = DeviceAPI::Android::Device.new(serial: 'SH34RW905290')
+
+        allow(Open3).to receive(:capture3) { ['[ro.product.model]: [HTC One]\n', '', $STATUS_ZERO] }
+        expect(device.model).to eq('HTC One')
+      end
+
+    end
+
+    describe '.orientation' do
+      it 'Returns portrait when device is portrait' do
+        device = DeviceAPI::Android::Device.new(serial: 'SH34RW905290')
+        allow(Open3).to receive(:capture3) { ["SurfaceOrientation: 0\r\n", '', $STATUS_ZERO] }
+
+        expect(device.orientation).
+            to eq(:portrait)
+      end
+
+      it 'Returns landscape when device is landscape' do
+        device = DeviceAPI::Android::Device.new(serial: 'SH34RW905290')
+        allow(Open3).to receive(:capture3) { ["SurfaceOrientation: 1\r\n", '', $STATUS_ZERO] }
+
+        expect(device.orientation).
+            to eq(:landscape)
+      end
+
+      it 'Returns landscape when device is landscape for a kindle Fire' do
+        device = DeviceAPI::Android::Device.new(serial: 'SH34RW905290')
+        allow(Open3).to receive(:capture3) { ["SurfaceOrientation: 3\r\n", '', $STATUS_ZERO] }
+
+        expect(device.orientation).
+            to eq(:landscape)
+      end
+
+      it 'Returns an error if response not understood' do
+        device = DeviceAPI::Android::Device.new(serial: 'SH34RW905290')
+
+        allow(Open3).to receive(:capture3) { ["SurfaceOrientation: 564654654\n", '', $STATUS_ZERO] }
+
+        expect { device.orientation }.
+          to raise_error(StandardError, 'Device orientation not returned got: 564654654.')
+      end
+
+      it 'Returns an error if no device found' do
+        device = DeviceAPI::Android::Device.new(serial: 'SH34RW905290')
+
+        allow(Open3).to receive(:capture3) { ["error: device not found\n", '', $STATUS_ZERO] }
+
+        expect { device.orientation }.
+            to raise_error(StandardError, 'No output returned is there a device connected?')
+      end
+
+      it 'Can handle device orientation changes during a test' do
+        device = DeviceAPI::Android::Device.new(serial: 'SH34RW905290')
+        landscape = "SurfaceOrientation: 1\r\n"
+        portrait = "SurfaceOrientation: 0\r\n"
+
+        allow(Open3).to receive(:capture3) { [portrait, '', $STATUS_ZERO] }
+        expect(device.orientation).
+            to eq(:portrait)
+        allow(Open3).to receive(:capture3) { [landscape, '', $STATUS_ZERO] }
+        expect(device.orientation).
+            to eq(:landscape)
+      end
+
+      it 'Can filter on large amounts of adb output to find the correct value', type: 'adb' do
+        out = <<_______________________________________________________
+uchMajor: min=0, max=15, flat=0, fuzz=0, resolution=0\r\n        TouchMinor: unknown range\r\n
+ToolMajor: unknown range\r\n        ToolMinor: unknown range\r\n        Orientation: unknown range\r\n
+Distance: unknown range\r\n        TiltX: unknown range\r\n        TiltY: unknown range\r\n
+TrackingId: min=0, max=65535, flat=0, fuzz=0, resolution=0\r\n        Slot: min=0, max=9, flat=0, fuzz=0,
+resolution=0\r\n      Calibration:\r\n        touch.size.calibration: diameter\r\n
+touch.size.scale: 22.500\r\n        touch.size.bias: 0.000\r\n        touch.size.isSummed: false\r\n
+touch.pressure.calibration: amplitude\r\n        touch.pressure.scale: 0.013\r\n        touch.orientation.calibration: none\r\n
+ touch.distance.calibration: none\r\n        touch.coverage.calibration: none\r\n      Viewport: displayId=0, orientation=0,
+logicalFrame=[0, 0, 768, 1280], physicalFrame=[0, 0, 768, 1280], deviceSize=[768, 1280]\r\n      SurfaceWidth: 768px\r\n
+ SurfaceHeight: 1280px\r\n      SurfaceLeft: 0\r\n      SurfaceTop: 0\r\n      SurfaceOrientation: 0\r\n
+ Translation and Scaling Factors:\r\n        XTranslate: 0.000\r\n        YTranslate: 0.000\r\n        XScale: 0.500\r\n
+     YScale: 0.500\r\n        XPrecision: 2.000\r\n        YPrecision: 2.000\r\n
+_______________________________________________________
+        device = DeviceAPI::Android::Device.new(serial: 'SH34RW905290')
+        allow(Open3).to receive(:capture3) { [out, '', $STATUS_ZERO] }
+
+        expect(device.orientation).
+            to eq(:portrait)
+
+      end
+
+    end
+
+    describe '.install' do
+
+      it 'Can install an apk' do
+        out = <<_______________________________________________________
+      4458 KB/s (9967857 bytes in 2.183s)
+      pkg: /data/local/tmp/bbciplayer-debug.apk
+      Success
+_______________________________________________________
+
+        device = DeviceAPI::Android::Device.new(serial: 'SH34RW905290')
+        allow(Open3).to receive(:capture3) { [out, '', $STATUS_ZERO] }
+        expect(device.install('some_apk.spk')).
+            to eq(:success)
+      end
+
+      it 'Can display an error when the apk is not found' do
+        out = "can't find 'fake.apk' to install"
+
+        device = DeviceAPI::Android::Device.new(serial: 'SH34RW905290')
+        allow(Open3).to receive(:capture3) { [out, '', $STATUS_ZERO] }
+        expect { device.install('fake.apk') }.
+            to raise_error(StandardError, "can't find 'fake.apk' to install")
+      end
+
+      it 'Can display an error message when no apk is specified' do
+        out = 'No apk specified.'
+
+        device = DeviceAPI::Android::Device.new(serial: 'SH34RW905290')
+        allow(Open3).to receive(:capture3) { [out, '', $STATUS_ZERO] }
+        expect { device.install('fake.apk') }.
+            to raise_error(StandardError, 'No apk specified.')
+      end
+
+      it 'Can display an error when the apk is already installed' do
+        out = 'Failure [INSTALL_FAILED_ALREADY_EXISTS]'
+
+        device = DeviceAPI::Android::Device.new(serial: 'SH34RW905290')
+        allow(Open3).to receive(:capture3) { [out, '', $STATUS_ZERO] }
+        expect { device.install('fake.apk') }.
+            to raise_error(StandardError, 'Failure [INSTALL_FAILED_ALREADY_EXISTS]')
+      end
+
+      describe '.uninstall' do
+
+        it 'Can uninstall an apk' do
+          out = 'Success'
+
+          device = DeviceAPI::Android::Device.new(serial: 'SH34RW905290')
+          allow(Open3).to receive(:capture3) { [out, '', $STATUS_ZERO] }
+          expect(device.uninstall('pack_name')).
+              to eq(:success)
+        end
+
+        it 'Can raise an error if the uninstall was unsuccessful' do
+          out = 'Failure'
+
+          device = DeviceAPI::Android::Device.new(serial: 'SH34RW905290')
+          allow(Open3).to receive(:capture3) { [out, '', $STATUS_ZERO] }
+          expect { device.uninstall('pack_name') }.
+              to raise_error(StandardError, "Unable to install 'package_name' Error Reported: Failure")
+        end
+
+      end
+
+      describe '.package_name' do
+        out = "package: name='bbc.iplayer.android' versionCode='4200066' versionName='4.2.0.66'"
+
+        it 'Can get the package name from an apk' do
+
+          device = DeviceAPI::Android::Device.new(serial: 'SH34RW905290')
+          allow(Open3).to receive(:capture3) { [out, '', $STATUS_ZERO] }
+          expect(device.package_name('iplayer.apk')).
+            to eq('bbc.iplayer.android')
+        end
+
+        it 'Can get the version number from an apk' do
+          device = DeviceAPI::Android::Device.new(serial: 'SH34RW905290')
+          allow(Open3).to receive(:capture3) { [out, '', $STATUS_ZERO] }
+          expect(device.app_version_number('iplayer.apk')).
+              to eq('4.2.0.66')
+        end
+
+        it 'can raise an error if the app package name is not found' do
+          out = "package: versionCode='4200066' versionName='4.2.0.66'"
+
+          device = DeviceAPI::Android::Device.new(serial: 'SH34RW905290')
+          allow(Open3).to receive(:capture3) { [out, '', $STATUS_ZERO] }
+          expect { device.package_name('iplayer.apk') }.
+              to raise_error(StandardError, 'Package name not found')
+        end
+
+        it 'can raise an error if the app version number is not found' do
+          out = "package: name='bbc.iplayer.android' yyyyy='xxxxxxxx' qqqqq='rrrrrrrr'"
+
+          device = DeviceAPI::Android::Device.new(serial: 'SH34RW905290')
+          allow(Open3).to receive(:capture3) { [out, '', $STATUS_ZERO] }
+          expect { device.app_version_number('iplayer.apk') }.
+              to raise_error(StandardError, 'Version number not found')
+        end
+
+        it 'can raise an error if aapt can not be found' do
+          device = DeviceAPI::Android::Device.new(serial: 'SH34RW905290')
+          allow(Open3).to receive(:capture3) { ['', '', $STATUS_ONE] }
+          expect { device.app_version_number('iplayer.apk') }.
+              to raise_error(StandardError, 'aapt not found - please create a symlink in $ANDROID_HOME/tools')
+        end
+
+      end
+    end
+  end

data/spec/helpers/stub_helper_spec.rb

@@ -0,0 +1,4 @@
+ProcessStatusStub = Struct.new(:exitstatus)
+$STATUS_ZERO = ProcessStatusStub.new(0)
+$STATUS_ONE = ProcessStatusStub.new(1)
+

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: device_api-android
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- BBC
+- David Buckhurst
+- Jitesh Gosai
+- Jon Wilson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: device_api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Android implementation of DeviceAPI
+email: david.buckhurst@bbc.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- 51-android.rules
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- device_api-android.gemspec
+- lib/device_api/android.rb
+- 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/signing.rb
+- spec/adb_spec.rb
+- spec/android_device_spec.rb
+- spec/android_spec.rb
+- spec/helpers/stub_helper_spec.rb
+homepage: https://github.com/bbc/device_api-android
+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.4.5
+signing_key: 
+specification_version: 4
+summary: Android Device Management API
+test_files: []
+has_rdoc: