bubble-wrap 1.7.1 → 1.8.0

data/Rakefile

@@ -28,7 +28,7 @@ Motion::Project::App.setup do |app|
   app.spec_files
   if Motion::Project::App.osx?
     app.spec_files -= Dir.glob("./spec/motion/**/ios/**.rb")
-    ["font", "location", "media", "ui", "mail", "sms", "network-indicator"].each do |package|
+    ["font", "motion", "location", "media", "ui", "mail", "sms", "network-indicator"].each do |package|
       app.spec_files -= Dir.glob("./spec/motion/#{package}/**/*.rb")
     end
   else

data/bubble-wrap.gemspec

@@ -3,10 +3,11 @@ require File.expand_path('../lib/bubble-wrap/version', __FILE__)
 
 Gem::Specification.new do |gem|
   gem.authors       = ['Matt Aimonetti', 'Francis Chong', 'James Harton', 'Clay Allsopp', 'Dylan Markow', 'Jan Weinkauff', 'Marin Usalj']
-  gem.email         = ['mattaimonetti@gmail.com', 'francis@ignition.hk', 'james@sociable.co.nz', 'clay.allsopp@gmail.com', 'dylan@dylanmarkow.com', 'jan@dreimannzelt.de', 'mneorr@gmail.com']
+  gem.email         = ['mattaimonetti@gmail.com', 'francis@ignition.hk', 'james@sociable.co.nz', 'clay.allsopp@gmail.com', 'dylan@dylanmarkow.com', 'jan@dreimannzelt.de', 'marin2211@gmail.com']
   gem.description   = 'RubyMotion wrappers and helpers (Ruby for iOS and OS X) - Making Cocoa APIs more Ruby like, one API at a time. Fork away and send your pull request.'
   gem.summary       = 'RubyMotion wrappers and helpers (Ruby for iOS and OS X) - Making Cocoa APIs more Ruby like, one API at a time. Fork away and send your pull request.'
   gem.homepage      = 'http://rubymotion.github.io/BubbleWrap/'
+  gem.license       = 'MIT'
 
   gem.files         = `git ls-files`.split($\)
   gem.test_files    = gem.files.grep(%r{^(test|spec|lib_spec|features)/})
@@ -16,9 +17,9 @@ Gem::Specification.new do |gem|
 
   gem.extra_rdoc_files = gem.files.grep(%r{motion})
 
-  gem.add_dependency 'bubble-wrap-http', BubbleWrap::VERSION
-  gem.add_development_dependency 'mocha', '0.11.4'
-  gem.add_development_dependency 'mocha-on-bacon'
-  gem.add_development_dependency 'bacon'
-  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'mocha', '~> 0.11'
+  gem.add_development_dependency 'mocha-on-bacon', '~> 0.2'
+  gem.add_development_dependency 'bacon', '~> 1.2'
+  gem.add_development_dependency 'rake', '~> 10.0'
+  gem.add_development_dependency 'webstub', '~> 1.1'
 end

data/lib/bubble-wrap.rb

@@ -1,3 +1,2 @@
 require 'bubble-wrap/version' unless defined?(BubbleWrap::VERSION)
 require File.expand_path('../bubble-wrap/core', __FILE__)
-require File.expand_path('../bubble-wrap/http', __FILE__)

data/lib/bubble-wrap/all.rb

@@ -1,4 +1,16 @@
 require File.expand_path('../loader', __FILE__)
