remi-andrake 0.1.0

data/lib/andrake/resource_manager.rb

@@ -0,0 +1,42 @@
+class Andrake::ResourceManager
+  attr_accessor :resources
+
+  def resources
+    @resources ||= {}
+  end
+
+  def [] resource_name
+    resources[resource_name] ||= {}
+  end
+
+  def []= *args
+    puts "[]= #{ args.inspect }"
+  end
+
+  def method_missing name, *args
+    if args.empty?
+      self[ name ]
+    elsif args.first.is_a?Hash
+      self[ name ].merge! args.first
+    else
+      raise "not sure what to do with #{name.inspect}(#{args.inspect})"
+    end
+  end
+
+  # this is pretty icky, but it's just a prototype!
+  def to_xml
+    require 'builder'
+    builder = Builder::XmlMarkup.new :indent => 2
+    builder.instruct! :xml, :version => '1.0', :encoding => 'utf-8'
+    builder.resources do |res|
+      resources.each  do |type, values|
+        type = type.to_s.singularize
+        values.each   do |value|
+          name, value = value.first, value.last
+          eval "res.#{type} #{value.inspect}, :name => #{name.inspect}"
+        end
+      end
+    end
+  end
+
+end

data/lib/android.rb

@@ -0,0 +1,21 @@
+$:.unshift File.dirname(__FILE__)
+require 'fileutils'
+require 'javaclass' # <--- should be moved to a gem, eventually
+require 'rubygems'
+
+class Android
+  def self.gem_root
+    lib = File.dirname __FILE__
+    File.expand_path File.join(lib, '..')
+  end
+
+  def self.devices
+    `adb devices`.sub("List of devices attached \n",'').split("\n")
+  end
+end
+
+require 'android/extensions'
+require 'android/application'
+require 'android/javaclass'
+require 'android/activity'
+require 'android/layout'

data/lib/android/activity.rb

@@ -0,0 +1,2 @@
+class Android::Activity < Android::JavaClass
+end

data/lib/android/application.rb

