mobo 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 769b5307fcef24c8fd89ae3812977029429d9aa3
+  data.tar.gz: 03bb960b0e2aa5bec20a8d9605d0dece15504896
+SHA512:
+  metadata.gz: 17af1fe2a87d0929d89cdc1d4b8762939a32300845fb0099279d7d638fd4047f3b9cbf2e8c1e11a11f240a67b02e08dd042f110dda9aa8a524b45f1c14ca4348
+  data.tar.gz: 7e8831e69051b35a96797f5b31817a35ddc3eea5358cca8ac10e3afd7e2cd7deb4c20c2ef0dcf2d95ed785e0efaf05158ba4a532d69ba4859f8e7817dfdd4db2

data/bin/mobo

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+require_relative '../lib/mobo'
+
+MOBO_DEVICES_FILE = Dir.pwd + '/devices.yaml'
+MOBO_DEVICES_CACHE_FILE = Dir.pwd + '/.mobo-devices.yaml'
+
+case ARGV[0]
+when "up"
+  Mobo.up(MOBO_DEVICES_FILE)
+when "status"
+  Mobo.status(MOBO_DEVICES_CACHE_FILE)
+when "destroy"
+  Mobo.destroy(MOBO_DEVICES_CACHE_FILE)
+end

data/lib/mobo/android.rb