-['core', 'http', 'reactor', 'rss_parser', 'ui', 'location', 'media', 'font', 'mail','sms', 'network-indicator'].each { |sub|
+[
+  'core',
+  'font',
+  'location',
+  'mail',
+  'media',
+  'motion',
+  'network-indicator',
+  'reactor',
+  'rss_parser',
+  'sms',
+  'ui',
+].each { |sub|
 	require File.expand_path("../#{sub}", __FILE__)
 }

data/lib/bubble-wrap/location.rb

@@ -8,4 +8,4 @@ BubbleWrap.require_ios("location") do
     file('motion/location/location.rb').depends_on 'motion/util/constants.rb'
     file('motion/location/location.rb').uses_framework('CoreLocation')
   end
-end
+end

data/lib/bubble-wrap/motion.rb

@@ -0,0 +1,10 @@
+require 'bubble-wrap/loader'
+
+BubbleWrap.require_ios('motion') do
+  BubbleWrap.require('motion/util/constants.rb')
+  BubbleWrap.require('motion/core/string.rb')
+  BubbleWrap.require('motion/motion/**/*.rb') do
+    file('motion/motion/motion.rb').depends_on 'motion/util/constants.rb'
+    file('motion/motion/motion.rb').uses_framework('CoreMotion')
+  end
+end

data/lib/bubble-wrap/rss_parser.rb

@@ -1,3 +1,2 @@
 require 'bubble-wrap/loader'
 BubbleWrap.require('motion/rss_parser.rb')
-BubbleWrap.require('motion/http.rb')

data/lib/bubble-wrap/test.rb

@@ -1,3 +1,4 @@
+require 'webstub'
 require 'bubble-wrap/loader'
 BW.require 'motion/util/*.rb'
 BW.require 'motion/test_suite_delegate.rb'

data/lib/bubble-wrap/version.rb

@@ -1,4 +1,4 @@
 module BubbleWrap
-  VERSION = '1.7.1' unless defined?(BubbleWrap::VERSION)
+  VERSION = '1.8.0' unless defined?(BubbleWrap::VERSION)
   MIN_MOTION_VERSION = '2.17'
 end

data/motion/core/device/ios/camera.rb

@@ -15,6 +15,13 @@ module BubbleWrap
       Constants.register UIImagePickerControllerSourceTypePhotoLibrary, UIImagePickerControllerSourceTypeCamera,
           UIImagePickerControllerSourceTypeSavedPhotosAlbum
 
+      Constants.register UIImagePickerControllerQualityTypeHigh,
+          UIImagePickerControllerQualityTypeMedium,
+          UIImagePickerControllerQualityTypeLow,
+          UIImagePickerControllerQualityType640x480,
+          UIImagePickerControllerQualityTypeIFrame1280x720,
+          UIImagePickerControllerQualityTypeIFrame960x540
+
       MEDIA_TYPE_HASH = {movie: KUTTypeMovie, image: KUTTypeImage}
 
       CAMERA_LOCATIONS = [:front, :rear, :none]
@@ -98,7 +105,9 @@ module BubbleWrap
           animated: true,
           on_dismiss: false,
           media_types: [:image],
-          dismiss_completed: nil
+          dismiss_completed: nil,
+          video_quality: :medium,
+          video_maximum_duration: 600
         }.merge(options)
 
         # If we're using Camera.any, by default use photo library
@@ -130,6 +139,8 @@ module BubbleWrap
         self.picker.sourceType = source_type
         self.picker.mediaTypes = media_types
         self.picker.allowsEditing = @options[:allows_editing]
+        self.picker.videoQuality = Constants.get("UIImagePickerControllerQualityType", @options[:video_quality])
+        self.picker.videoMaximumDuration = @options[:video_maximum_duration]
 
         if source_type_readable == :camera && ![:front, :rear].member?(self.location)
           raise Error::INVALID_CAMERA_LOCATION, "Can't use camera location #{self.location} with source type :camera"

data/motion/core/ios/device.rb

@@ -51,6 +51,12 @@ module BubbleWrap
       UIDevice.currentDevice.systemVersion
     end
 
+    # Returns an identifier unique to the vendor across the vendors app.
+    # @return [NSUUID]
+    def vendor_identifier
+      UIDevice.currentDevice.identifierForVendor
+    end
+
     # Delegates to BubbleWrap::Screen.orientation
     def orientation
       screen.orientation
@@ -61,4 +67,4 @@ module BubbleWrap
       screen.interface_orientation
     end
   end
-end
+end

data/motion/core/json.rb

@@ -14,7 +14,7 @@ module BubbleWrap
     # TODO: support options like the C Ruby module does
     def self.parse(str_data, &block)
       return nil unless str_data
