droiuby 0.1.6 → 0.2.0

data/lib/droiuby/plugins/plugins.rb

@@ -0,0 +1,25 @@
+module Droiuby
+  class Plugins
+    
+    def self.descendants
+      @descendants ||= []
+    end
+
+    def self.inherited(descendant)
+      descendants << descendant
+    end
+
+    #ran after all classes are initialized and before executing the MainActivity on_create method
+    def after_bootstrap
+    end
+    
+    #after a partial is rendered
+    def after_partial_setup(view)
+    end
+    
+    #after a complete view is rendered
+    def after_view_setup
+    end
+
+  end
+end

data/lib/droiuby/preload.rb

@@ -0,0 +1,29 @@
+#trigger pre load
+def start_droiuby_plugins
+  puts "starting plugins"
+  $droiuby_plugins = []
+  puts "loading plugins"
+  Droiuby::Plugins.descendants.each { |klass|
+    puts "plugin -> #{klass.to_s}"
+    $droiuby_plugins << klass.new
+  }
+
+  $droiuby_plugins.each do |plugin|
+    puts "plugin attach #{plugin.class.to_s}"
+    plugin.after_bootstrap
+  end unless $droiuby_plugins.blank?
+end
+
+def after_view_setup
+  $droiuby_plugins.each do |plugin|
+    puts "plugin attach #{plugin.class.to_s}"
+    plugin.after_view_setup
+  end unless $droiuby_plugins.blank? 
+end
+
+def after_partial_setup(view_group)
+  $droiuby_plugins.each do |plugin|
+    puts "plugin attach #{plugin.class.to_s}"
+    plugin.after_partial_setup(view_group)
+  end unless $droiuby_plugins.blank?
+end

data/lib/droiuby/{project.rb → scripts/project.rb}

@@ -132,12 +132,17 @@ class Project < Thor
     end
 
     dest_folder = File.join(output_dir,"#{name}")
+    template File.join('ruby','Gemfile.erb'), File.join(dest_folder,"Gemfile")
     template File.join('ruby','config.droiuby.erb'), File.join(dest_folder,"config.droiuby")
     template File.join('ruby','gitignore.erb'), File.join(dest_folder,".gitignore")
     template File.join('ruby','index.xml.erb'), File.join(dest_folder,"index.xml")
     template File.join('ruby','application.css.erb'), File.join(dest_folder,"application.css")
     template File.join('ruby','index.rb.erb'), File.join(dest_folder,"index.rb")
     empty_directory File.join(dest_folder,"lib")
+    say "running bundle install"
+    Dir.chdir dest_folder
+    `bundle install`
+    bundle
   end
 
   desc "package NAME [WORKSPACE_DIR] [true|false]","package a project"
@@ -177,8 +182,11 @@ class Project < Thor
     Thread.new do
       while !ready
       end
-      `adb shell am start -W -S --activity-clear-top --activity-brought-to-front -n com.droiuby.application/.CanvasActivity`
-      launch(device_ip, "http://#{host_name_args}:#{port}/config.droiuby")
+      begin
+        launch(device_ip, "http://#{host_name_args}:#{port}/config.droiuby")
+      rescue Exception=>e
+        `adb shell am start -W -S --activity-clear-top --activity-brought-to-front -n com.droiuby.application/.DroiubyActivity`
+      end
     end
 
     puts "Starting server: http://#{host_name_args}:#{port}"
@@ -264,9 +272,7 @@ class Project < Thor
   end
 
   desc "execute NAME DEVICE_IP [WORKSPACE_DIR]","package and execute a droiuby application to target device running droiuby client"
-
   def execute(name, device_ip, source_dir = 'projects')
-    `adb shell am start -W -S --activity-clear-top --activity-brought-to-front -n com.droiuby.application/.CanvasActivity`
     package name, source_dir, "true"
     upload name, device_ip, source_dir
   end
@@ -312,9 +318,12 @@ class Project < Thor
       FileUtils.rm archive, :force=>true
 
       Zip::File.open(archive, Zip::File::CREATE) do |zipfile|
-        Dir["#{path}/**/**"].reject{ |f| f==archive || f.match(/\/build/) }.each do |file|
+        Dir.glob("**{,/*/**}/*.*").reject{ |f| f==archive || f.match(/^build/) }.uniq.each do |file|
           say_status 'adding', file
