bubble-wrap 1.8.0 → 1.9.0

data/motion/core/ns_notification_center.rb

@@ -15,8 +15,8 @@ class NSNotificationCenter
     removeObserver(observer)
     observers.delete(observer)
   end
-  
+
   def post(name, object=nil, info=nil)
     self.postNotificationName(name, object: object, userInfo: info)
   end
-end
+end

data/motion/core/ns_url_request.rb

@@ -3,8 +3,8 @@ class NSURLRequest
   # Provides a to_s method so we can use inspect in instances and get
   # valuable information.
   def to_s
-    "#<#{self.class}:#{self.object_id} - url: #{self.URL.description}, 
-    headers: #{self.allHTTPHeaderFields.inspect}, 
+    "#<#{self.class}:#{self.object_id} - url: #{self.URL.description},
+    headers: #{self.allHTTPHeaderFields.inspect},
     cache policy: #{self.cachePolicy}, Pipelining: #{self.HTTPShouldUsePipelining}, main doc url: #{mainDocumentURL},\
     timeout: #{self.timeoutInterval}, network service type: #{self.networkServiceType} >"
   end

data/motion/core/osx/device.rb

@@ -3,4 +3,4 @@ module BubbleWrap
     module_function
 
   end
-end
+end

data/motion/core/string.rb

@@ -1,6 +1,6 @@
 module BubbleWrap
-  # This module contains simplified version of the `camelize` and 
-  # `underscore` methods from ActiveSupport, since these are such 
+  # This module contains simplified version of the `camelize` and
+  # `underscore` methods from ActiveSupport, since these are such
   # common operations when dealing with the Cocoa API.
   module String
 
@@ -67,8 +67,8 @@ module BubbleWrap
       return color_klass.send(keyword_selector) if color_klass.respond_to? keyword_selector
 
       # Next attempt to convert from hex
-      hex_color = self.gsub("#", "")   
-      case hex_color.size 
+      hex_color = self.gsub("#", "")
+      case hex_color.size
         when 3
           colors = hex_color.scan(%r{[0-9A-Fa-f]}).map!{ |el| (el * 2).to_i(16) }
         when 6
@@ -77,15 +77,15 @@ module BubbleWrap
           colors = hex_color.scan(%r<[0-9A-Fa-f]{2}>).map!{ |el| el.to_i(16) }
         else
           raise ArgumentError
-      end 
+      end
       if colors.size == 3
         BubbleWrap.rgb_color(colors[0], colors[1], colors[2])
       elsif colors.size == 4
         BubbleWrap.rgba_color(colors[1], colors[2], colors[3], colors[0])
       else
         raise ArgumentError
-      end 
-    end  
+      end
+    end
 
   end
 end

data/motion/font/font.rb

@@ -82,4 +82,4 @@ module BubbleWrap
       _attributes
     end
   end
-end
+end

data/motion/ios/8/location_constants.rb

@@ -0,0 +1,21 @@
+module BW
+  # 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(
+    KCLAuthorizationStatusAuthorized,
+    KCLAuthorizationStatusAuthorizedWhenInUse,
+    KCLAuthorizationStatusAuthorizedAlways
+  )
+
+  module Location
+    module_function
+
+    def authorized?
+      [
+        BW::Constants.get("KCLAuthorizationStatus", :authorized),
+        BW::Constants.get("KCLAuthorizationStatus", :authorized_always),
+        BW::Constants.get("KCLAuthorizationStatus", :authorized_when_in_use)
+      ].include?(CLLocationManager.authorizationStatus)
+    end
+  end
+end

data/motion/location/location.rb