-      data = str_data.respond_to?(:to_data) ? str_data.to_data : str_data
+      data = str_data.respond_to?('dataUsingEncoding:') ? str_data.dataUsingEncoding(NSUTF8StringEncoding) : str_data
       opts = NSJSONReadingMutableContainers | NSJSONReadingMutableLeaves | NSJSONReadingAllowFragments
       error = Pointer.new(:id)
       obj = NSJSONSerialization.JSONObjectWithData(data, options:opts, error:error)

data/motion/core/osx/app.rb

@@ -2,6 +2,15 @@ module BubbleWrap
   module App
     module_function
 
+    # Opens an url (string or instance of `NSURL`)
+    # in the default web browser
+    # Usage Example:
+    #   App.open_url("http://www.rubymotion.com")
+    def open_url(url)
+      url = NSURL.URLWithString(url) unless url.is_a?(NSURL)
+      NSWorkspace.sharedWorkspace.openURL(url)
+    end
+
     # Application Delegate
     def delegate
       shared.delegate
@@ -11,5 +20,6 @@ module BubbleWrap
     def shared
       NSApplication.sharedApplication
     end
+
   end
-end
+end

data/motion/core/time.rb

@@ -1,25 +1,48 @@
 class Time
-  
+
   def self.iso8601(time)
+    if time.include?(".")
+      # Fractional Seconds
+      if time.include?('Z')
+        iso8601_with_fractional_seconds(time)
+      else
+        iso8601_with_fractional_seconds_and_timesone(time)
+      end
+    else
+      # Non Fractional Seconds
+      if time.include?('Z')
+        iso8601_zulu(time)
+      else
+        iso8601_with_timezone(time)
+      end
+    end
+  end
+
+  def self.iso8601_zulu(time)
     cached_date_formatter("yyyy-MM-dd'T'HH:mm:ss'Z'").
       dateFromString(time)
   end
-  
+
   def self.iso8601_with_timezone(time)
     cached_date_formatter("yyyy-MM-dd'T'HH:mm:ssZZZZZ").
       dateFromString(time)
   end
-  
+
   def self.iso8601_with_fractional_seconds(time)
     cached_date_formatter("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'").
       dateFromString(time)
   end
 
+  def self.iso8601_with_fractional_seconds_and_timesone(time)
+    cached_date_formatter("yyyy-MM-dd'T'HH:mm:ss.SSSZZZZZ").
+      dateFromString(time)
+  end
+
   private
 
   def self.cached_date_formatter(dateFormat)
     Thread.current[:date_formatters] ||= {}
-    Thread.current[:date_formatters][dateFormat] ||= 
+    Thread.current[:date_formatters][dateFormat] ||=
       NSDateFormatter.alloc.init.tap do |formatter|
         formatter.dateFormat = dateFormat
         formatter.timeZone   = NSTimeZone.timeZoneWithAbbreviation "UTC"

data/motion/location/location.rb

@@ -25,6 +25,10 @@ module BubbleWrap
         KCLLocationAccuracyNearestTenMeters, KCLLocationAccuracyHundredMeters,
         KCLLocationAccuracyKilometer, KCLLocationAccuracyThreeKilometers
 
+    # New additions to CLAuthorizationStatus in ios8
+    # see: https://developer.apple.com/library/prerelease/ios/documentation/CoreLocation/Reference/CLLocationManager_Class/index.html#//apple_ref/c/tdef/CLAuthorizationStatus
+    Constants.register KCLAuthorizationStatusAuthorizedWhenInUse, KCLAuthorizationStatusAuthorizedAlways
+
     module_function
     # Start getting locations
     # @param [Hash] options = {
@@ -150,14 +154,14 @@ module BubbleWrap
       @location_manager
     end
 
-    # returns true/false whether services are enabled for the _device_
+    # returns true/false whether services, or limited services, are enabled for the _device_
     def enabled?
       CLLocationManager.locationServicesEnabled
     end
 
     # returns true/false whether services are enabled for the _app_
     def authorized?
