ruboto-core 0.0.2 → 0.0.3

data/Gemfile

@@ -0,0 +1,4 @@
+source :gemcutter
+
+gem 'main'
+gem 'jruby-jars'

data/Gemfile.lock

@@ -0,0 +1,16 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    arrayfields (4.7.4)
+    fattr (2.1.0)
+    jruby-jars (1.5.3)
+    main (4.2.0)
+      arrayfields (>= 4.7.4)
+      fattr (>= 2.1.0)
+
+PLATFORMS
+  java
+
+DEPENDENCIES
+  jruby-jars
+  main

data/README.md

@@ -31,6 +31,7 @@ Command-line Tools
 
 * [Application generator](#application_generator) (like the rails application generator)
 * [Class generator](#class_generator) to generate additional Activities, BroadcastReceivers, Services, etc.
+* [Callback generator](#class_generator) to generate specific subclasses to open up access (callbacks) for various portions of the Android API.
 * [Packaging task](#packaging_task) to generate an apk file
 * [Deployment task](#deployment_task) to deploy a generated package to an emulator or connected device
 * [Develop without having to compile to try every change](#update_scripts)
@@ -39,16 +40,52 @@ Command-line Tools
 <a name="application_generator"></a>
 ### Application generator
 
-    $ ruboto gen app --package com.yourdomain.whatever --path path/to/where/you/want/the/app --name NameOfApp --target android-version --activity MainActivityName
-Currently any value but `android-8` will not work.
+    $ ruboto gen app --package com.yourdomain.whatever --path path/to/where/you/want/the/app --name NameOfApp --target android-version --min_sdk another-android-version --activity MainActivityName
+Version values must be specified using'android-' and the sdk level number (e.g., android-8 is froyo).
 
 <a name="class_generator"></a>
 ### Class generator
 
+Generates a Java class (Activity, Service, or BroadcastReceiver) associated with a specific ruboto script.
+
     $ ruboto gen class ClassName --name YourObjectName
 Ex:
     $ ruboto gen class BroadcastReceiver --name AwesomenessReceiver
 
+<a name="callback_generator"></a>
+### Callback generator
+
+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.
+
+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
+Ex:
+    $ ruboto gen class android.telephony.PhoneStateListener --name MyPhoneStateListener
+
+For interfaces that need implementing (e.g., OnClickListener or SensorListener)
+
+    $ ruboto gen interface AndroidPackageAndInterfaceName --name YourClassName
+Ex:
+    $ ruboto gen interface android.hardware.SensorListener --name MySensorListener
+
+Inside your script use: 
+
+    # note that this is different than java_import
+    ruboto_import "your.package.MySensorListener"
+
+Later:
+
+    # Create the callback object
+    @sensor_listener = MySensorListener.new
+
+    # Specify the block to call 
+    @sensor_listener.handle_sensor_changed do |sensor, values|
+      # Do stuff
+    end
+
+    # Register the listener
+
 <a name="packaging_task"></a>
 ### Packaging task
 
@@ -100,8 +137,33 @@ Also, you need root access to your device for this to work, as it needs to write
 
 ### Updating Ruboto's Files
 
-Not implemented, yet.
+You can update various portions of your generated Ruboto app through the ruboto command:
+
+* JRuby:
+ 
+1) If a new version of JRuby is released, you should update your gem (e.g., sudo gem update jruby-jars).
+
+2) From the root directory of your app: 
+
+    $ ruboto update jruby
+
+* The ruboto.rb script:
+
+1) From the root directory of your app: 
+
+    $ ruboto update ruboto
+
+* The core classes (e.g., RubotoActivity):
+
+1) These classes are generated on your machine based on the SDKs (min and target) specified when you 'gen app' (stored in the AndroidManifest.xml)
+
+2) You many want to regenerate them if a new version of the SDK is released, if you change your targets, or if you want more control over the callbacks you receive.
+
+3) From the root directory of your app:
+
+    $ ruboto gen core Activity --method_base all-on-or-none --method_include specific-methods-to-include --method_include specific-methods-to-exclude
 
