ruboto 0.5.2 → 0.5.3

data/assets/src/ruboto/activity.rb

@@ -0,0 +1,84 @@
+require 'ruboto/base'
+
+#######################################################
+#
+# ruboto/activity.rb
+#
+# Basic activity set up and callback configuration.
+#
+#######################################################
+
+#
+# Context
+#
+
+module Ruboto
+  module Context
+    def initialize_ruboto()
+      eval("#{$new_context_global} = self")
+      $new_context_global = nil
+
+      instance_eval &$context_init_block if $context_init_block
+      $context_init_block = nil
+      setup_ruboto_callbacks 
+
+      @initialized = true
+      self
+    end
+  
+    def start_ruboto_dialog(remote_variable, theme=Java::android.R.style::Theme_Dialog, &block)
+      ruboto_import "org.ruboto.RubotoDialog"
+      start_ruboto_activity(remote_variable, RubotoDialog, theme, &block)
+    end
+  
+    def start_ruboto_activity(global_variable_name, klass=RubotoActivity, theme=nil, &block)
+      $context_init_block = block
+      $new_context_global = global_variable_name
+  
+      if @initialized or (self == $activity && !$activity.kind_of?(RubotoActivity))
+        b = Java::android.os.Bundle.new
+        b.putInt("Theme", theme) if theme
+  
+        i = Java::android.content.Intent.new
+        i.setClass self, klass.java_class
+        i.putExtra("RubotoActivity Config", b)
+  
+        self.startActivity i
+      else
+        initialize_ruboto
+        on_create nil
+      end
+  
+      self
+    end
+  end
+end
+
+java_import "android.content.Context"
+Context.class_eval do
+  include Ruboto::Context
+end
+
+#
+# Basic Activity Setup
+#
+
+module Ruboto
+  module Activity
+  end
+end
+  
+def ruboto_configure_activity(klass)
+  klass.class_eval do
+    include Ruboto::Activity
+    
+    # Can't be moved into the module
+    def on_create(bundle)
+    end
+  end
+end
+
+java_import "android.app.Activity"
+ruboto_import "org.ruboto.RubotoActivity"
+ruboto_configure_activity(RubotoActivity)
+

data/assets/src/ruboto/base.rb

@@ -0,0 +1,88 @@
+#######################################################
+#
+# ruboto/base.rb
+#
+# Code shared by other ruboto components.
+#
+#######################################################
+
+# Only used needed for ruboto-core apps
+require 'ruboto/version'
+$RUBOTO_VERSION = 10
+
+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
+  raise "requires $RUBOTO_VERSION=#{required_version}, current version #{$RUBOTO_VERSION}" if $RUBOTO_VERSION != required_version and exact
+end
+
+require 'java'
+
+$package_name = ($activity || $service || $broadcast_receiver).package_name
+$package      = eval("Java::#{$package_name}")
+
+# Create convenience method for top-level android package so we do not need to prefix with 'Java::'.
+module Kernel
+  def android
+    JavaUtilities.get_package_module_dot_format('android')
+  end
+end
+
+java_import "android.R"
+
+module Ruboto
+  java_import "#{$package_name}.R"
+  begin
+    Id = JavaUtilities.get_proxy_class("#{$package_name}.R$id")
+  rescue NameError
+    Java::android.util.Log.d "RUBOTO", "no R$id"
+  end
+end
+AndroidIds = JavaUtilities.get_proxy_class("android.R$id")
+
+#
+# Callbacks
+#
+
+module Ruboto
+  module CallbackClass
+    def new_with_callbacks &block
+      new.initialize_ruboto_callbacks &block
+    end
+  end
+    
+  module Callbacks
+    def initialize_ruboto_callbacks &block
+      instance_eval &block
+      setup_ruboto_callbacks
+      self
+    end
+    
+    def ruboto_callback_methods 
+      (singleton_methods - ["on_create", "on_receive"]).select{|i| i =~ /^on_/} 
+    end 
+
+    def setup_ruboto_callbacks 
+      ruboto_callback_methods.each do |i| 
+        begin
+          setCallbackProc(self.class.const_get(i.sub(/^on_/, "CB_").upcase), method(i)) 
+        rescue
+        end
+      end 
+    end 
+  end
+end
+
+#
+# Import a class and set it up for handlers
+#
+
+def ruboto_import(package_class)
+  klass = java_import(package_class) || eval("Java::#{package_class}")
+  return unless klass
+
+  klass.class_eval do
+    extend Ruboto::CallbackClass
+    include Ruboto::Callbacks
+  end
+end
+

