ruboto 0.5.4 → 0.6.0

data/Gemfile.lock

@@ -2,15 +2,15 @@ GEM
   remote: http://rubygems.org/
   specs:
     arrayfields (4.7.4)
-    chronic (0.6.6)
-    fattr (2.2.0)
-    jruby-jars (1.6.5.1)
-    main (4.8.1)
-      arrayfields (~> 4.7.4)
-      chronic (~> 0.6.2)
-      fattr (~> 2.2.0)
-      map (~> 5.1.0)
-    map (5.1.0)
+    chronic (0.6.7)
+    fattr (2.2.1)
+    jruby-jars (1.6.7)
+    main (5.0.1)
+      arrayfields (>= 4.7.4)
+      chronic (>= 0.6.2)
+      fattr (>= 2.2.0)
+      map (>= 5.1.0)
+    map (5.5.0)
     rake (0.9.2.2)
 
 PLATFORMS

data/README.md

@@ -57,6 +57,8 @@ Ex:
 
 Can subclass any part of the Android API to pass control over to a script when the specified methods are called. You can also create classes that implement a single Android interface to pass control over to ruboto.
 
+_Note: While the command line calls below still work, there is an easier way to do this within your scripts. The new way of generating interfaces and subclasses is described in the wiki [Generating classes for callbacks](https://github.com/ruboto/ruboto/wiki/Generating-classes-for-callbacks)._
+
 For classes that need subclassing (e.g., PhoneStateListener, SQLiteOpenHelper, View)
 
     $ ruboto gen subclass AndroidPackageAndClassName --name YourClassName --method_base all-on-or-none --method_include methods --method_exclude methods

data/Rakefile

@@ -1,15 +1,21 @@
+$:.unshift('lib') unless $:.include?('lib')
 require 'rake/clean'
 require 'rexml/document'
-require 'lib/ruboto/version'
+require 'ruboto/version'
+require 'ruboto/sdk_versions'
+require 'uri'
+require 'net/http'
 
 PLATFORM_PROJECT = File.expand_path('tmp/RubotoCore', File.dirname(__FILE__))
 PLATFORM_DEBUG_APK = "#{PLATFORM_PROJECT}/bin/RubotoCore-debug.apk"
 PLATFORM_RELEASE_APK = "#{PLATFORM_PROJECT}/bin/RubotoCore-release.apk"
+PLATFORM_CURRENT_RELEASE_APK = "#{PLATFORM_PROJECT}/bin/RubotoCore-release.apk.current"
 MANIFEST_FILE = "AndroidManifest.xml"
 GEM_FILE = "ruboto-#{Ruboto::VERSION}.gem"
 GEM_FILE_OLD = "ruboto-core-#{Ruboto::VERSION}.gem"
 GEM_SPEC_FILE = 'ruboto.gemspec'
 GEM_SPEC_FILE_OLD = 'ruboto-core.gemspec'
+EXAMPLE_FILE = File.expand_path("examples/RubotoTestApp_#{Ruboto::VERSION}_tools_r#{Ruboto::SdkVersions::ANDROID_TOOLS_REVISION}.tgz", File.dirname(__FILE__))
 
 CLEAN.include('ruboto-*.gem', 'tmp')
 
@@ -28,15 +34,46 @@ file GEM_FILE_OLD => GEM_SPEC_FILE_OLD do
   `gem build #{GEM_SPEC_FILE_OLD}`
 end
 
+task :install => :gem do
+  `gem query -i -n ^ruboto$ -v #{Ruboto::VERSION}`
+  if $? != 0
+    cmd = "gem install ruboto-#{Ruboto::VERSION}.gem"
+    output = `#{cmd}`
+    if $? == 0
+      puts output
+    else
+      sh "sudo #{cmd}"
+    end
+  end
+end
+
+desc "Generate an example app"
+task :example => EXAMPLE_FILE
+
+file EXAMPLE_FILE => :install do
+  puts "Creating example app #{EXAMPLE_FILE}"
+  app_name = 'RubotoTestApp'
+  Dir.chdir File.dirname(EXAMPLE_FILE) do
+    FileUtils.rm_rf app_name
+    sh "ruboto gen app --package org.ruboto.test_app --name #{app_name} --path #{app_name}"
+    sh "tar czf #{EXAMPLE_FILE} #{app_name}"
+    FileUtils.rm_rf app_name
+  end
+end
+
 desc "Push the gem to RubyGems"
-task :release => :gem do
+task :release => [:clean, :gem] do
   output = `git status --porcelain`
   raise "Workspace not clean!\n#{output}" unless output.empty?
   sh "git tag #{Ruboto::VERSION}"
   sh "git push --tags"
   sh "gem push #{GEM_FILE}"
   sh "gem push #{GEM_FILE_OLD}"
-  
+
+  Rake::Task[:example].invoke
+  sh "git add #{EXAMPLE_FILE}"
+  sh "git commit -m '* Added example app for Ruboto #{Ruboto::VERSION} tools r#{Ruboto::SdkVersions::ANDROID_TOOLS_REVISION}' #{EXAMPLE_FILE}"
+  sh "git push"
 end
 
 desc "Run the tests"
@@ -57,22 +94,33 @@ namespace :platform do
   task :project => PLATFORM_PROJECT
 
   file PLATFORM_PROJECT do
-    sh "ruby -rubygems -I#{File.expand_path('lib', File.dirname(__FILE__))} bin/ruboto gen app --package org.ruboto.core --name RubotoCore --with-jruby --path #{PLATFORM_PROJECT}"
+    sh "ruby -rubygems -I#{File.expand_path('lib', File.dirname(__FILE__))} bin/ruboto gen app --package org.ruboto.core --name RubotoCore --with-jruby --path #{PLATFORM_PROJECT} --min-sdk #{Ruboto::SdkVersions::MINIMUM_SUPPORTED_SDK} --target #{Ruboto::SdkVersions::DEFAULT_TARGET_SDK}"
     Dir.chdir(PLATFORM_PROJECT) do
       manifest = REXML::Document.new(File.read(MANIFEST_FILE))
       manifest.root.attributes['android:versionCode'] = '408'
-      manifest.root.attributes['android:versionName'] = '0.4.8'
+      manifest.root.attributes['android:versionName'] = '0.4.8.dev'
       manifest.root.attributes['android:installLocation'] = 'auto' # or 'preferExternal' ?
-      manifest.root.elements['uses-sdk'].attributes['android:targetSdkVersion'] = '8'
       File.open(MANIFEST_FILE, 'w') { |f| manifest.document.write(f, 4) }
-      File.open('project.properties', 'w'){|f| f << "target=android-8\n"}
       File.open('Gemfile.apk', 'w'){|f| f << "source :rubygems\n\ngem 'activerecord-jdbc-adapter'\n"}
+
+      # FIXME(uwe):  Add this when either jruby-openssl is simplified or most devices are Android 4
+      # FIXME(uwe):  Reeference: #154 and http://code.google.com/p/android/issues/detail?id=22586
+      # File.open('Gemfile.apk', 'w'){|f| f << "gem 'jruby-openssl'\n"}
+      # FIXME end
+
       File.open('ant.properties', 'a'){|f| f << "key.store=${user.home}/ruboto_core.keystore\nkey.alias=Ruboto\n"}
     end
   end
 
+  desc 'Generate a Ruboto Core platform debug apk'
+  task :debug => PLATFORM_DEBUG_APK
+
   file PLATFORM_DEBUG_APK => PLATFORM_PROJECT do
     Dir.chdir(PLATFORM_PROJECT) do
+      if File.exists?(PLATFORM_CURRENT_RELEASE_APK) && File.exists?(PLATFORM_DEBUG_APK) &&
+          File.size(PLATFORM_CURRENT_RELEASE_APK) == File.size(PLATFORM_DEBUG_APK)
+        sh 'rake uninstall'
+      end
       sh 'rake debug'
     end
   end
@@ -86,6 +134,22 @@ namespace :platform do
     end
   end
 
+  desc 'Download the current RubotoCore platform release apk'
+  task :current => :debug do
+    Dir.chdir PLATFORM_PROJECT do
+      if !File.exists?(PLATFORM_CURRENT_RELEASE_APK)
+        puts 'Downloading the current RubotoCore platform release apk'
+        url = 'http://cloud.github.com/downloads/ruboto/ruboto/RubotoCore-release.apk'
+        File.open(PLATFORM_CURRENT_RELEASE_APK, 'w') { |f| f << Net::HTTP.get(URI.parse url) }
+      end
+
+      if File.size(PLATFORM_CURRENT_RELEASE_APK) != File.size(PLATFORM_DEBUG_APK)
+        FileUtils.cp PLATFORM_CURRENT_RELEASE_APK, PLATFORM_DEBUG_APK
+        sh 'rake uninstall'
+      end
+    end
+  end
+
   desc 'Install the Ruboto Core platform debug apk'
   task :install => PLATFORM_DEBUG_APK do
     Dir.chdir(PLATFORM_PROJECT) do

data/assets/Rakefile

@@ -1,407 +1,2 @@
-if `ant -version` !~ /version (\d+)\.(\d+)\.(\d+)/ || $1.to_i < 1 || ($1.to_i == 1 && $2.to_i < 8)
-  puts "ANT version 1.8.0 or later required.  Version found: #{$1}.#{$2}.#{$3}"
-  exit 1
-end
-
-require 'time'
-
-def manifest() @manifest ||= REXML::Document.new(File.read(MANIFEST_FILE)) end
-def package() manifest.root.attribute('package') end
-def build_project_name() @build_project_name ||= REXML::Document.new(File.read('build.xml')).elements['project'].attribute(:name).value end
-def scripts_path() @sdcard_path ||= "/mnt/sdcard/Android/data/#{package}/files/scripts" end
-def app_files_path() @app_files_path ||= "/data/data/#{package}/files" end
-
-require 'rake/clean'
-require 'rexml/document'
-
-PROJECT_DIR        = Dir.getwd
-UPDATE_MARKER_FILE = File.expand_path(File.join('bin', 'LAST_UPDATE'), File.dirname(__FILE__))
-BUNDLE_JAR         = File.expand_path 'libs/bundle.jar'
-BUNDLE_PATH        = File.expand_path 'bin/bundle'
-MANIFEST_FILE      = File.expand_path 'AndroidManifest.xml'
-RUBOTO_CONFIG_FILE = File.expand_path 'ruboto.yml'
-GEM_FILE           = File.expand_path('Gemfile.apk')
-GEM_LOCK_FILE      = File.expand_path('Gemfile.apk.lock')
-RELEASE_APK_FILE   = File.expand_path "bin/#{build_project_name}-release.apk"
-APK_FILE           = File.expand_path "bin/#{build_project_name}-debug.apk"
-TEST_APK_FILE      = File.expand_path "test/bin/#{build_project_name}Test-debug.apk"
-JRUBY_JARS         = Dir[File.expand_path 'libs/jruby-*.jar']
-RESOURCE_FILES     = Dir[File.expand_path 'res/**/*']
-JAVA_SOURCE_FILES  = Dir[File.expand_path 'src/**/*.java']
-RUBY_SOURCE_FILES  = Dir[File.expand_path 'src/**/*.rb']
-APK_DEPENDENCIES   = [MANIFEST_FILE, RUBOTO_CONFIG_FILE, BUNDLE_JAR] + JRUBY_JARS + JAVA_SOURCE_FILES + RESOURCE_FILES + RUBY_SOURCE_FILES
-KEYSTORE_FILE      = (key_store = File.readlines('ant.properties').grep(/^key.store=/).first) ? key_store.chomp.sub(/^key.store=/, '') : "#{build_project_name}.keystore"
-KEYSTORE_ALIAS     = (key_alias = File.readlines('ant.properties').grep(/^key.alias=/).first) ? key_alias.chomp.sub(/^key.alias=/, '') : build_project_name
-
-CLEAN.include('bin')
-
-task :default => :debug
-
-file JRUBY_JARS => RUBOTO_CONFIG_FILE do
-  next unless File.exists? RUBOTO_CONFIG_FILE
-  jruby_jars_mtime = JRUBY_JARS.map { |f| File.mtime(f) }.min
-  ruboto_yml_mtime = File.mtime(RUBOTO_CONFIG_FILE)
-  next if jruby_jars_mtime > ruboto_yml_mtime
-  puts '*' * 80
-  if JRUBY_JARS.empty?
-    puts '  The JRuby jars are missing.'
-  else
-    puts "  The JRuby jars need reconfiguring after changes to #{RUBOTO_CONFIG_FILE}"
-    puts "  #{RUBOTO_CONFIG_FILE}: #{ruboto_yml_mtime}"
-    puts "  #{JRUBY_JARS.join(', ')}: #{jruby_jars_mtime}"
-  end
-  puts '  Run "ruboto update jruby" to regenerate the JRuby jars'
-  puts '*' * 80
-end
-
-desc 'build debug package'
-task :debug => APK_FILE
-
-namespace :debug do
-  desc 'build debug package if compiled files have changed'
-  task :quick => [MANIFEST_FILE, RUBOTO_CONFIG_FILE, BUNDLE_JAR] + JRUBY_JARS + JAVA_SOURCE_FILES + RESOURCE_FILES do |t|
-    build_apk(t, false)
-  end
-end
-
-desc "build package and install it on the emulator or device"
-task :install => APK_FILE do
-  install_apk
-end
-
-namespace :install do
-  desc 'uninstall, build, and install the application'
-  task :clean => [:uninstall, APK_FILE, :install]
-
-  desc 'Install the application, but only if compiled files are changed.'
-  task :quick => 'debug:quick' do
-    install_apk
-  end
-end
-
-desc 'Build APK for release'
-task :release => RELEASE_APK_FILE
-
-file RELEASE_APK_FILE => [KEYSTORE_FILE] + APK_DEPENDENCIES do |t|
-  build_apk(t, true)
-end
-
-desc 'Create a keystore for signing the release APK'
-file KEYSTORE_FILE do
-  unless File.read('ant.properties') =~ /^key.store=/
-    File.open('ant.properties', 'a'){|f| f << "\nkey.store=#{KEYSTORE_FILE}\n"}
-  end
-  unless File.read('ant.properties') =~ /^key.alias=/
-    File.open('ant.properties', 'a'){|f| f << "\nkey.alias=#{KEYSTORE_ALIAS}\n"}
-  end
-  sh "keytool -genkey -v -keystore #{KEYSTORE_FILE} -alias #{KEYSTORE_ALIAS} -keyalg RSA -keysize 2048 -validity 10000"
-end
-
-desc 'Tag this working copy with the current version'
-task :tag => :release do
-  unless `git branch` =~ /^\* master$/
-    puts "You must be on the master branch to release!"
-    exit!
-  end
-  # sh "git commit --allow-empty -a -m 'Release #{version}'"
-  output = `git status --porcelain`
-  raise "Workspace not clean!\n#{output}" unless output.empty?
-  sh "git tag #{version}"
-  sh "git push origin master --tags"
-end
-
-task :sign => :release do
-  sh "jarsigner -keystore #{ENV['RUBOTO_KEYSTORE']} -signedjar bin/#{build_project_name}.apk bin/#{build_project_name}-unsigned.apk #{ENV['RUBOTO_KEY_ALIAS']}"
-end
-
-task :align => :sign do
-  sh "zipalign 4 bin/#{build_project_name}.apk #{build_project_name}.apk"
-end
-
-task :publish => :align do
-  puts "#{build_project_name}.apk is ready for the market!"
-end
-
-desc 'Start the emulator with larger disk'
-task :emulator do
-  sh 'emulator -partition-size 1024 -avd Android_3.0'
-end
-
-task :start do
-  start_app
-end
-
-task :stop do
-  raise "Unable to stop app.  Only available on emulator." unless stop_app
-end
-
-desc 'Restart the application'
-task :restart => [:stop, :start]
-
-task :uninstall do
-  uninstall_apk
-end
-
-file MANIFEST_FILE
-file RUBOTO_CONFIG_FILE
-
-file APK_FILE => APK_DEPENDENCIES do |t|
-  build_apk(t, false)
-end
-
-desc 'Copy scripts to emulator or device'
-task :update_scripts => ['install:quick'] do
-  update_scripts
-end
-
-namespace :update_scripts do
-  desc 'Copy scripts to emulator and restart the app'
-  task :restart => APK_DEPENDENCIES do |t|
-    if build_apk(t, false) || !stop_app
-      install_apk
-    else
-      update_scripts
-    end
-    start_app
-  end
-end
-
-task :test => :uninstall do
-  Dir.chdir('test') do
-    puts 'Running tests'
-    sh "adb uninstall #{package}.tests"
-    sh "ant instrument install test"
-  end
-end
-
-namespace :test do
-  task :quick => :update_scripts do
-    Dir.chdir('test') do
-      puts 'Running quick tests'
-      sh 'ant instrument'
-      sh 'ant installi'
-      sh "ant run-tests-quick"
-    end
-  end
-end
-
-file GEM_FILE
-file GEM_LOCK_FILE
-
-desc 'Generate bundle jar from Gemfile'
-task :bundle => BUNDLE_JAR
-
-file BUNDLE_JAR => [GEM_FILE, GEM_LOCK_FILE] do
-  next unless File.exists? GEM_FILE
-  puts "Generating #{BUNDLE_JAR}"
-
-  FileUtils.mkdir_p BUNDLE_PATH
-  sh "bundle install --gemfile #{GEM_FILE} --path=#{BUNDLE_PATH}"
-  gem_path = Dir["#{BUNDLE_PATH}/*ruby/1.8/gems"][0]
-
-  if package != 'org.ruboto.core' && JRUBY_JARS.none? { |f| File.exists? f }
-    Dir.chdir gem_path do
-      Dir['activerecord-jdbc-adapter-*'].each do |g|
-        puts "Removing #{g} gem since it is included in the RubotoCore platform apk."
-        FileUtils.rm_rf g
-      end
-    end
-  end
-
-  # Remove duplicate files
-  Dir.chdir gem_path do
-    scanned_files = []
-    source_files = RUBY_SOURCE_FILES.map { |f| f.gsub("#{PROJECT_DIR}/src/", '') }
-    Dir["*/lib/**/*"].each do |f|
-      next if File.directory? f
-      raise "Malformed file name" unless f =~ %r{^(.*?)/lib/(.*)$}
-      gem_name, lib_file = $1, $2
-      if existing_file = scanned_files.find { |sf| sf =~ %r{(.*?)/lib/#{lib_file}} }
-        puts "Overwriting duplicate file #{lib_file} in gem #{$1} with file in #{gem_name}"
-        FileUtils.rm existing_file
-        scanned_files.delete existing_file
-      elsif source_files.include? lib_file
-        puts "Removing duplicate file #{lib_file} in gem #{gem_name}"
-        puts "Already present in project source src/#{lib_file}"
-        FileUtils.rm f
-        next
-      end
-      scanned_files << f
-    end
-  end
-
-  # Expand JARs
-  Dir.chdir gem_path do
-    Dir['*'].each do |gem_lib|
-      Dir.chdir "#{gem_lib}/lib" do
-        Dir['**/*.jar'].each do |jar|
-          unless jar =~ /sqlite-jdbc/
-            puts "Expanding #{gem_lib} #{jar} into #{BUNDLE_JAR}"
-            `jar xf #{jar}`
-          end
-          if jar == 'arjdbc/jdbc/adapter_java.jar'
-            jar_load_code = <<-END_CODE
-require 'jruby'
-Java::arjdbc.jdbc.AdapterJavaService.new.basicLoad(JRuby.runtime)
-            END_CODE
-          else
-            jar_load_code = ''
-          end
-          puts "Writing dummy JAR file #{jar + '.rb'}"
-          File.open(jar + '.rb', 'w') { |f| f << jar_load_code }
-          if jar.end_with?('.jar')
-            puts "Writing dummy JAR file #{jar.sub(/.jar$/, '.rb')}"
-            File.open(jar.sub(/.jar$/, '.rb'), 'w') { |f| f << jar_load_code }
-          end
-          FileUtils.rm_f(jar)
-        end
-      end
-    end
-  end
-
-
-  FileUtils.rm_f BUNDLE_JAR
-  Dir["#{gem_path}/*"].each_with_index do |gem_dir, i|
-    `jar #{i == 0 ? 'c' : 'u'}f #{BUNDLE_JAR} -C #{gem_dir}/lib .`
-  end
-  FileUtils.rm_rf BUNDLE_PATH
-end
-
-# Methods
-
-def mark_update(time = Time.now)
-  FileUtils.mkdir_p File.dirname(UPDATE_MARKER_FILE)
-  File.open(UPDATE_MARKER_FILE, 'w') { |f| f << time.iso8601 }
-end
-
-def clear_update
-  mark_update File.ctime APK_FILE
-  if device_path_exists?(scripts_path)
-    sh "adb shell rm -r #{scripts_path}"
-    puts "Deleted scripts directory #{scripts_path}"
-  end
-end
-
-def strings(name)
-  @strings ||= REXML::Document.new(File.read('res/values/strings.xml'))
-  value = @strings.elements["//string[@name='#{name.to_s}']"] or raise "string '#{name}' not found in strings.xml"
-  value.text
-end
-
-def version()
-  strings :version_name
-end
-
-def app_name()
-  strings :app_name
-end
-
-def main_activity()
-  manifest.root.elements['application'].elements["activity[@android:label='@string/app_name']"].attribute('android:name')
-end
-
-def device_path_exists?(path)
-  path_output =`adb shell ls #{path}`
-  result = path_output.chomp !~ /No such file or directory|opendir failed, Permission denied/
-  result
-end
-
-def package_installed? test = false
-  package_name = "#{package}#{'.tests' if test}"
-  ['', '-0', '-1', '-2'].each do |i|
-    p = "/data/app/#{package_name}#{i}.apk"
-    o = `adb shell ls -l #{p}`.chomp
-    if o =~ /^-rw-r--r-- system\s+system\s+(\d+) \d{4}-\d{2}-\d{2} \d{2}:\d{2} #{File.basename(p)}$/
-      apk_file = test ? TEST_APK_FILE : APK_FILE
-      if !File.exists?(apk_file) || $1.to_i == File.size(apk_file)
-        return true
-      else
-        return false
-      end
-    end
-  end
-  return nil
-end
-
-private
-
-def replace_faulty_code(faulty_file, faulty_code)
-  explicit_requires = Dir["#{faulty_file.chomp('.rb')}/*.rb"].sort.map { |f| File.basename(f) }.map do |filename|
-    "require 'active_model/validations/#{filename}'"
-  end.join("\n")
-
-  old_code = File.read(faulty_file)
-  new_code = old_code.gsub faulty_code, explicit_requires
-  if new_code != old_code
-    puts "Replaced directory listing code in file #{faulty_file} with explicit requires."
-    File.open(faulty_file, 'w') { |f| f << new_code }
-  else
-    puts "Could not find expected faulty code\n\n#{faulty_code}\n\nin file #{faulty_file}\n\n#{old_code}\n\n"
-  end
-end
-
-def build_apk(t, release)
-  apk_file = release ? RELEASE_APK_FILE : APK_FILE
-  if File.exist?(apk_file)
-    changed_prereqs = t.prerequisites.select do |p|
-      File.file?(p) && !Dir[p].empty? && Dir[p].map { |f| File.mtime(f) }.max > File.mtime(APK_FILE)
-    end
-    return false if changed_prereqs.empty?
-    changed_prereqs.each { |f| puts "#{f} changed." }
-    puts "Forcing rebuild of #{apk_file}."
-  end
-  if release
-    sh 'ant release'
-  else
-    sh 'ant debug'
-  end
-  return true
-end
-
-def install_apk
-  case package_installed?
-  when true
-    puts "Package already installed."
-    return
-  when false
-    puts "Package installed, but of wrong size."
-  end
-  sh 'ant installd'
-  clear_update
-end
-
-def uninstall_apk
-  return if package_installed?.nil?
-  puts "Uninstalling package #{package}"
-  system "adb uninstall #{package}"
-  if $? != 0 && package_installed?
-    puts "Uninstall failed exit code #{$?}"
-    exit $?
-  end
-end
-
-def update_scripts
-  `adb shell mkdir -p #{scripts_path}` if !device_path_exists?(scripts_path)
-  puts "Pushing files to apk public file area."
-  last_update = File.exists?(UPDATE_MARKER_FILE) ? Time.parse(File.read(UPDATE_MARKER_FILE)) : Time.parse('1970-01-01T00:00:00')
-  # TODO(uwe): Use `adb sync src` instead?
-  Dir.chdir('src') do
-    Dir["**/*.rb"].each do |script_file|
-      next if File.directory? script_file
-      next if File.mtime(script_file) < last_update
-      next if script_file =~ /~$/
-      print "#{script_file}: "; $stdout.flush
-      `adb push #{script_file} #{scripts_path}/#{script_file}`
-    end
-  end
-  mark_update
-end
-
-def start_app
-  `adb shell am start -a android.intent.action.MAIN -n #{package}/.#{main_activity}`
-end
-
-def stop_app
-  output = `adb shell ps | grep #{package} | awk '{print $2}' | xargs adb shell kill`
-  return output !~ /Operation not permitted/
-end
+# Write your own rake tasks here.
+# You can find the Ruboto rake tasks in rakelib/ruboto.rake