-      CLLocationManager.authorizationStatus == KCLAuthorizationStatusAuthorized
+      [KCLAuthorizationStatusAuthorized, KCLAuthorizationStatusAuthorizedAlways, KCLAuthorizationStatusAuthorizedWhenInUse].include?(CLLocationManager.authorizationStatus)
     end
 
     def error(type)

data/motion/mail/mail.rb

@@ -56,6 +56,10 @@ module BubbleWrap
       mail_controller
     end
 
+    def can_send_mail?
+      !!MFMailComposeViewController.canSendMail
+    end
+
     # Event when the MFMailComposeViewController is closed
     # -------------------------------------------------------------
     # the callback is fired if it was present in the constructor

data/motion/media/player.rb

@@ -73,11 +73,12 @@ module BubbleWrap
         klass = display_modal ? MPMoviePlayerViewController : MPMoviePlayerController
 
         content_url = content_url.is_a?(NSURL) ? content_url : NSURL.URLWithString(content_url)
-        @media_player = klass.alloc.initWithContentURL(content_url)
+        @media_player = klass.alloc.init
 
         self.media_player.prepareToPlay if not display_modal
 
         set_player_options(options)
+        self.media_player.setContentURL(content_url)
 
         NSNotificationCenter.defaultCenter.observe MPMoviePlayerPlaybackDidFinishNotification do |notification|
           h = notification.userInfo

data/motion/motion/motion.rb