-          zipfile.add(file.sub(path+'/',''),file)
+          begin
+            zipfile.add(file, file)
+          rescue Zip::ZipEntryExistsError=>e
+          end
         end
       end
       say_status 'create', archive

data/lib/droiuby/scripts/templates/ruby/Gemfile.erb

@@ -0,0 +1,3 @@
+source 'http://rubygems.org'
+
+gem 'droiuby'

data/lib/droiuby/support/asset.rb

@@ -0,0 +1,47 @@
+class BitmapDrawableWrapper
+  def initialize(drawable)
+    @native = drawable
+  end
+  
+  def native
+    @native
+  end
+  
+  def to_bitmap
+    @native.getBitmap
+  end
+  
+  def height
+    @native.getIntrinsicHeight
+  end
+  
+  def width
+    @native.getIntrinsicWidth
+  end
+end
+
+class AssetHandler
+  
+  def initialize(url)
+    @url = url
+  end
+  
+  def self.download(url)
+    AssetHandler.new(url)
+  end
+  
+  def start
+    async.perform {
+      result = BitmapDrawableWrapper.new(Java::com.droiuby.client.core.utils.Utils.loadAppAssetRuby(_execution_bundle, _current_app, _current_activity,
+      @url, Java::com.droiuby.client.core.utils.Utils::ASSET_TYPE_IMAGE, Java::com.droiuby.client.core.utils.Utils::HTTP_GET))
+      result
+    }.done { |result|
+      @block.call(result)
+    }.start
+  end
+  
+  def done(&block)
+    @block = block
+    self
+  end
+end

data/lib/droiuby/support/autoload.rb

@@ -0,0 +1,22 @@
+
+class Object
+  class << self
+    alias :const_missing_old :const_missing
+    def const_missing(name)
+      puts "constant missing #{name}"
+      @looked_for ||= {}
+      str_name = name.to_s
+      raise "Class not found: #{name}" if @looked_for[str_name]
+      @looked_for[str_name] = 1
+      
+      name_parts = name.to_s.split('::').collect { |n| n.underscore }
+      require_path = File.join(*name_parts)
+      
+      puts "autoloading #{require_path}"
+      require require_path
+      klass = const_get(name)
+      return klass if klass
+      raise "Class not found: #{name}"
+    end
+  end
+end

data/lib/droiuby/support/fixnum.rb

@@ -0,0 +1,11 @@
+class Fixnum
+
+  def dip
+    Java::com.droiuby.client.core.builder.ActivityBuilder.toDeviceIndependentPixels(_current_activity, self)    
+  end
+
+  def to_px
+  	Java::com.droiuby.client.core.builder.ActivityBuilder.toPixelsFromDip(_current_activity, self)
+  end
+  
+end

data/lib/droiuby/support/object.rb

@@ -0,0 +1,11 @@
+class Object
+
+  def blank?
+    respond_to?(:empty?) ? empty? : !self
+  end
+  
+  def boolean?
+    self.is_a?(TrueClass) || self.is_a?(FalseClass) 
+  end
+  
+end

data/lib/droiuby/support/string.rb

@@ -0,0 +1,38 @@
+class String
+  
+  def camelize(first_letter_in_uppercase = true)
+    if first_letter_in_uppercase
+      self.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+    else
+      self.first + camelize(self)[1..-1]
+    end
+  end
+  
+  def to_pixels
+    Java::com.droiuby.client.core.builder.ActivityBuilder.toPixels(_current_activity, self)
+  end
+  
+  def to_color
+    Java::android.graphics.Color.parseColor(self)
+  end
+  
+  def underscore
+    self.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+  
+  def constantize
+    names = self.split('::')
+    names.shift if names.empty? || names.first.empty?
+  
+    constant = Object
+    names.each do |name|
+      constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+    end
+    constant
+  end
+  
+end

data/lib/droiuby/support/system.rb

@@ -0,0 +1,14 @@
+module Droiuby
+  class SystemWrapper
+    
+    include JavaMethodHelper
+    
+    java_native_singleton Java::java.lang.System, :nanoTime, []
+    java_native_singleton Java::java.lang.System, :currentTimeMillis, []
+    java_native_singleton Java::java.lang.System, :currentTimeMillis, []
+    java_native_singleton Java::java.lang.Thread, :sleep, [Java::long]
+    java_native_singleton Java::java.lang.System, :gc, []
+    java_native_singleton Java::android.util.Log, :d, [Java::java.lang.String, Java::java.lang.String]
+    
+  end
+end

