bubble-wrap 1.8.0 → 1.9.0

data/motion/motion/magnetometer.rb

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

data/motion/motion/motion.rb

@@ -129,293 +129,5 @@ module BubbleWrap
 
     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

data/motion/reactor.rb

@@ -67,7 +67,7 @@ module BubbleWrap
     # parameter (the "operation") and schedule it for asynchronous execution
     # on a GCD concurrency queue. When the operation completes the result (if any)
     # is passed into the callback (if present).
-    def defer(op=nil,cb=nil,&blk) 
+    def defer(op=nil,cb=nil,&blk)
       schedule do
         result = (op||blk).call
         schedule(result, &cb) if cb
@@ -76,7 +76,7 @@ module BubbleWrap
 
     # A version of `defer` which schedules both the operator
     # and callback operations on the application's main thread.
-    def defer_on_main(op=nil,cb=nil,&blk) 
+    def defer_on_main(op=nil,cb=nil,&blk)
       schedule_on_main do
         result = (op||blk).call
         schedule_on_main(result, &cb) if cb
@@ -105,7 +105,7 @@ module BubbleWrap
       end
       ::Dispatch::Queue.main.async &cb
     end
-    
+
   end
 end
 

data/motion/reactor/deferrable.rb

@@ -7,13 +7,13 @@ module BubbleWrap
       #   base.extend ::BubbleWrap::Reactor::Future
       # end
 
-      # Specify a block to be executed if and when the Deferrable object 
-      # receives a status of :succeeded. See set_deferred_status for more 
+      # Specify a block to be executed if and when the Deferrable object
+      # receives a status of :succeeded. See set_deferred_status for more
       # information.
-      # Calling this method on a Deferrable object whose status is not yet 
-      # known will cause the callback block to be stored on an internal 
-      # list. If you call this method on a Deferrable whose status is 
-      # :succeeded, the block will be executed immediately, receiving 
+      # Calling this method on a Deferrable object whose status is not yet
+      # known will cause the callback block to be stored on an internal
+      # list. If you call this method on a Deferrable whose status is
+      # :succeeded, the block will be executed immediately, receiving
       # the parameters given to the prior set_deferred_status call.
       def callback(&blk)
         return unless blk
@@ -35,8 +35,8 @@ module BubbleWrap
         end
       end
 
-      # Specify a block to be executed if and when the Deferrable object 
-      # receives a status of :failed. See set_deferred_status for more 
+      # Specify a block to be executed if and when the Deferrable object
+      # receives a status of :failed. See set_deferred_status for more
       # information.
       def errback(&blk)
         return unless blk
@@ -46,7 +46,7 @@ module BubbleWrap
           blk.call(*@deferred_args)
         elsif @deferred_status != :succeeded
           @errbacks ||= []
-          @errbacks.unshift blk 
+          @errbacks.unshift blk
         end
       end
 
@@ -81,31 +81,31 @@ module BubbleWrap
       end
       alias set_deferred_failure fail
 
-      # Sets the “disposition” (status) of the Deferrable object. See also 
-      # the large set of sugarings for this method. Note that if you call 
-      # this method without arguments, no arguments will be passed to the 
-      # callback/errback. If the user has coded these with arguments, 
-      # then the user code will throw an argument exception. Implementors 
-      # of deferrable classes must document the arguments they will supply 
+      # Sets the “disposition” (status) of the Deferrable object. See also
+      # the large set of sugarings for this method. Note that if you call
+      # this method without arguments, no arguments will be passed to the
+      # callback/errback. If the user has coded these with arguments,
+      # then the user code will throw an argument exception. Implementors
+      # of deferrable classes must document the arguments they will supply
       # to user callbacks.
-      # OBSERVE SOMETHING VERY SPECIAL here: you may call this method even 
-      # on the INSIDE of a callback. This is very useful when a 
-      # previously-registered callback wants to change the parameters that 
+      # OBSERVE SOMETHING VERY SPECIAL here: you may call this method even
+      # on the INSIDE of a callback. This is very useful when a
+      # previously-registered callback wants to change the parameters that
       # will be passed to subsequently-registered ones.
       # You may give either :succeeded or :failed as the status argument.
-      # If you pass :succeeded, then all of the blocks passed to the object 
-      # using the callback method (if any) will be executed BEFORE the 
-      # set_deferred_status method returns. All of the blocks passed to the 
+      # If you pass :succeeded, then all of the blocks passed to the object
+      # using the callback method (if any) will be executed BEFORE the
+      # set_deferred_status method returns. All of the blocks passed to the
       # object using errback will be discarded.
-      # If you pass :failed, then all of the blocks passed to the object 
-      # using the errback method (if any) will be executed BEFORE the 
-      # set_deferred_status method returns. All of the blocks passed to the 
+      # If you pass :failed, then all of the blocks passed to the object
+      # using the errback method (if any) will be executed BEFORE the
+      # set_deferred_status method returns. All of the blocks passed to the
       # object using # callback will be discarded.
-      # If you pass any arguments to set_deferred_status in addition to the 
-      # status argument, they will be passed as arguments to any callbacks 
-      # or errbacks that are executed. It’s your responsibility to ensure 
-      # that the argument lists specified in your callbacks and errbacks match 
-      # the arguments given in calls to set_deferred_status, otherwise Ruby 
+      # If you pass any arguments to set_deferred_status in addition to the
+      # status argument, they will be passed as arguments to any callbacks
+      # or errbacks that are executed. It’s your responsibility to ensure
+      # that the argument lists specified in your callbacks and errbacks match
+      # the arguments given in calls to set_deferred_status, otherwise Ruby
       # will raise an ArgumentError.
       def set_deferred_status(status, *args)
         cancel_timeout
@@ -137,9 +137,9 @@ module BubbleWrap
       end
       alias set_deferred_success succeed
 
-      # Setting a timeout on a Deferrable causes it to go into the failed 
-      # state after the Timeout expires (passing no arguments to the object’s 
-      # errbacks). Setting the status at any time prior to a call to the 
+      # Setting a timeout on a Deferrable causes it to go into the failed
+      # state after the Timeout expires (passing no arguments to the object’s
+      # errbacks). Setting the status at any time prior to a call to the
       # expiration of the timeout will cause the timer to be cancelled.
       def timeout(seconds)
         cancel_timeout