+4) The generator will load up the SDK information and find the specified methods. The generator will abort around methods that were added or deprecated based on the SDK levels. You can either exclude those methods or add --force to create them anyway (added methods are created without calling super to avoid crashin on legacy hardware).
 
 Scripts
 -------

data/Rakefile

@@ -5,140 +5,6 @@ task :gem do
 end
 
 task :release do
-  `gem push ruboto-core-0.0.1.gem`
-end
-
-require 'erb'
-
-def unprefixed_class(class_name)
-  /\.([^\.]+)\z/.match(class_name)[1]
-end
-
-# active_support/inflector.rb
-def underscore(camel_cased_word)
-  camel_cased_word.to_s.gsub(/::/, '/').
-    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-    gsub(/([a-z\d])([A-Z])/,'\1_\2').
-    tr("-", "_").
-    downcase
-end
-
-def transform_return_type(type)
-  if type.include?(".")
-    return type
-  elsif type == "int"
-    return "Integer"
-  else
-    return type.capitalize
-  end
-end
-
-task :generate_java_classes do
-  all_callbacks = eval(IO.read("lib/java_class_gen/interfaces.txt"))
-
-  @starting_methods = {"BroadcastReceiver" => "onReceive"}
-  @starting_methods.default = "onCreate"
-
-  all_callbacks.each do |full_class, method_hash|
-    @class = unprefixed_class full_class
-    @callbacks = method_hash
-    @full_class = full_class
-    @first_method = @starting_methods[@class]
-
-
-    ##############################################################################################
-    #
-    #   This code resolves any issues with the generated callbacks.
-    #
-    #   1) Remove callbacks that are hard coded in RubotoActivity.erb:
-    #
-
-    if @class == "Activity"
-      @callbacks["android.view.View$OnCreateContextMenuListener"].delete("onCreateContextMenu")
-      #
-      #   2) Remove callbacks that are causing a problem
-      #
-      @callbacks["android.app.Activity"].delete("onRetainNonConfigurationChildInstances")
-      #
-      #   3) Override the callback constant for a few key callbacks
-      #
-      @callbacks["android.app.Activity"]["onMenuItemSelected"]["constant"] = "CB_CREATE_OPTIONS_MENU"
-      @callbacks["android.app.Activity"]["onContextItemSelected"]["constant"] = "CB_CREATE_CONTEXT_MENU"
-      #
-      #   4) Create a unique name for callbacks that have duplicate names
-      #
-      @callbacks["android.content.DialogInterface$OnClickListener"]["onClick"]["ruby_method"] = "on_dialog_click"
-      @callbacks["android.content.DialogInterface$OnClickListener"]["onClick"]["constant"] = "CB_DIALOG_CLICK"
-      @callbacks["android.content.DialogInterface$OnKeyListener"]["onKey"]["ruby_method"] = "on_dialog_key"
-      @callbacks["android.content.DialogInterface$OnKeyListener"]["onKey"]["constant"] = "CB_DIALOG_KEY"
-      @callbacks["android.content.DialogInterface$OnMultiChoiceClickListener"]["onClick"]["ruby_method"] = "on_dialog_multi_choice_click"
-      @callbacks["android.content.DialogInterface$OnMultiChoiceClickListener"]["onClick"]["constant"] = "CB_DIALOG_MULTI_CHOICE_CLICK"
-      #
-      #   5) Report any duplicate name callbacks not handled
-      #
-      callbacks = {}
-      @callbacks.each do |interface,i_info|
-        i_info.each do |method,v|
-          if callbacks[method] and not v["ruby_method"]
-            puts "#{method} in #{interface} and #{callbacks[method]}"
-          else
-            callbacks[v["ruby_method"] || method] = interface
-          end
-        end
-      end
-      #
-      #   6) Create a few new special case callbacks
-      #
-      @callbacks["none"] = {
-        "onDraw" => {"args" => ["android.view.View", "android.graphics.Canvas"]},
-        "onSizeChanged" => {"args" => ["android.view.View", "int", "int", "int", "int"]}
-      }
-    end
-    #
-    ##############################################################################################
-    #
-    #   This code takes the callbacks hash (read out of the interfaces.txt file) and prepares
-    #   it for use in the code below.
-    #
-    @implements = []
-    @constants = []
-    @callbacks.each do |interface,i_info|
-      i_info.each do |method,v|
-        v["interface"] = interface.gsub("$", ".")
-        v["interface"] = "Activity" if v["interface"] == "android.app.Activity"
-        v["method"] = method
-        v["return_type"] = (v["return_type"] || "void").gsub("$", ".")
-        v["interface_method"] = v["interface_method"] || v["method"]
-        v["ruby_method"] = v["ruby_method"] || v["method"].gsub(/[A-Z]/) {|i| "_#{i.downcase}"}
-
-        @implements << v["interface"] if v["interface"] != full_class and
-          v["interface"] != @class and
-          v["interface"] != "none" and
-          not @implements.include?(v["interface"])
-
-        unless v["constant"]
-          constant = v["method"].gsub(/[A-Z]/) {|i| "_#{i}"}.upcase
-          constant = constant[3..-1] if constant[0..2] == "ON_"
-          v["constant"] = "CB_#{constant}"
-        end
-        @constants << v["constant"] unless @constants.include?(v["constant"]) || v["method"] == @first_method
-
-        v["args"] = (v["args"] || [])
-        v["args_with_types"], v["args_alone"] = [], []
-        v["args"].each_with_index {|arg_type, i| v["args_with_types"] << "#{arg_type.gsub("$", ".")} arg#{i}"; v["args_alone"] << "arg#{i}"}
-        v["args_with_types"] = v["args_with_types"].join(", ")
-      end
-    end
-    ##############################################################################################
-
-
-    File.open("assets/src/Inheriting#{@class}.java", "w") do |file|
-      file.write ERB.new(IO.read("lib/java_class_gen/InheritingClass.java.erb"), 0, "%").result
-    end
-
-    File.open("assets/src/org/ruboto/Ruboto#{@class}.java", "w") do |file|
-      file.write ERB.new(IO.read("lib/java_class_gen/RubotoClass.java.erb"), 0, "%").result
-    end
-  end
+  `gem push #{Dir['ruboto-core-*.gem'][-1]}`
 end
 