data/lib/droiuby/support/thread.rb

@@ -0,0 +1,17 @@
+class Object 
+  def with_large_stack(stack_size_kb = 64, &block) 
+    result = nil 
+    t = Thread.with_large_stack(&proc{result = block.call}) 
+    t.join 
+    result 
+  end 
+end
+
+class Thread 
+  def self.with_large_stack(stack_size_kb = 128, &block)
+    runnable = RunnableWrapper.new(block).to_native 
+    t = Java::java.lang.Thread.new(nil, runnable, "block with large stack", stack_size_kb * 1024) 
+    t.start 
+    t 
+  end 
+end

data/lib/droiuby/support/to_query.rb

@@ -0,0 +1,28 @@
+require 'active_support/core_ext/object/to_param'
+
+class Object
+  # Converts an object into a string suitable for use as a URL query string, using the given <tt>key</tt> as the
+  # param name.
+  #
+  # Note: This method is defined as a default implementation for all Objects for Hash#to_query to work.
+  def to_query(key)
+    require 'cgi' unless defined?(CGI) && defined?(CGI::escape)
+    "#{CGI.escape(key.to_param)}=#{CGI.escape(to_param.to_s)}"
+  end
+  
+end
+
+class Array
+  # Converts an array into a string suitable for use as a URL query string,
+  # using the given +key+ as the param name.
+  #
+  #   ['Rails', 'coding'].to_query('hobbies') # => "hobbies%5B%5D=Rails&hobbies%5B%5D=coding"
+  def to_query(key)
+    prefix = "#{key}[]"
+    collect { |value| value.to_query(prefix) }.join '&'
+  end
+end
+
+class Hash
+  alias_method :to_query, :to_param
+end

data/lib/droiuby/support/utils.rb

@@ -0,0 +1,10 @@
+module Droiuby
+  class Utils
+
+    def self.start_web_console(&block)
+      listener = Droiuby::Wrappers::Listeners::OnWebConsoleReadyListener.new(_execution_bundle,block)
+      Java::com.droiuby.client.core.DroiubyLauncher.setupConsole(_execution_bundle, listener.to_native)
+    end
+
+  end
+end

data/lib/droiuby/wrappers/accelerometer.rb

@@ -0,0 +1,17 @@
+class Accelerometer
+  
+  attr_accessor :sensor, :rate
+  include Droiuby::Wrappers::Listeners
+  
+  def initialize
+    @native = _execution_bundle.getSensor(Java::Sensor.TYPE_ACCELEROMETER)
+  end
+  
+  def on(event, &block)
+    unless @listener
+      @listener = Droiuby::Wrappers::Listeners::AutoWrapMultiple.new(_execution_bundle)
+      @native.registerListener(@listener.to_native('SensorEventListener'), @sensor, @rate)
+    end
+    @listener.impl(event, &block) 
+  end
+end

data/lib/droiuby/wrappers/activity.rb

@@ -0,0 +1,64 @@
+class Activity
+  
+  @@before_content_blocks = []
+
+  def initialize
+  end
+
+  def me
+    _current_activity
+  end
+
+  class << self
+
+    def on_click(name, &block)
+      view = V(name).tap { |v|
+        v.native.setOnClickListener(Java::com.droiuby.client.core.OnClickListenerBridge.new(_execution_bundle, v.id))
+      }
+      define_method("on_click_listener_for_#{view.id.to_s}".to_sym) do |n_view|
+        _current_activity.instance_exec(wrap_native_view(n_view),&block)
+      end
+    end
+    
+    def portrait_mode_only
+      add_before_content_task { _current_activity.setRequestedOrientation(ActivityInfo::SCREEN_ORIENTATION_PORTRAIT) }  
+    end
+
+    def landscape_mode_only
+      add_before_content_task { _current_activity.setRequestedOrientation(ActivityInfo::SCREEN_ORIENTATION_LANDSCAPE) }  
+    end
+
+    def no_action_bar
+      add_before_content_task { _current_activity.requestWindowFeature(Java::android.view.Window::FEATURE_NO_TITLE) }
+    end
+
+    def set_theme(theme, namespace = nil)
+      namespace = "#{namespace}." unless namespace.nil?
+
+      add_before_content_task do  
+        _current_activity.setTheme(_R("#{namespace}R.style.#{theme}"))
+      end
+    end
+
+    private 
+
+    def add_before_content_task(&block) 
+      @@before_content_blocks = @@before_content_blocks || []
+      @@before_content_blocks << block  
+    end
+
+  end
+
+  def on_activity_result(request_code, result_code, intent)
+
+  end
+  
+  def before_content_render
+    @@before_content_blocks.each { |block| block.call }
+    _current_activity.setContentView(_R('R.layout.canvas'))
+  end
+
+  def on_activity_reload
+  end
+
+end