@@ -0,0 +1,194 @@
+# Represents an Android application, with the conventional 
+# layout used by Android applications
+#
+class Android::Application
+
+  # the root directory of the Application
+  attr_accessor :root, :name
+
+  def initialize root_directory = File.dirname(__FILE__)
+    @root = File.expand_path root_directory
+  end
+
+  # returns the String name of this Application
+  #
+  # currently simply returns the directory name, 
+  # whereas it really should parse the AndroidManifest.xml
+  def name
+    @name ||= File.basename(File.expand_path(root))
+  end
+
+  # returns an Array of all of this Application's 
+  # .java classes (Android::JavaClass)
+  def classes
+    Android::JavaClass.find_all root
+  end
+
+  # returns an Array of all of this Application's
+  # .xml layout files (Android::Layout)
+  def layouts
+    Android::Layout.find_all root
+  end
+
+  # returns an Array of all of this Application's
+  # .java classes that are activities (Android::Activity)
+  def activities
+    classes_by_type Android::Activity
+  end
+
+  # returns the resource JavaClass 'R'
+  def resource_class
+    classes.find {|klass| klass.name == 'R' }
+  end
+
+  # returns the String path to this Application's built .apk file
+  def apk_file
+    if File.file? File.join root, 'bin', "#{name}.apk"
+      File.join root, 'bin', "#{name}.apk"
+    elsif File.file? File.join root, 'bin', "#{name}-debug.apk"
+      File.join root, 'bin', "#{name}-debug.apk"
+    else 
+      nil
+    end
+  end
+
+  # actually builds the Application to an APK
+  #
+  # returns false if the APK wasn't properly created
+  #
+  def build
+    self.name = File.basename(File.expand_path(File.join('.'))) if self.name == '.app'
+    write_build_xml_template
+    check_build_dependencies
+    require 'open3'
+    build_command = %{cd '#{root}' && ant}
+    @build_output = Open3.popen3 build_command
+    return (@build_output[1].read.include?('BUILD SUCCESSFUL')) ? true : false
+  end
+
+  # returns a formatted String displaying information 
+  # about this Application
+  def info
+%{Name: #{name}
+#{classes.length} classes: #{classes.map(&:name).join(', ')}
+#{activities.length} activities: #{activities.map(&:name).join(', ')}
+#{layouts.length} layouts: #{layouts.map(&:name).join(', ')}
+APK: #{apk_file}
+}
+  end
+
+  # the MAIN Activity for this Android application
+  #
+  # TODO right now this is just getting the first Activity 
+  #      that has an intent-filter defined!
+  def main_activity
+    main = ''
+    if File.file? File.join(root, 'AndroidManifest.xml')
+      require 'hpricot'
+      doc = Hpricot(File.read(File.join(root, 'AndroidManifest.xml')))
+      name = ''
+      ( doc / :activity ).each do |activity|
+        if ( activity / 'intent-filter' ).length > 0
+          name = activity['android:name']
+          break
+        end
+      end
+      name.sub! /^\./, ''
+      main = activities.find {|a| a.name == name }
+    else
+      main = activities.find {|a| a.name.downcase == self.name.downcase }
+      main = activities.find {|a| a.name.downcase == "#{ self.name.downcase }activity" } unless main
+      main = activities.find {|a| self.name.downcase.include? a.name.downcase } unless main
+      main = activities.find {|a| a.name.downcase.include? self.name.downcase } unless main
+      raise "Hmm ... couldn't figure out which the main activity is ... activities: #{ activities.map {|a| a.name}.inspect }" unless main
+    end
+
+    main
+  end
+
+  def manifest_xml
+    file_path = File.join root, 'AndroidManifest.xml'
+    File.read file_path
+  end
+
+  # runs this Android application (on the default device)
+  def run
+    self.name = File.basename(File.expand_path(File.join('.'))) if self.name == '.app'
+    package = main_activity.package_name # TODO need to actually figure out which 
+    cmd = "cd '#{root}' && adb shell am start -n #{package}/#{package}.#{main_activity.name}"
+    puts cmd
+    make_sure_a_device_is_present
+    puts `#{cmd}`
+  end
+
+  # installs this Android application (on the default device)
+  def install
+    build
+    cmd = "cd '#{root}' && adb install '#{apk_file}'" if apk_file
+    puts cmd
+    make_sure_a_device_is_present
+    puts `#{cmd}`
+  end
+
+  # uninstalls this Android application (on the default device)
+  def uninstall
+    bin_dir = File.join root, 'bin'
+    FileUtils.rm_r bin_dir if File.directory? bin_dir
+    cmd = "cd '#{root}' && adb uninstall #{ main_activity.package }"
+    puts cmd
+    make_sure_a_device_is_present
+    puts `#{cmd}`
+  end
+
+  # reinstalls this Android application (on the default device)
+  def reinstall
+    uninstall
+    install
+  end
+
+  # returns true if the directory appears to be an Android application,
+  # else returns false
+  #
+  # specifically, we check to see if there's an AndroidManifest.xml
+  #
+  # TODO go up the directory tree to find a root!  go up to root 
+  #      looking for an AndroidManifest.xml
+  def self.is_application? directory
+    return File.file? File.join(directory, 'AndroidManifest.xml')
+  end
+
+  protected
+
+  # makes sure that all of the dependencies needed to build this 
+  # Android Application are present
+  def check_build_dependencies
+    libs = File.join root, 'libs'
+    FileUtils.mkdir libs unless File.directory? libs
+  end
+
+  # creates a build.xml Ant script in this Application's root directory
+  def write_build_xml_template
+    build_xml = File.join root, 'build.xml'
+    unless File.file? build_xml
+      require 'erb'
+      template = File.read File.join(Android.gem_root, 'templates', 'build.xml.erb')
+      rendered = ERB.new(template).result(proc { @app = self; proc{}}.call)
+      File.open(build_xml, 'w'){|f| f << rendered }
+    end
+  end
+
+  # returns an Array of all of this Application's
+  # .java classes that match the given type, eg: Android::Activity
+  def classes_by_type type
+    classes.select {|klass| klass.is_a? type }
+  end
+
+  # if no device is present, start up an emulator
+  def make_sure_a_device_is_present
+    unless Android.devices.length > 0
+      require 'open3'
+      Open3.popen3 'emulator'
+    end
+  end
+
+end

data/lib/android/bin.rb