data/assets/Rakefile

@@ -29,6 +29,8 @@ file jruby_ruboto_jar => generated_libs do
   ant.zip(:destfile=>jruby_ruboto_jar) do
     zipfileset(:src=>jruby_jar) do
       exclude(:name=>'jni/**')
+      # dx chokes on some of the netdb classes, for some reason
+      exclude(:name=>'jnr/netdb/**')
     end
   end
 end

data/assets/assets/scripts/ruboto.rb

@@ -2,11 +2,14 @@
 #
 # ruboto.rb (by Scott Moyer)
 #
-# Wrapper for using RubotoActivity in Ruboto IRB
+# - Wrapper for using RubotoActivity, RubotoService, and
+#     RubotoBroadcastReceiver. 
+# - Provides interface for generating UI elements. 
+# - Imports and configures callback classes.
 #
 #######################################################
 
-$RUBOTO_VERSION = 4
+$RUBOTO_VERSION = 6
 
 def confirm_ruboto_version(required_version, exact=true)
   raise "requires $RUBOTO_VERSION=#{required_version} or greater, current version #{$RUBOTO_VERSION}" if $RUBOTO_VERSION < required_version and not exact
@@ -15,9 +18,9 @@ end
 
 require 'java'
 
+$package_name = "THE_PACKAGE"
 
-
-%w(Activity Dialog BroadcastReceiver Service View).map do |klass|
+%w(Activity Dialog BroadcastReceiver Service).map do |klass|
   java_import "org.ruboto.Ruboto#{klass}"
 end
 
@@ -42,9 +45,9 @@ java_import "android.R"
 java_import "android.util.Log"
 
 module Ruboto
-  java_import "THE_PACKAGE.R"
+  java_import "#{$package_name}.R"
   begin