data/lib/droiuby/wrappers/animation.rb

@@ -0,0 +1,141 @@
+class AnimatorListenerWrapper
+  
+  def initialize
+    @native = Java::com.droiuby.wrappers::AnimatorListenerRubyWrapper.new(_execution_bundle, self)
+    @blocks = {}
+  end
+    
+  def set_block(sym, &block)
+    @blocks[sym.to_sym] = block
+  end 
+  
+  def onAnimationStart
+    @block[:start].call if @block.has_key? :start
+  end
+  
+  def onAnimationEnd
+    @block[:end].call if @block.has_key? :end
+  end
+  
+  def onAnimationCancel
+    @block[:cancel].call if @block.has_key? :cancel
+  end
+  
+  def onAnimationRepeat
+    @block[:repeat].call if @block.has_key? :repeat
+  end
+  
+  def to_native
+    @native
+  end
+end
+
+
+#Wrap the android animation API
+class Animator
+    def initialize(target)
+      @animator_set = Java::android.animation.AnimatorSet.new
+      @mode = :together
+      @animators = []
+      @target = target
+      @done = false
+    end
+
+    def animator_set
+      @animator_set
+    end
+
+    def animators
+      @animators
+    end
+
+    def native
+      @animator_set
+    end
+    
+    def method_missing(name, *args, &block)
+      anim = Java::android.animation.ObjectAnimator.ofFloat(@target.native, name.to_s.camelize(:lower), args[0], args[1]);
+      if args[2] && args[2].kind_of?(Hash)
+        duration = args[2][:duration]
+        anim.setDuration(duration)
+      end
+      @animators << anim
+      anim
+    end
+
+    def sequentially
+      @mode = :one_after_the_other
+      self
+    end
+
+    def together
+      @mode = :together
+      self
+    end
+
+    def before(animation)
+      Java::android.animation.AnimatorSet.new.tap { |s|
+        s.play(to_animator(animation)).before(self.animator_set)
+      } if @done
+    end
+
+    def after(animation)
+      s = Java::android.animation.AnimatorSet.new.tap { |s|
+        s.play(to_animator(animation)).after(self.animator_set)
+      } if @done
+    end
+
+    def wait(milliseconds)
+      Java::android.animation.AnimatorSet.new.tap { |s|
+        s.play(self.animator_set).after(milliseconds.to_i)
+      } if @done
+    end
+
+    def with(animation)
+      Java::android.animation.AnimatorSet.new.tap { |s|
+        s.play(to_animator(animation)).with(self.animator_set)
+      } if @done
+    end
+
+    def together
+      @mode = :together
+    end
+    
+    def one_after_the_other
+      @mode = :one_after_the_other
+    end
+    
+    def done
+      @done = true
+      case @mode
+      when :together
+        @animator_set.playTogether(*@animators)
+      when :one_after_the_other
+        @animator_set.playSequentially(*@animators)
+      end
+    end
+
+    def start
+      @animator_set.start
+      self
+    end
+
+    def on(event, &block)
+      @animation_listener = @animation_listener || AnimatorListenerWrapper.new
+      if [:cancel, :start, :end, :repeat ].include?(event)
+        @animation_listener.set_block(event, Proc.new { |v| block.call(wrap_native_view(v))})  
+        self.native.addListener(@animation_listener.to_native)
+      end
+      self
+    end
+    
+    protected
+
+    def to_animator(animation)
+      animator = animation
+      if animation.kind_of? Animator
+        animator = animation.animator_set
+      end
+      animator
+    end
+  end