@@ -25,10 +25,6 @@ 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 = {
@@ -47,12 +43,15 @@ module BubbleWrap
     # }
     # @block for callback. takes one argument, `result`.
     #   - On error or cancelled, is called with a hash {error: BW::Location::Error::<Type>}
-    #   - On success, is called with a hash {to: #<CLLocation>, from: #<CLLocation>}
+    #   - On success, is called with a hash {to: #<CLLocation>, from: #<CLLocation>, previous: [#<CLLocation>,...]}
+    #   -- :previous will return an Array of CLLocation objects, ordered from oldest to newest, excluding the 
+    #        locations :to and :from, returning an empty Array if no additional locations were provided
     #
     # Example
     # BW::Location.get(distance_filter: 10, desired_accuracy: :nearest_ten_meters) do |result|
     #   result[:to].class == CLLocation
     #   result[:from].class == CLLocation
+    #   result[:previous].class == NSArray<CLLocation>
     #   p "Lat #{result[:to].latitude}, Long #{result[:to].longitude}"
     # end
     def get(options = {}, &block)
@@ -70,6 +69,7 @@ module BubbleWrap
 
       @options[:significant] = false if @options[:significant].nil?
       @retries = 0
+      @from_location = nil
 
       if not enabled?
         error(Error::DISABLED) and return
@@ -86,13 +86,8 @@ module BubbleWrap
       self.location_manager.desiredAccuracy = Constants.get("KCLLocationAccuracy", @options[:desired_accuracy])
       self.location_manager.purpose = @options[:purpose] if @options[:purpose]
 
-      if @options[:significant]
-        self.location_manager.startMonitoringSignificantLocationChanges
-      elsif @options[:compass]
-        self.location_manager.startUpdatingHeading
-      else
-        self.location_manager.startUpdatingLocation
-      end
+      @initialized = true
+      start
     end
 
     def get_significant(options = {}, &block)
@@ -136,6 +131,18 @@ module BubbleWrap
       get_compass(options.merge(once: true), &block)
     end
 
+    # Start getting locations
+    def start
+      return unless initialized?
+      if @options[:significant]
+        self.location_manager.startMonitoringSignificantLocationChanges
+      elsif @options[:compass]
+        self.location_manager.startUpdatingHeading
+      else
+        self.location_manager.startUpdatingLocation
+      end
+    end
+
     # Stop getting locations
     def stop
       return unless @options
@@ -159,9 +166,16 @@ module BubbleWrap
       CLLocationManager.locationServicesEnabled
     end
 
+    # returns true/false if CLLocationManager has been initialized with the provided or default options
+    def initialized?
+      @initialized ||= false
+    end
+
     # returns true/false whether services are enabled for the _app_
     def authorized?
-      [KCLAuthorizationStatusAuthorized, KCLAuthorizationStatusAuthorizedAlways, KCLAuthorizationStatusAuthorizedWhenInUse].include?(CLLocationManager.authorizationStatus)
+      [
+        BW::Constants.get("KCLAuthorizationStatus", :authorized)
+      ].include?(CLLocationManager.authorizationStatus)
     end
 
     def error(type)
@@ -172,13 +186,19 @@ module BubbleWrap
 
     ##########
     # CLLocationManagerDelegate Methods
-    def locationManager(manager, didUpdateToLocation:newLocation, fromLocation:oldLocation)
+    def locationManager(manager, didUpdateLocations:locations)
       if @options[:once]
-        @callback && @callback.call(newLocation)
+        @callback && @callback.call(locations.last)
         @callback = proc { |result| }
         stop
       else
-        @callback && @callback.call({to: newLocation, from: oldLocation})
+        size = locations.count
+        result = {to: locations.last, 
+          from: ( (size > 1) ? locations.last(2).first : @from_location ), 
+          previous: ( (size > 2) ? locations.first(size - 2) : [] )
+        }
+        @from_location = result[:to]
+        @callback && @callback.call(result)
       end
     end
 
@@ -211,8 +231,8 @@ module BubbleWrap
           if @retries > @options[:retries]
             error(Error::LOCATION_UNKNOWN)
           else
-            self.location_manager.stopUpdatingLocation
-            self.location_manager.startUpdatingLocation
+            stop
+            start
           end
         when KCLErrorNetwork
           error(Error::NETWORK_FAILURE)

data/motion/mail/result.rb

@@ -23,7 +23,7 @@ module BubbleWrap
       def failed?
         self.result == MFMailComposeResultFailed || self.error
       end
-      
+
     end
   end
 end

data/motion/media/media.rb

@@ -12,4 +12,4 @@ module BubbleWrap
   end
 end
 
-::Media = BubbleWrap::Media unless defined?(::Media)
+::Media = BubbleWrap::Media unless defined?(::Media)

data/motion/motion/accelerometer.rb

@@ -0,0 +1,55 @@
+module BubbleWrap
+  module Motion
+    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
+
+  end
+end

data/motion/motion/device_motion.rb

@@ -0,0 +1,139 @@
+module BubbleWrap
+  module Motion
+    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

data/motion/motion/gyroscope.rb

@@ -0,0 +1,55 @@
+module BubbleWrap
+  module Motion
+    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
+
+  end
+end