-    Id = JavaUtilities.get_proxy_class("THE_PACKAGE.R$id")
+    Id = JavaUtilities.get_proxy_class("#{$package_name}.R$id")
   rescue NameError
     Log.d "RUBOTO", "no R$id"
   end
@@ -58,16 +61,14 @@ AndroidIds = JavaUtilities.get_proxy_class("android.R$id")
 #
 
 class Activity
-  attr_accessor :init_block
-
   def start_ruboto_dialog(remote_variable, &block)
     start_ruboto_activity(remote_variable, RubotoDialog, &block)
   end
 
   def start_ruboto_activity(remote_variable, klass=RubotoActivity, &block)
-    @@init_block = block
+    $activity_init_block = block
 
-    if @initialized or not self.is_a?(RubotoActivity)
+    if @initialized or not self.kind_of?(RubotoActivity)
       b = Bundle.new
       b.putString("Remote Variable", remote_variable)
       b.putBoolean("Define Remote Variable", true)
@@ -101,112 +102,134 @@ end
 
 #############################################################################
 #
-# RubotoActivity
+# Configure a class to work with handlers
 #
 
-class RubotoActivity
-  #
-  # Initialize
-  #
-
-  def initialize_activity()
-    instance_eval &@@init_block
-    @initialized = true
-    self
-  end
-
-  #
-  # Option Menus
-  #
-
-  def add_menu title, icon=nil, &block
-    mi = @menu.add(title)
-    mi.setIcon(icon) if icon
-    mi.class.class_eval {attr_accessor :on_click}
-    mi.on_click = block
-  end
-
-  def handle_create_options_menu &block
-    requestCallback RubotoActivity::CB_CREATE_OPTIONS_MENU
-    @create_options_menu_block = block
-  end
-
-  def on_create_options_menu(*args)
-    @menu, @context_menu = args[0], nil
-    instance_eval {@create_options_menu_block.call(*args)} if @create_options_menu_block
-  end
-
-  def on_menu_item_selected(num,menu_item)
-    (instance_eval &(menu_item.on_click); return true) if @menu
-    false
-  end
+def ruboto_allow_handlers(klass)
+  klass.class_eval do
+    def method_missing(name, *args, &block)
+      if name.to_s =~ /^handle_(.*)/ and (const = self.class.const_get("CB_#{$1.upcase}"))
+        setCallbackProc(const, block)
+        self
+      else
+        super
+      end
+    end
 
-  #
-  # Context Menus
-  #
+    def respond_to?(name)
+      return true if name.to_s =~ /^handle_(.*)/ and self.class.const_get("CB_#{$1.upcase}")
+      super
+    end
 
-  def add_context_menu title, &block
-    mi = @context_menu.add(title)
-    mi.class.class_eval {attr_accessor :on_click}
-    mi.on_click = block
+    def initialize_handlers(&block)
+      instance_eval &block
+      self
+    end
   end
+  klass
+end
 
-  def handle_create_context_menu &block
-    requestCallback RubotoActivity::CB_CREATE_CONTEXT_MENU
-    @create_context_menu_block = block
-  end
+#############################################################################
+#
+# Activity Subclass Setup
+#
 
-  def on_create_context_menu(*args)
-    @menu, @context_menu = nil, args[0]
-    instance_eval {@create_context_menu_block.call(*args)} if @create_context_menu_block
-  end
+def ruboto_configure_activity(klass)
+  klass.class_eval do
+    #
+    # Initialize
+    #
 
-  def on_context_item_selected(menu_item)
-    (instance_eval {menu_item.on_click.call(menu_item.getMenuInfo.position)}; return true) if menu_item.on_click
-    false
-  end
-end
+    def initialize_activity()
+      instance_eval &$activity_init_block
+      @initialized = true
+      self
+    end
 
-RUBOTO_CLASSES.each do |klass|
-  klass.class_eval do
-    def when_launched(&block)
-      instance_exec *args, &block
-      on_create nil
+    def handle_finish_create &block
+      @finish_create_block = block
     end
 
-    def handle_create &block
-      @create_block = block
+    def setup_content &block
+      @content_view_block = block
     end
 
     def on_create(bundle)
+      @view_parent = nil
       setContentView(instance_eval &@content_view_block) if @content_view_block