data/assets/src/ruboto/broadcast_receiver.rb

@@ -0,0 +1,31 @@
+#######################################################
+#
+# ruboto/broadcast_receiver.rb
+#
+# Basic broadcast_receiver set up and callback configuration.
+#
+#######################################################
+
+require 'ruboto/base'
+
+ruboto_import "org.ruboto.RubotoBroadcastReceiver"
+RubotoBroadcastReceiver.class_eval do
+    def self.new_with_callbacks &block
+      (($broadcast_receiver.nil? || $broadcast_receiver.initialized) ? new : $broadcast_receiver).initialize_ruboto_callbacks &block
+    end
+
+    def initialized
+      @initialized ||= false
+    end
+
+    def initialize_ruboto_callbacks &block
+      instance_eval &block
+      setup_ruboto_callbacks
+      @initialized = true
+      self
+    end
+
+    def on_receive(context, intent)
+    end
+end
+

data/assets/src/ruboto/legacy.rb

@@ -0,0 +1,223 @@
+require 'ruboto/activity'
+
+#######################################################
+#
+# ruboto/legacy.rb
+#
+# Required for backwards compatibility. The goal
+# should be to run scripts without this.
+#
+#######################################################
+
+#
+# Old handle methods
+#
+
+module Ruboto
+  module Callbacks
+    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
+
+    def respond_to?(name)
+      return true if name.to_s =~ /^handle_(.*)/ and self.class.const_get("CB_#{$1.upcase}")
+      super
+    end
+
+    def initialize_handlers(&block)
+      instance_eval &block
+      self
+    end
+  end
+end
+
+#
+# Old handle_create for Activities
+#
+
+module Ruboto
+  module Activity
+    def handle_finish_create &block
+      @finish_create_block = block
+    end
+  
+    def setup_content &block
+      @view_parent = nil
+      @content_view_block = block
+    end
+
+    def handle_create(&block)
+      $new_context_global = "$activity"
+      instance_exec &block
+      initialize_ruboto
+      on_create nil
+    end
+  end
+end
+  
+RubotoActivity.class_eval do
+    def on_create(bundle)
+      @view_parent = nil
+      setContentView(instance_eval &@content_view_block) if @content_view_block
+      instance_eval { @finish_create_block.call } if @finish_create_block
+    end
+end
+
+#
+# Allow IRB legacy 
+#
+
+if $package_name == "org.ruboto.irb"
+  Java::org.ruboto.irb.IRB.class_eval do
+    def handle_create(&block)
+      start_ruboto_activity "$activity", RubotoActivity, nil, &block
+    end
+  end
+end
+
+#
+# Legacy Service Subclass Setup
+#
+
+module Ruboto
+  module Service
+    def handle_create(&block)
+      $new_context_global = "$service"
+      instance_exec &block
+      initialize_ruboto
+      on_create
+    end
+  end
+end
+
+#
+# Legacy BroadcastReceiver Subclass Setup
+#
+
+module Ruboto
+  module BroadcastReceiver
+    def handle_receive(&block)
+      instance_exec &block
+      on_receive($context, nil)
+    end
+  end
+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
+
+  unless RubotoActivity.method_defined? "#{unique_name}_handler"
+    RubotoActivity.class_eval "
+      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
+    "
+  end
+
+  unless for_class.method_defined? "orig_#{method_name}"
+    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
+end
+
+def setup_button
+  Button.class_eval do
+    def configure(context, params = {})
+      setOnClickListener(context)
+      super(context, params)
+    end
+  end
+
+  ruboto_register_handler("org.ruboto.callbacks.RubotoOnClickListener", "click", Button, "setOnClickListener")
+end
+
+def setup_image_button
+  ImageButton.class_eval do
+    def configure(context, params = {})
+      setOnClickListener(context)
+      super(context, params)
+    end
+  end
+
+  ruboto_register_handler("org.ruboto.callbacks.RubotoOnClickListener", "click", ImageButton, "setOnClickListener")
+end
+
+def setup_list_view
+  Java::android.widget.ListView.class_eval do
+    attr_reader :adapter, :adapter_list
+
+    def configure(context, params = {})
+      if params.has_key? :list
+        @adapter_list = Java::java.util.ArrayList.new
+        @adapter_list.addAll(params[:list])
+        item_layout = params.delete(:item_layout) || R::layout::simple_list_item_1
+        @adapter    = Java::android.widget.ArrayAdapter.new(context, item_layout, @adapter_list)
+        setAdapter @adapter
+        params.delete :list
+      end
+      if params.has_key? :adapter
+        @adapter = params[:adapter]
+      end
+      setOnItemClickListener(context) # legacy
+      super(context, params)
+    end
+
+    def reload_list(list)
+      @adapter_list.clear
+      @adapter_list.addAll(list)
+      @adapter.notifyDataSetChanged
+      invalidate
+    end
+  end
+
+  ruboto_register_handler("org.ruboto.callbacks.RubotoOnItemClickListener", "item_click", Java::android.widget.ListView, "setOnItemClickListener") # legacy
+end
+
+def setup_spinner
+  Java::android.widget.Spinner.class_eval do
+    attr_reader :adapter, :adapter_list
+
+    def configure(context, params = {})
+      if params.has_key? :list
+        @adapter_list = Java::java.util.ArrayList.new
+        @adapter_list.addAll(params[:list])
+        item_layout = params.delete(:item_layout) || R::layout::simple_spinner_item
+        @adapter    = Java::android.widget.ArrayAdapter.new(context, item_layout, @adapter_list)
+        @adapter.setDropDownViewResource(params.delete(:dropdown_layout) || R::layout::simple_spinner_dropdown_item)
+        setAdapter @adapter
+        params.delete :list
+      end
+      setOnItemSelectedListener(context) # legacy
+      super(context, params)
+    end
+
+    def reload_list(list)
+      @adapter.clear
+      @adapter.addAll(list)
+      @adapter.notifyDataSetChanged
+      invalidate
+    end
+  end
+
+  ruboto_register_handler("org.ruboto.callbacks.RubotoOnItemSelectedListener", "item_selected", Java::android.widget.Spinner, "setOnItemSelectedListener") # legacy
+end
+