@@ -0,0 +1,75 @@
+require 'optparse'
+require 'simplecli'
+
+class Android::Bin
+  include SimpleCLI
+
+  def usage *args
+    puts <<doco
+
+  android == %{ Android Development Companion }
+
+    Usage:
+      android command [options]
+
+    Examples:
+      android info
+
+    Further help:
+      android commands         # list all available commands
+      android help <COMMAND>   # show help for COMMAND
+      android help             # show this help message
+
+doco
+  end 
+
+  def current_application
+    if Android::Application.is_application? '.'
+      Android::Application.new '.'
+    else
+      puts "Current directory doesn't appear to be the root of an Android application."
+      exit
+    end
+  end
+
+  def info_help
+    <<doco
+Usage: #{ script_name } info
+
+  Summary:
+    Display information about the current Android application
+  end
+doco
+  end
+  def info
+    puts current_application.info
+  end
+
+  def build_help
+    <<doco
+Usage: #{ script_name } build
+
+  Summary:
+    build the current Android application
+  end
+doco
+  end
+  def build
+    current_application.build
+  end
+
+  def emulate_help
+    <<doco
+Usage: #{ script_name } emulate
+
+  Summary:
+    run the current Android application in the emulator
+  end
+doco
+  end
+  def emulate
+    current_application.reinstall
+    current_application.run
+  end
+
+end

data/lib/android/extensions.rb

@@ -0,0 +1,9 @@
+# little helpful class extensions
+class Array
+  def directories
+    select {|x| File.directory? x }
+  end
+  def files
+    select {|x| File.file? x }
+  end
+end

data/lib/android/gen.rb

@@ -0,0 +1,86 @@
+require 'optparse'
+require 'simplecli'
+require 'simplegen'
+require 'rubygems'
+require 'activesupport' # for now, for alias_method_chain
+
+class OptionParser
+
+  class << self
+    attr_accessor :dynamic_options
+  end
+  OptionParser.dynamic_options ||= { }
+
+  def complete_with_ambiguous_option_handling *args
+    begin
+      complete_without_ambiguous_option_handling *args 
+    rescue
+      puts "AMBIGUOUS FAIL!  #{ args.inspect }"
+      long_arg = "--#{ args[1] }"
+      puts "long: #{long_arg}"
+      self.on("--#{long_arg} [X]"){ |x| puts "handled #{long_arg}" }
+      complete_without_ambiguous_option_handling *args 
+    end
+  end
+  alias_method_chain :complete, :ambiguous_option_handling
+end
+
+gem_root = File.expand_path File.join(File.dirname(__FILE__), '..', '..')
+android_gen_template_dir = File.join gem_root, 'templates', 'android-gen'
+SimpleGen.template_directories << android_gen_template_dir
+SimpleGen.template_directories << File.expand_path("~/.android/templates")
+
+# Android Generator Script
+#
+# currently seperate from the main android tool.
+# i may merge the two back together eventually.
+#
+class Android::Gen
+  include SimpleCLI
+
+  def usage *args
+    puts <<doco
+
+  android-gen == %{ Android Generator Tool }
+
+    Usage:
+      android-gen command [options]
+
+    Examples:
+      android-gen app HelloAndroid
+      android-gen templates
+
+    Further help:
+      android-gen commands         # list all available commands
+      android-gen help <COMMAND>   # show help for COMMAND
+      android-gen help             # show this help message
+
+doco
+  end 
+
+  SimpleGen.templates.each do |template|
+    name = template.name
+
+    define_method "#{name}_help" do
+    <<doco
+Usage: #{ script_name } #{ name }
+
+  Summary:
+    Generate Template: #{ name }
+  end
+doco
+    end
+
+    define_method name do |*args|
+      options = {}
+      opts = OptionParser.new do |opts|
+        opts.on('--foo [X]'){ |x| options[:foo] = x }
+      end
+      opts.parse! args
+
+      puts "WILL GENERATE template: #{ name } with variables: ... #{ options.inspect }"
+    end
+
+  end
+
+end

data/lib/android/javaclass.rb

@@ -0,0 +1,26 @@
+# represents a .java class file
+#
+# we're using *VERY* rudimentary parsing of the 
+# .java source code, at the moment.
+#
+# we need to eventually write a much more intelligent 
+# .java parser or, ideally, find a well-written .java 
+# parser to take advantage of
+#
+class Android::JavaClass < JavaClass
+
+  def self.find_all directory
+    Dir[ File.join(directory, '**', '*.java') ].map do |file_path|
+      java = JavaClass.new file_path
+      # if a the .java class 'extends Foo' and there's a class called 
+      # Android::Foo, we initialize an Android::Foo, else we initialize
+      # a generic Android::JavaClass
+      if java.superclass && Android.const_defined?(java.superclass.to_sym)
+        Android.const_get(java.superclass).new file_path
+      else
+        Android::JavaClass.new file_path
+      end
+    end
+  end
+
+end