-      instance_eval {@create_block.call} if @create_block
+      instance_eval {@finish_create_block.call} if @finish_create_block
     end
 
-    # plugin or something
-    def setup_content &block
-      @view_parent = nil
-      @content_view_block = block
+    #
+    # Option Menus
+    #
+
+    def add_menu title, icon=nil, &block
+      mi = @menu.add(title)
+      mi.setIcon(icon) if icon
+      mi.class.class_eval {attr_accessor :on_click}
+      mi.on_click = block
+
+      # Seems to be needed or the block might get cleaned up
+      @all_menu_items = [] unless @all_menu_items
+      @all_menu_items << mi
+    end
+
+    def handle_create_options_menu &block
+      p = Proc.new do |*args|
+        @menu, @context_menu = args[0], nil
+        instance_eval {block.call(*args)} if block
+      end
+      setCallbackProc(self.class.const_get("CB_CREATE_OPTIONS_MENU"), p)
+
+      p = Proc.new do |num,menu_item|
+        (instance_eval &(menu_item.on_click); return true) if @menu
+        false
+      end
+      setCallbackProc(self.class.const_get("CB_MENU_ITEM_SELECTED"), p)
     end
 
     #
-    # Setup Callbacks
+    # Context Menus
     #
 
-    def method_missing(name, *args, &block)
-      # make #handle_name_of_callback request that callback
-      if name.to_s =~ /^handle_(.*)/ and (const = RubotoActivity.const_get("CB_#{$1.upcase}"))
-        requestCallback const
-        @eigenclass ||= class << self; self; end
-        @eigenclass.send(:define_method, "on_#{$1}", &block)
-      else
-        super
+    def add_context_menu title, &block
+      mi = @context_menu.add(title)
+      mi.class.class_eval {attr_accessor :on_click}
+      mi.on_click = block
+
+      # Seems to be needed or the block might get cleaned up
+      @all_menu_items = [] unless @all_menu_items
+      @all_menu_items << mi
+    end
+
+    def handle_create_context_menu &block
+      p = Proc.new do |*args|
+        @menu, @context_menu = nil, args[0]
+        instance_eval {block.call(*args)} if block
       end
+      setCallbackProc(self.class.const_get("CB_CREATE_CONTEXT_MENU"), p)
+
+      p = Proc.new do |menu_item|
+        (instance_eval {menu_item.on_click.call(menu_item.getMenuInfo.position)}; return true) if menu_item.on_click
+        false
+      end
+      setCallbackProc(self.class.const_get("CB_CONTEXT_ITEM_SELECTED"), p)
     end
+  end
 