data/assets/src/ruboto/menu.rb

@@ -0,0 +1,89 @@
+require 'ruboto/activity'
+
+#######################################################
+#
+# ruboto/menu.rb
+#
+# Make using menus a little easier. This is still using
+# handle methods and may be moved into legacy code.
+#
+#######################################################
+
+module Ruboto
+  module Activity
+    #
+    # 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 = args[0]
+        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|
+        # handles a problem where this is called for context items
+        # TODO(uwe): JRUBY-5866 JRuby can't access nested Java class if the class is called 'id'
+        # TODO(uwe): Remove check for SDK version when we stop supporting api level < 11
+        unless @just_processed_context_item == menu_item || (android.os.Build::VERSION::SDK_INT >= 11 && menu_item.item_id == AndroidIds.home)
+          instance_eval &(menu_item.on_click)
+          @just_processed_context_item = nil
+          true
+        else
+          false
+        end
+      end
+      setCallbackProc(self.class.const_get("CB_MENU_ITEM_SELECTED"), p)
+    end
+
+    #
+    # Context Menus
+    #
+
+    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|
+        @context_menu = 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|
+        if menu_item.on_click
+          arg = menu_item
+          begin
+            arg = menu_item.getMenuInfo.position
+          rescue
+          end
+          instance_eval { menu_item.on_click.call(arg) }
+          @just_processed_context_item = menu_item
+          true
+        else
+          false
+        end
+      end
+      setCallbackProc(self.class.const_get("CB_CONTEXT_ITEM_SELECTED"), p)
+    end
+  end
+end
+