@@ -0,0 +1,247 @@
+module Mobo
+
+  module Android
+
+    class << self
+      def exists?
+        add_to_path
+        Mobo.cmd("which android")
+      end
+
+      def install
+         Mobo.cmd("curl -O http://dl.google.com/android/android-sdk_r24.3.4-linux.tgz")
+         Mobo.cmd("sudo tar -xf android-sdk_r24.3.4-linux.tgz -C /usr/local/")
+         Mobo.cmd("sudo chown -R $(whoami) /usr/local/android-sdk-linux")
+         add_to_path
+      end
+ 
+      # setting env variables in the bash profile and trying to reload them isn't easy,
+      # as the variables are only set in the sub process the bash_profile is executed in
+      # so we can set env variables, which take effect here, and also set them in bash_profile
+      # for the user to use later on
+      def add_to_path
+        android_home = "/usr/local/android-sdk-linux"
+        
+        if !ENV['PATH'].match(/#{android_home}/)
+          ENV['ANDROID_HOME'] = android_home
+          ENV['PATH'] += ":#{ENV['ANDROID_HOME']}/tools"
+          Mobo.cmd("echo \"export ANDROID_HOME=#{ENV['ANDROID_HOME']}\" >> ~/.bash_profile")
+          Mobo.cmd("echo \"export PATH=#{ENV['PATH']}\" >> ~/.bash_profile")
+          Mobo.log.info("ANDROID_HOME and PATH env variables have been updated. 
+            Start a new terminal session for them to take effect")
+          raise "Setting ANDROID_HOME and PATH failed" unless self.exists?
+        end
+      end
+
+      def package_exists?(package)
+        Mobo.cmd("android list sdk --extended --no-ui --all | grep '\"#{package}\"'")
+      end
+
+      def install_package(package)
+        Mobo.cmd("echo y | android update sdk --no-ui --all --filter #{package} 2>&1 >> /dev/null")
+      end
+    end
+
+    module Targets
+      class << self
+        def exists?(target)
+          Mobo.cmd("android list targets --compact | grep #{target}")
+        end
+
+        def target_details(target)
+          output = Mobo.cmd_out("android list targets")
+          records = output.split('----------')
+          records.each do |record|
+            return record if record.match(/#{target}/)
+          end
+        end
+
+        def abi_package(target, abi)
+          prepend = "sys-img"
+          "#{prepend}-#{abi}-#{target}"
+        end
+
+        def has_abi?(target, abi)
+          target_details(target).match(/#{abi}/)
+        end
+
+        def has_skin?(target, skin)
+          target_details(target).match(/#{skin}/)
+        end
+      end
+    end
+
+    module Avd
+      class << self
+        def create(device)
+          SystemCheck.target_exists(device["target"])
+          SystemCheck.abi_exists?(device["target"], device["abi"])
+          SystemCheck.skin_exists?(device["target"], device["skin"])
+          emulator_cmd =
+            "echo no | android create avd \
+            --name #{device["name"]} \
+            --target #{device["target"]} \
+            --abi #{device["abi"]} \
+            --force"
+          emulator_cmd += " --skin #{device["skin"]}" if device["skin"]
+          Mobo.cmd(emulator_cmd)
+
+          raise "Error creating AVD" unless $?.success?
+        end
+      end
+    end
+
+    class Adb
+      class << self
+
+        def add_to_path
+          if !ENV['PATH'].match(/platform-tools/)
+            ENV['PATH'] += ":#{ENV['ANDROID_HOME']}/platform-tools"
+            Mobo.cmd("echo \"export PATH=#{ENV['PATH']}\" >> ~/.bash_profile")
+            Mobo.log.debug("ENV['PATH'] set to #{ENV['PATH']}")
+            Mobo.log.info("PATH env variables has been updated. 
+            Start a new terminal session for it to take effect")
+          end
+        end
+
+        def exists?
+          add_to_path
+          Mobo.cmd("which adb")
+        end
+
+        def install
+          Mobo.cmd("echo yes | android update sdk --all --no-ui --filter platform-tools 2>&1 >> /dev/null")
+          add_to_path  
+          raise "Installing adb failed" unless self.exists?
+        end
+      end
+    end
+
+    class Emulator
+      PORT_START = 5600
+      BOOT_SLEEP = 5
+      BOOT_WAIT_ATTEMPTS = 30
+      UNLOCK_KEY_EVENT = 82
+      BACK_KEY_EVENT = 4
+
+      class << self
+        attr_accessor :last_port
+      end
+
+      def initialize(device)
+        @device = device
+      end
+
+      def find_open_port
+        port = (Emulator.last_port || PORT_START) + 2
+        until not Mobo.cmd("netstat -an | grep 127.0.0.1.#{port}")
+          port += 2
+        end
+        Emulator.last_port = port
+        @device["port"] = port
+      end
+
+      def create_sdcard
+        @device["sdcard"] = "#{@device["name"]}_sdcard.img"
+        Mobo.cmd("mksdcard -l e #{@device["sdcard_size"]} #{@device["sdcard"]}")
+      end
+
+      def destroy_sdcard
+        Mobo.cmd("rm -f #{@device["sdcard"]}")
+      end
+
+      def create_cache
+        @device["cache"] = @device["name"] + "_cache.img"
+      end
+
+      def destroy_cache
+        Mobo.cmd("rm -f #{@device["cache"]}")
+      end
+
+      def start
+        find_open_port
+        create_sdcard
+        create_cache
+
+        cmd ="emulator @#{@device["name"]} \
+          -port #{@device["port"]} \
+          -sdcard #{@device["sdcard"]} \
+          -cache #{@device["cache"]}"
+        pid = Process.fork {
+          Mobo.cmd(cmd)
+          Mobo.log.info("Emulator #{@device["name"]} has stopped")
+        }
+
+        @device["pid"] = pid
+        @device["id"] = "emulator-#{@device["port"]}"
+        return @device
+      end
+
+      def unlock_when_booted
+        Process.fork do
+          BOOT_WAIT_ATTEMPTS.times do |attempt|
+            if booted?
+              Mobo.log.info("#{@device["id"]} has booted")
+              break
+            elsif !running?
+              Mobo.log.error("Emulator #{@device["name"]} has stopped")
+              break
+            else
+              Mobo.log.debug("waiting for #{@device["id"]} to boot...")
+              sleep(BOOT_SLEEP)
+            end
+          end
+
+          if running? && booted?
+            unlock
+          end
+        end
+      end
+
+      def running?
+        begin
+          Process.getpgid( @device["pid"] )
+          true
+        rescue Errno::ESRCH
+          false
+        end
+      end
+
+      def booted?
+        bootanim = Mobo.cmd_out("adb -s #{@device["id"]} shell 'getprop init.svc.bootanim'")
+        if bootanim.match(/stopped/)
+          return true
+        else
+          return false
+        end
+      end
+
+      def unlock
+        # unlock the emulator, so it can be used for UI testing
+        # then, pressing back because sometimes a menu appears
+        [UNLOCK_KEY_EVENT, BACK_KEY_EVENT].each do |key|
+          sleep(BOOT_SLEEP)
+          Mobo.cmd("adb -s #{@device["id"]} shell input keyevent #{key}")
+        end
+      end
+
+      def status
+        Mobo.log.info("#{@device["name"]} (#{@device["id"]}) is running: #{booted?}")
+      end
+
+      def destroy
+        (0..10).each do 
+          if booted?
+            Mobo.cmd("adb -s #{@device["id"]} emu kill")
+            sleep 1
+          else
+            Mobo.log.info("#{@device["name"]} (#{@device["id"]}) is shutdown")
+            destroy_cache
+            destroy_sdcard
+            break
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mobo/system_check.rb

@@ -0,0 +1,41 @@
+module Mobo
+  module SystemCheck
+    class << self
+      def bash_check(cmd, msg, error)
+        system(cmd)
+        Mobo.log.info("#{msg} : #{$?}")
+        raise error unless $?.success?
+      end
+
+      def android
+        Android.exists?
+      end
+
+      def target_exists(target)
+        unless Android::Targets.exists?(target)
+          SystemSetup.install_target(target)
+        end
+      end
+
+      def abi_exists?(target, abi)
+        unless Android::Targets.has_abi?(target, abi)
+          SystemSetup.install_abi(target, abi)
+        end
+      end
+
+      def skin_exists?(target, abi)
+        Android::Targets.has_skin?(target, abi)
+      end
+
+      def adb
+        unless Android::Adb.exists?
+          SystemSetup.install_adb
+        end
+      end
+
+      def device_file_exists?(filename)
+        File.exists?(filename)
+      end
+    end
+  end
+end

data/lib/mobo/system_setup.rb

@@ -0,0 +1,32 @@
+module Mobo
+  module SystemSetup
+    class << self
+
+      def base_libraries
+        #if ubuntu
+        if(Mobo.cmd("which apt-get"))
+          Mobo.cmd("sudo apt-get install -y libc6-i386 lib32stdc++6 lib32gcc1 lib32ncurses5 lib32z1")
+        end
+      end
+
+      def install_android
+        Android.install
+      end
+
+      def install_target(target)
+        Android.install_package(target) if Android.package_exists?(target)
+        raise "Cannot install target: #{target}" unless $?.success?
+      end
+
+      def install_abi(target, abi)
+        package_name = Android::Targets.abi_package(target, abi)
+        Android.install_package(package_name) if Android.package_exists?(package_name)
+        raise "Cannot install abi: #{abi} for #{target}" unless $?.success?
+      end
+
+      def install_adb
+        Android::Adb.install unless Android::Adb.exists?
+      end
+    end
+  end
+end

data/lib/mobo.rb

@@ -0,0 +1,105 @@
+#!/usr/bin/env ruby
+require 'yaml'
+require 'pp'
+require 'logger'
+require_relative 'mobo/android'
+require_relative 'mobo/system_check'
+require_relative 'mobo/system_setup'
+
+module Mobo
+  class << self
+    attr_accessor :log, :data, :devices
+
+    def log
+      @log || @log = Logger.new(STDOUT)
+    end
+
+    def cmd(command)
+      log.debug(command)
+      system(command)
+    end
+
+    def cmd_out(command)
+      log.debug(command)
+      `#{command}`
+    end
+
+    def start_process(cmd)
+      pid = Process.spawn(cmd)
+      Process.detach(pid)
+      pid
+    end
+
+    def ask_user(msg, &block)
+      puts msg
+      ans = STDIN.gets.chomp
+      if ans.match(/yes|y|Y/)
+        yield
+      end
+    end
+
+    def devices
+      @devices = @devices.nil? ? {} : @devices
+    end
+
+    def device_config(device)
+      defaults = {
+        "name"        => "default",
+        "target"      => "android-22",
+        "abi"         => "x86_64",
+        "height"      => "1200",
+        "width"       => "720",
+        "sdcard_size" => "20M" }
+      device = defaults.merge(device)
+    end
+
+    def load_data(filename)
+      raise "Cannot file #{filename}" unless SystemCheck.device_file_exists?(filename)
+      Mobo.data = YAML::load_file(filename)
+    end
+
+    def system_checks
+      SystemSetup.base_libraries
+      SystemCheck.android
+      SystemCheck.adb
+    end
+
+    def up(filename)
+      system_checks
+      load_data(filename)
+      # retrive settings for one of each device
+      Mobo.data["devices"].each do |device|
+        device = device_config(device)
+        Mobo.devices[device["name"]] = device
+      end
+
+      # build and boot devices
+      Mobo.devices.each_pair do |name, device|
+        Mobo::Android::Avd.create(device)
+        emulator = Android::Emulator.new(device)
+        emulator.start
+        emulator.unlock_when_booted
+      end
+      File.open(MOBO_DEVICES_CACHE_FILE, "w") do |file|
+        file.write Mobo.devices.to_yaml
+      end
+      Process.waitall
+    end
+
+    def status(filename)
+      load_data(filename)
+      Mobo.data.each_pair do |name, device|
+        Mobo::Android::Emulator.new(device).status
+      end
+    end
+
+    def destroy(filename)
+      load_data(filename)
+      Mobo.data.each_pair do |name, device|
+        Mobo::Android::Emulator.new(device).destroy
+      end
+    end
+
+  end
+
+end

data/mobo.rb

@@ -0,0 +1,80 @@
+#!/usr/bin/env ruby
+require 'yaml'
+require 'pp'
+require 'logger'
+require_relative 'lib/mobo/android'
+require_relative 'lib/mobo/system_check'
+
+module Mobo
+  class << self
+    attr_accessor :log, :data, :devices
+
+    def log
+      @log || @log = Logger.new(STDOUT)
+    end
+
+    def cmd(command)
+      log.debug(command)
+      system(command)
+    end
+
+    def cmd_out(command)
+      log.debug(command)
+      `#{command}`
+    end
+
+    def start_process(cmd)
+      pid = Process.spawn(cmd)
+        Process.detach(pid)
+        pid
+      end
+
+    def devices
+      @devices = @devices.nil? ? {} : @devices
+    end
+
+    def device_config(device)
+      defaults = {
+        "name"        => "default",
+        "target"      => "android-22",
+        "abi"         => "default/x86_64",
+        "height"      => "1200",
+        "width"       => "720",
+        "sdcard_size" => "20M" }
+      defaults.merge(device)
+    end
+
+    def up
+      # retrive settings for one of each device
+      Mobo.data["devices"].each do |device|
+        device = device_config(device)
+        Mobo.devices[device["name"]] = device
+      end
+
+      # build and boot devices
+      Mobo.devices.each_pair do |name, device|
+        Mobo::Android::Avd.create(device)
+        emulator = Android::Emulator.new(device)
+        emulator.start
+        emulator.unlock_when_booted
+      end
+      File.open(MOBO_DEVICES_FILE, "w") do |file|
+        file.write Mobo.devices.to_yaml
+      end
+    end
+
+    def status
+      Mobo.data.each_pair do |name, device|
+        Mobo::Android::Emulator.new(device).status
+      end
+    end
+
+    def destroy
+      Mobo.data.each_pair do |name, device|
+        Mobo::Android::Emulator.new(device).destroy
+      end
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: mobo
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Mark O'Shea
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-05 00:00:00.000000000 Z
+dependencies: []
+description: Abstract android emaulators with a simple yaml file
+email: mark@osheatech.com
+executables:
+- mobo
+extensions: []
+extra_rdoc_files: []
+files:
+- mobo.rb
+- lib/mobo/android.rb
+- lib/mobo/system_check.rb
+- lib/mobo/system_setup.rb
+- lib/mobo.rb
+- bin/mobo
+homepage: https://github.com/moshea/mobo
+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.0.3
+signing_key: 
+specification_version: 4
+summary: Mobo - android emulator abstraction
+test_files: []