-    def respond_to?(name)
-      return true if name.to_s =~ /^handle_(.*)/ and RubotoActivity.const_get("CB_#{$1.upcase}")
-      super
+  ruboto_allow_handlers(klass)
+end
+ruboto_configure_activity(RubotoActivity)
+
+RUBOTO_CLASSES.each do |klass|
+  # Setup ability to handle callbacks
+  ruboto_allow_handlers(klass)
+
+  klass.class_eval do
+    def when_launched(&block)
+      instance_exec *args, &block
+      on_create nil
     end
 
     eval %Q{
@@ -217,7 +240,6 @@ RUBOTO_CLASSES.each do |klass|
   end
 end
 
-
 #############################################################################
 #
 # RubotoActivity View Generation
@@ -227,8 +249,8 @@ def ruboto_import_widgets(*widgets)
   widgets.each{|i| ruboto_import_widget i}
 end
 
-def ruboto_import_widget(class_name)
-  view_class = java_import "android.widget.#{class_name}"
+def ruboto_import_widget(class_name, package_name="android.widget")
+  view_class = java_import "#{package_name}.#{class_name}"
   return unless view_class
 
   RubotoActivity.class_eval "
@@ -246,14 +268,14 @@ def ruboto_import_widget(class_name)
    "
 end
 
-# Need to load these two to extend classes
-ruboto_import_widgets :ListView, :Button
-
 #############################################################################
 #
 # Extend Common View Classes
 #
 
+# Need to load these two to extend classes
+ruboto_import_widgets :ListView, :Button
+
 class View
   @@convert_params = {
      :wrap_content => ViewGroup::LayoutParams::WRAP_CONTENT,
@@ -308,3 +330,127 @@ class Button
     super(context, params)
   end
 end
+
+#############################################################################
+#
+# Import a class and set it up for handlers
+#
+
+def ruboto_import(package_class)
+  klass = java_import package_class
+  return unless klass
+  ruboto_allow_handlers(klass)
+end
+
+#############################################################################
+#
+# Allows RubotoActivity to handle callbacks covering Class based handlers
+#
+
+def ruboto_register_handler(handler_class, unique_name, for_class, method_name)
+  klass_name = handler_class[/.+\.([A-Z].+)/,1]
+  klass = ruboto_import handler_class
+  return unless klass
+
+  RubotoActivity.class_eval "
+    attr_accessor :#{unique_name}_handler
+
+    def #{unique_name}_handler
+      @#{unique_name}_handler ||= #{klass_name}.new
+    end
+
+    def handle_#{unique_name}(&block)
+      #{unique_name}_handler.handle_#{unique_name} &block
+      self
+    end
+  "
+
+  for_class.class_eval "
+    alias_method :orig_#{method_name}, :#{method_name}
+    def #{method_name}(handler)
+      orig_#{method_name}(handler.kind_of?(RubotoActivity) ? handler.#{unique_name}_handler : handler)
+    end
+  "
+end
+
+ruboto_register_handler("org.ruboto.callbacks.RubotoOnClickListener", "click", Button, "setOnClickListener")
+ruboto_register_handler("org.ruboto.callbacks.RubotoOnItemClickListener", "item_click", ListView, "setOnItemClickListener")
+
+#############################################################################
+#
+# RubotoPreferenceActivity Preference Generation
+#
+
+def ruboto_import_preferences(*preferences)
+  preferences.each{|i| ruboto_import_preference i}
+end
+
+def ruboto_import_preference(class_name, package_name="android.preference")
+  klass = java_import "#{package_name}.#{class_name}"
+  return unless klass
+
+  setup_preferences
+
+  RubotoPreferenceActivity.class_eval "
+     def #{(class_name.to_s.gsub(/([A-Z])/) {'_' + $1.downcase})[1..-1]}(params={})
+        rv = #{class_name}.new self
+        rv.configure self, params
+        @parent.addPreference(rv) if @parent
+        if block_given?
+          old_parent, @parent = @parent, rv
+          yield
+          @parent = old_parent
+        end
+        rv
+     end
+   "
+end
+
+def setup_preferences
+  return if @preferences_setup_complete
+
+  java_import "android.preference.PreferenceScreen"
+  java_import "android.preference.Preference"
+  java_import "org.ruboto.RubotoPreferenceActivity"
+  ruboto_configure_activity(RubotoPreferenceActivity)
+
+
+  RubotoPreferenceActivity.class_eval do
+    def preference_screen(params={})
+      rv = self.getPreferenceManager.createPreferenceScreen(self)
+      rv.configure self, params
+      @parent.addPreference(rv) if @parent
+      if block_given?
+        old_parent, @parent = @parent, rv
+        yield
+        @parent = old_parent
+      end
+      rv
+    end
+
+    def setup_preference_screen &block
+      @preference_screen_block = block
+    end
+
+    def on_create(bundle)
+      @parent = nil
+      setPreferenceScreen(instance_eval &@preference_screen_block) if @preference_screen_block
+      instance_eval {@finish_create_block.call} if @finish_create_block
+    end
+  end
+
+  Preference.class_eval do
+    def configure(context, params = {})
+      params.each do |k, v|
+        if v.is_a?(Array)
+          self.send("set#{k.to_s.gsub(/(^|_)([a-z])/) {$2.upcase}}", *v)
+        else
+          self.send("set#{k.to_s.gsub(/(^|_)([a-z])/) {$2.upcase}}", v)
+        end
+      end
+    end
+  end
+
+  @preferences_setup_complete = true
+end
+