@@ -0,0 +1,421 @@
+# Provides a nice DSL for interacting with the standard CMMotionManager from
+# CoreMotion
+module BubbleWrap
+  # These module methods provide the main interface.  It uses a shared manager
+  # (per Apple's recommendation), and they all have a common set of supported
+  # methods:
+  #     available?
+  #     active?
+  #     repeat(opts)
+  #     once(opts)
+  #     every(time_interval, opts)
+  #
+  # @example
+  #     if BW::Motion.accelerometer.available?
+  #       BW::Motion.accelerometer.every(5) do |result|
+  #         # see the README for the keys that are available in result.
+  #       end
+  #     end
+  #
+  # If you insist on using your own manager, or you want more than one
+  # BW::Motion::Whatever running at the same time, you'll need to instantiate
+  # them yourself.
+  #
+  # @example
+  #     mgr = CMMotionManager.alloc.init
+  #     accel = BW::Motion::Accelerometer.new(mgr)
+  #     accel.once do |result_data|
+  #     end
+  #     # => BW::Motion::accelerometer.once do |result_data| ... end
+  module Motion
+    module_function
+
+    def manager
+      @manager ||= CMMotionManager.alloc.init
+    end
+
+    def accelerometer
+      @accelerometer ||= Accelerometer.new(self.manager)
+    end
+
+    def gyroscope
+      @gyroscope ||= Gyroscope.new(self.manager)
+    end
+
+    def magnetometer
+      @magnetometer ||= Magnetometer.new(self.manager)
+    end
+
+    def device
+      @device ||= DeviceMotion.new(self.manager)
+    end
+  end
+
+
+  module Motion
+    module Error
+    end
+
+    class GenericMotionInterface
+
+      def initialize(manager)
+        @manager = manager
+      end
+
+      def repeat(options={}, &blk)
+        raise "A block is required" unless blk
+        blk.weak! if BubbleWrap.use_weak_callbacks?
+
+        self.start(options, &blk)
+        return self
+      end
+
+      def every(time=nil, options={}, &blk)
+        raise "A block is required" unless blk
+        blk.weak! if BubbleWrap.use_weak_callbacks?
+
+        if time.is_a?(NSDictionary)
+          options = time
+        elsif time
+          options = options.merge(interval: time)
+        end
+
+        self.start(options, &blk)
+        return self
+      end
+
+      def once(options={}, &blk)
+        raise "A block is required" unless blk
+        blk.weak! if BubbleWrap.use_weak_callbacks?
+
+        @called_once = false
+        every(options) do |result, error|
+          unless @called_once
+            @called_once = true
+            blk.call(result, error)
+          end
+          self.stop
+        end
+
+        return self
+      end
+
+      private def convert_queue(queue_name)
+        case queue_name
+        when :main, nil
+          return NSOperationQueue.mainQueue
+        when :background
+          queue = NSOperationQueue.new
+          queue.name = 'com.bubble-wrap.core-motion.background-queue'
+          return queue
+        when :current
+          return NSOperationQueue.currentQueue
+        when String
+          queue = NSOperationQueue.new
+          queue.name = queue_name
+          return queue
+        else
+          queue_name
+        end
+      end
+
+      private def internal_handler(handler)
+        retval = -> (result_data, error) do
+          handle_result(result_data, error, handler)
+        end
+        retval.weak! if BubbleWrap.use_weak_callbacks?
+        retval
+      end
+
+    end
+
+    class Accelerometer < GenericMotionInterface
+
+      def start(options={}, &handler)
+        if options.key?(:interval)
+          @manager.accelerometerUpdateInterval = options[:interval]
+        end
+
+        if handler
+          queue = convert_queue(options[:queue])
+          @manager.startAccelerometerUpdatesToQueue(queue, withHandler: internal_handler(handler))
+        else
+          @manager.startAccelerometerUpdates
+        end
+
+        return self
+      end
+
+      private def handle_result(result_data, error, handler)
+        if result_data
+          result = {
+            data: result_data,
+            acceleration: result_data.acceleration,
+            x: result_data.acceleration.x,
+            y: result_data.acceleration.y,
+            z: result_data.acceleration.z,
+          }
+        else
+          result = nil
+        end
+
+        handler.call(result, error)
+      end
+
+      def available?
+        @manager.accelerometerAvailable?
+      end
+
+      def active?
+        @manager.accelerometerActive?
+      end
+
+      def data
+        @manager.accelerometerData
+      end
+
+      def stop
+        @manager.stopAccelerometerUpdates
+      end
+
+    end
+
+    class Gyroscope < GenericMotionInterface
+
+      def start(options={}, &handler)
+        if options.key?(:interval)
+          @manager.gyroUpdateInterval = options[:interval]
+        end
+
+        if handler
+          queue = convert_queue(options[:queue])
+          @manager.startGyroUpdatesToQueue(queue, withHandler: internal_handler(handler))
+        else
+          @manager.startGyroUpdates
+        end
+
+        return self
+      end
+
+      private def handle_result(result_data, error, handler)
+        if result_data
+          result = {
+            data: result_data,
+            rotation: result_data.rotationRate,
+            x: result_data.rotationRate.x,
+            y: result_data.rotationRate.y,
+            z: result_data.rotationRate.z,
+          }
+        else
+          result = nil
+        end
+
+        handler.call(result, error)
+      end
+
+      def available?
+        @manager.gyroAvailable?
+      end
+
+      def active?
+        @manager.gyroActive?
+      end
+
+      def data
+        @manager.gyroData
+      end
+
+      def stop
+        @manager.stopGyroUpdates
+      end
+
+    end
+
+    class Magnetometer < GenericMotionInterface
+
+      def start(options={}, &handler)
+        if options.key?(:interval)
+          @manager.magnetometerUpdateInterval = options[:interval]
+        end
+
+        if handler
+          queue = convert_queue(options[:queue])
+          @manager.startMagnetometerUpdatesToQueue(queue, withHandler: internal_handler(handler))
+        else
+          @manager.startMagnetometerUpdates
+        end
+
+        return self
+      end
+
+      private def handle_result(result_data, error, handler)
+        if result_data
+          result = {
+            data: result_data,
+            field: result_data.magneticField,
+            x: result_data.magneticField.x,
+            y: result_data.magneticField.y,
+            z: result_data.magneticField.z,
+          }
+        else
+          result = nil
+        end
+
+        handler.call(result, error)
+      end
+
+      def available?
+        @manager.magnetometerAvailable?
+      end
+
+      def active?
+        @manager.magnetometerActive?
+      end
+
+      def data
+        @manager.magnetometerData
+      end
+
+      def stop
+        @manager.stopMagnetometerUpdates
+      end
+
+    end
+
+    class DeviceMotion < GenericMotionInterface
+
+      def start(options={}, &handler)
+        if options.key?(:interval)
+          @manager.deviceMotionUpdateInterval = options[:interval]
+        end
+
+        if options.key?(:reference)
+          reference_frame = convert_reference_frame(options[:reference])
+        else
+          reference_frame = nil
+        end
+
+        if handler
+          queue = convert_queue(options[:queue])
+
+          if reference_frame
+              @manager.startDeviceMotionUpdatesUsingReferenceFrame(reference_frame, toQueue: queue, withHandler: internal_handler(handler))
+          else
+              @manager.startDeviceMotionUpdatesToQueue(queue, withHandler: internal_handler(handler))
+          end
+        else
+          if reference_frame
+            @manager.startDeviceMotionUpdatesUsingReferenceFrame(reference_frame)
+          else
+            @manager.startDeviceMotionUpdates
+          end
+        end
+
+        return self
+      end
+
+      private def handle_result(result_data, error, handler)
+        if result_data
+          result = {
+            data: result_data,
+            attitude: result_data.attitude,
+            rotation: result_data.rotationRate,
+            gravity: result_data.gravity,
+            acceleration: result_data.userAcceleration,
+            magnetic: result_data.magneticField,
+          }
+
+          if result_data.attitude
+            result.merge!({
+              roll: result_data.attitude.roll,
+              pitch: result_data.attitude.pitch,
+              yaw: result_data.attitude.yaw,
+              matrix: result_data.attitude.rotationMatrix,
+              quaternion: result_data.attitude.quaternion,
+            })
+          end
+
+          if result_data.rotationRate
+            result.merge!({
+              rotation_x: result_data.rotationRate.x,
+              rotation_y: result_data.rotationRate.y,
+              rotation_z: result_data.rotationRate.z,
+            })
+          end
+
+          if result_data.gravity
+            result.merge!({
+              gravity_x: result_data.gravity.x,
+              gravity_y: result_data.gravity.y,
+              gravity_z: result_data.gravity.z,
+            })
+          end
+
+          if result_data.userAcceleration
+            result.merge!({
+              acceleration_x: result_data.userAcceleration.x,
+              acceleration_y: result_data.userAcceleration.y,
+              acceleration_z: result_data.userAcceleration.z,
+            })
+          end
+
+          if result_data.magneticField
+            case result_data.magneticField.accuracy
+            when CMMagneticFieldCalibrationAccuracyLow
+              accuracy = :low
+            when CMMagneticFieldCalibrationAccuracyMedium
+              accuracy = :medium
+            when CMMagneticFieldCalibrationAccuracyHigh
+              accuracy = :high
+            end
+
+            result.merge!({
+              field: result_data.magneticField.field,
+              magnetic_x: result_data.magneticField.field.x,
+              magnetic_y: result_data.magneticField.field.y,
+              magnetic_z: result_data.magneticField.field.z,
+              magnetic_accuracy: accuracy,
+            })
+          end
+        else
+          result = nil
+        end
+
+        handler.call(result, error)
+      end
+
+      def convert_reference_frame(reference_frame)
+        case reference_frame
+        when :arbitrary_z
+          CMAttitudeReferenceFrameXArbitraryZVertical
+        when :corrected_z
+          CMAttitudeReferenceFrameXArbitraryCorrectedZVertical
+        when :magnetic_north
+          CMAttitudeReferenceFrameXMagneticNorthZVertical
+        when :true_north
+          CMAttitudeReferenceFrameXTrueNorthZVertical
+        else
+          reference_frame
+        end
+      end
+
+      def available?
+        @manager.deviceMotionAvailable?
+      end
+
+      def active?
+        @manager.deviceMotionActive?
+      end
+
+      def data
+        @manager.deviceMotion
+      end
+
+      def stop
+        @manager.stopDeviceMotionUpdates
+      end
+
+    end
+
+  end
+end