Range of Motion Tasks - added support for all device orientations

ResearchKit/ActiveTasks/ORKRangeOfMotionResult.h

@@ -42,6 +42,11 @@ NS_ASSUME_NONNULL_BEGIN
 ORK_CLASS_AVAILABLE
 @interface ORKRangeOfMotionResult : ORKResult
 
+/**
+ The physical orientation of the device at the start position (the commencement of recording).
+ */
+@property (nonatomic, assign) NSInteger orientation;
+
 /**
  The angle (degrees) from the device reference position at the start position.
  */

ResearchKit/ActiveTasks/ORKRangeOfMotionResult.m

@@ -39,6 +39,7 @@ @implementation ORKRangeOfMotionResult
 
 - (void)encodeWithCoder:(NSCoder *)aCoder {
     [super encodeWithCoder:aCoder];
+    ORK_ENCODE_INTEGER(aCoder, orientation);
     ORK_ENCODE_DOUBLE(aCoder, start);
     ORK_ENCODE_DOUBLE(aCoder, finish);
     ORK_ENCODE_DOUBLE(aCoder, minimum);
@@ -49,6 +50,7 @@ - (void)encodeWithCoder:(NSCoder *)aCoder {
 - (id)initWithCoder:(NSCoder *)aDecoder {
     self = [super initWithCoder:aDecoder];
     if (self) {
+        ORK_DECODE_INTEGER(aDecoder, orientation);
         ORK_DECODE_DOUBLE(aDecoder, start);
         ORK_DECODE_DOUBLE(aDecoder, finish);
         ORK_DECODE_DOUBLE(aDecoder, minimum);
@@ -66,6 +68,7 @@ - (BOOL)isEqual:(id)object {
     BOOL isParentSame = [super isEqual:object];
     __typeof(self) castObject = object;
     return isParentSame &&
+    self.orientation == castObject.orientation &&
     self.start == castObject.start &&
     self.finish == castObject.finish &&
     self.minimum == castObject.minimum &&
@@ -79,6 +82,7 @@ - (NSUInteger)hash {
 
 - (instancetype)copyWithZone:(NSZone *)zone {
     ORKRangeOfMotionResult *result = [super copyWithZone:zone];
+    result.orientation = self.orientation;
     result.start = self.start;
     result.finish = self.finish;
     result.minimum = self.minimum;
@@ -88,7 +92,7 @@ - (instancetype)copyWithZone:(NSZone *)zone {
 }
 
 - (NSString *)descriptionWithNumberOfPaddingSpaces:(NSUInteger)numberOfPaddingSpaces {
-    return [NSString stringWithFormat:@"<%@: start: %f; finish: %f; minimum: %f; maximum: %f; range: %f>", self.class.description, self.start, self.finish, self.minimum, self.maximum, self.range];
+    return [NSString stringWithFormat:@"<%@: orientation: %li; start: %f; finish: %f; minimum: %f; maximum: %f; range: %f>", self.class.description, self.orientation, self.start, self.finish, self.minimum, self.maximum, self.range];
 }
 
 @end

ResearchKit/ActiveTasks/ORKRangeOfMotionStepViewController.h

@@ -41,6 +41,7 @@ NS_ASSUME_NONNULL_BEGIN
  */
 ORK_CLASS_AVAILABLE
 @interface ORKRangeOfMotionStepViewController : ORKActiveStepViewController {
+    UIDeviceOrientation _orientation;
     double _startAngle;
     double _newAngle;
     double _minAngle;

ResearchKit/ActiveTasks/ORKRangeOfMotionStepViewController.m

@@ -1,5 +1,6 @@
 /*
  Copyright (c) 2016, Darren Levy. All rights reserved.
+ Copyright (c) 2020, David W. Evans. All rights reserved.
 
  Redistribution and use in source and binary forms, with or without modification,
  are permitted provided that the following conditions are met:
@@ -124,7 +125,6 @@ @interface ORKRangeOfMotionStepViewController () <ORKDeviceMotionRecorderDelegat
     ORKRangeOfMotionContentView *_contentView;
     UITapGestureRecognizer *_gestureRecognizer;
     CMAttitude *_referenceAttitude;
-    UIInterfaceOrientation _orientation;
 }
 
 @end
@@ -134,13 +134,29 @@ @implementation ORKRangeOfMotionStepViewController
 
 - (void)viewDidLoad {
     [super viewDidLoad];
+
     _contentView = [ORKRangeOfMotionContentView new];
     _contentView.translatesAutoresizingMaskIntoConstraints = NO;
     self.activeStepView.activeCustomView = _contentView;
     _gestureRecognizer = [[UITapGestureRecognizer alloc] initWithTarget:self action:@selector(handleTap:)];
     [self.activeStepView addGestureRecognizer:_gestureRecognizer];
+
+     // Initiate orientation notifications
+    [[UIDevice currentDevice] beginGeneratingDeviceOrientationNotifications];
+    _orientation = [[UIDevice currentDevice] orientation]; // captures the initial device orientation
+}
+
+- (void)viewWillDisappear:(BOOL)animated {
+    [super viewWillDisappear:animated];
+
+    // Ends orientation notifications
+    [[NSNotificationCenter defaultCenter] removeObserver:self];
+    if ([[UIDevice currentDevice] isGeneratingDeviceOrientationNotifications]) {
+        [[UIDevice currentDevice] endGeneratingDeviceOrientationNotifications];
+    }
 }
-    //This function records the angle of the device when the screen is tapped
+
+   //Records the angle of the device when the screen is tapped
 - (void)handleTap:(UIGestureRecognizer *)sender {
     [self calculateAndSetAngles];
     [self finish];
@@ -149,56 +165,74 @@ - (void)handleTap:(UIGestureRecognizer *)sender {
 - (void)calculateAndSetAngles {
     _startAngle = ([self getDeviceAngleInDegreesFromAttitude:_referenceAttitude]);
 
-    //This function calculates maximum and minimum angles recorded by the device
+    // Calculate maximum and minimum angles recorded by the device
     if (_newAngle > _maxAngle) {
         _maxAngle = _newAngle;
     }
-    if (_minAngle == 0.0 || _newAngle < _minAngle) {
+    if (_newAngle < _minAngle) {
         _minAngle = _newAngle;
     }
 }
 
+
 #pragma mark - ORKDeviceMotionRecorderDelegate
 
 - (void)deviceMotionRecorderDidUpdateWithMotion:(CMDeviceMotion *)motion {
     if (!_referenceAttitude) {
         _referenceAttitude = motion.attitude;
     }
     CMAttitude *currentAttitude = [motion.attitude copy];
-
     [currentAttitude multiplyByInverseOfAttitude:_referenceAttitude];
 
     double angle = [self getDeviceAngleInDegreesFromAttitude:currentAttitude];
 
-    //This function shifts the range of angles reported by the device from +/-180 degrees to -90 to +270 degrees, which should be sufficient to cover all ahievable knee and shoulder ranges of motion
-    BOOL shiftAngleRange = angle > 90 && angle <= 180;
-    if (shiftAngleRange) {
-        _newAngle = fabs(angle) - 360;
-    } else {
-        _newAngle = angle;
+    //These shift the range of angles reported by the device from +/-180 degrees to -90 to +270 degrees, which should be sufficient to cover all ahievable knee and shoulder ranges of motion
+    if (UIDeviceOrientationLandscapeLeft == _orientation) {
+        BOOL shiftAngleRange = angle < -90 && angle >= -180;
+        if (shiftAngleRange) {
+            _newAngle = 360 - fabs(angle);
+        } else {
+            _newAngle = angle;
+        }
+    } else if (UIDeviceOrientationPortrait == _orientation) {
+        BOOL shiftAngleRange = angle > 90 && angle <= 180;
+        if (shiftAngleRange) {
+            _newAngle = fabs(angle) - 360;
+        } else {
+            _newAngle = angle;
+        }
+    } else if (UIDeviceOrientationLandscapeRight == _orientation) {
+        BOOL shiftAngleRange = angle > 90 && angle <= 180;
+        if (shiftAngleRange) {
+            _newAngle = fabs(angle) - 360;
+        } else {
+            _newAngle = angle;
+        }
+    } else if (UIDeviceOrientationPortraitUpsideDown == _orientation) {
+       BOOL shiftAngleRange = angle < -90 && angle >= -180;
+       if (shiftAngleRange) {
+           _newAngle = 360 - fabs(angle);
+       } else {
+           _newAngle = angle;
+       }
     }
-
     [self calculateAndSetAngles];
 }
 
 /*
- When the device is in Portrait mode, we need to get the attitude's pitch
- to determine the device's angle. attitude.pitch doesn't return all
- orientations, so we use the attitude's quaternion to calculate the
- angle.
+ When the device is in Portrait mode, we need to get the attitude's pitch to determine the device's
+ angle; whereas, when the device is in Landscape, we need the attitude's roll. We can use the
+ quaternion that represents the device's attitude to calculate the angle around each axis.
  */
 - (double)getDeviceAngleInDegreesFromAttitude:(CMAttitude *)attitude {
-    if (!_orientation) {
-        _orientation = [UIApplication sharedApplication].statusBarOrientation;
-    }
-    double angle;
-    if (UIInterfaceOrientationIsLandscape(_orientation)) {
+    double angle = 0.0;
+    if (UIDeviceOrientationIsLandscape(_orientation)) {
         double x = attitude.quaternion.x;
         double w = attitude.quaternion.w;
         double y = attitude.quaternion.y;
         double z = attitude.quaternion.z;
         angle = radiansToDegrees(allOrientationsForRoll(x, w, y, z));
-    } else {
+    } else if (UIDeviceOrientationIsPortrait(_orientation)) {
         double x = attitude.quaternion.x;
         double w = attitude.quaternion.w;
         double y = attitude.quaternion.y;
@@ -216,13 +250,51 @@ - (ORKResult *)result {
 
     ORKRangeOfMotionResult *result = [[ORKRangeOfMotionResult alloc] initWithIdentifier:self.step.identifier];
 
-    result.start = 90.0 - _startAngle;
-    result.finish = result.start - _newAngle;
-    //Because the task uses pitch in the direction opposite to the original CoreMotion device axes (i.e. right hand rule), maximum and minimum angles are reported the 'wrong' way around for the knee and shoulder tasks
-    result.minimum = result.start - _maxAngle;
-    result.maximum = result.start - _minAngle;
-    result.range = fabs(result.maximum - result.minimum);
+    int ORIENTATION_UNSPECIFIED = -1;
+    int ORIENTATION_LANDSCAPE_LEFT = 0; // equivalent to LANDSCAPE in Android
+    int ORIENTATION_PORTRAIT = 1;
+    int ORIENTATION_LANDSCAPE_RIGHT = 2; // equivalent to REVERSE_LANDSCAPE in Android
+    int ORIENTATION_PORTRAIT_UPSIDE_DOWN = 3;  // equivalent to REVERSE_PORTRAIT in Android
 
+    if (UIDeviceOrientationLandscapeLeft == _orientation) {
+        result.orientation = ORIENTATION_LANDSCAPE_LEFT;
+        result.start = 90.0 + _startAngle;
+        result.finish = result.start + _newAngle;
+        result.minimum = result.start + _minAngle;
+        result.maximum = result.start + _maxAngle;
+        result.range = fabs(result.maximum - result.minimum);
+    } else if (UIDeviceOrientationPortrait == _orientation) {
+        result.orientation = ORIENTATION_PORTRAIT;
+        result.start = 90.0 - _startAngle;
+        result.finish = result.start - _newAngle;
+    // In Portrait device orientation, the task uses pitch in the direction opposite to the original CoreMotion device axes (i.e. right hand rule). Therefore, maximum and minimum angles are reported the 'wrong' way around for the knee and shoulder tasks.
+        result.minimum = result.start - _maxAngle;
+        result.maximum = result.start - _minAngle;
+        result.range = fabs(result.maximum - result.minimum);
+    } else if (UIDeviceOrientationLandscapeRight == _orientation) {
+        result.orientation = ORIENTATION_LANDSCAPE_RIGHT;
+        result.start = 90.0 - _startAngle;
+        result.finish = result.start - _newAngle;
+    // In Landscape Right device orientation, the task uses roll in the direction opposite to the original CoreMotion device axes.
+        result.minimum = result.start - _maxAngle;
+        result.maximum = result.start - _minAngle;
+        result.range = fabs(result.maximum - result.minimum);
+    } else if (UIDeviceOrientationPortraitUpsideDown == _orientation) {
+        result.orientation = ORIENTATION_PORTRAIT_UPSIDE_DOWN;
+        result.start = -90 - _startAngle;
+        result.finish = result.start + _newAngle;
+        result.minimum = result.start + _minAngle;
+        result.maximum = result.start + _maxAngle;
+        result.range = fabs(result.maximum - result.minimum);
+    } else if (!UIDeviceOrientationIsValidInterfaceOrientation(_orientation)) {
+        result.orientation = ORIENTATION_UNSPECIFIED;
+        result.start = NAN;
+        result.finish = NAN;
+        result.minimum = NAN;
+        result.maximum = NAN;
+        result.range = NAN;
+    }
+
     stepResult.results = [self.addedResults arrayByAddingObject:result] ? : @[result];
 
     return stepResult;

ResearchKit/ActiveTasks/ORKShoulderRangeOfMotionStepViewController.m

@@ -1,5 +1,6 @@
 /*
  Copyright (c) 2016, Darren Levy. All rights reserved.
+ Copyright (c) 2020, David W. Evans. All rights reserved.
 
  Redistribution and use in source and binary forms, with or without modification,
  are permitted provided that the following conditions are met:
@@ -35,21 +36,61 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 #import "ORKStepViewController_Internal.h"
 
 
-@implementation ORKShoulderRangeOfMotionStepViewController
+@implementation ORKShoulderRangeOfMotionStepViewController: ORKRangeOfMotionStepViewController
 
 #pragma mark - ORKActiveTaskViewController
 
 - (ORKResult *)result {
     ORKStepResult *stepResult = [super result];
 
     ORKRangeOfMotionResult *result = [[ORKRangeOfMotionResult alloc] initWithIdentifier:self.step.identifier];
-    result.start = 90.0 - _startAngle;
-    result.finish = result.start - _newAngle;
-    //Because the task uses pitch in the direction opposite to the original CoreMotion device axes (i.e. right hand rule), maximum and minimum angles are reported the 'wrong' way around for the knee and shoulder tasks
-    result.minimum = result.start - _maxAngle;
-    result.maximum = result.start - _minAngle;
-    result.range = fabs(result.maximum - result.minimum);
-
+
+    int ORIENTATION_UNSPECIFIED = -1;
+    int ORIENTATION_LANDSCAPE_LEFT = 0; // equivalent to LANDSCAPE in Android
+    int ORIENTATION_PORTRAIT = 1;
+    int ORIENTATION_LANDSCAPE_RIGHT = 2; // equivalent to REVERSE_LANDSCAPE in Android
+    int ORIENTATION_PORTRAIT_UPSIDE_DOWN = 3;  // equivalent to REVERSE_PORTRAIT in Android
+
+    if (UIDeviceOrientationLandscapeLeft == _orientation) {
+        result.orientation = ORIENTATION_LANDSCAPE_LEFT;
+        result.start = 90.0 + _startAngle;
+        result.finish = result.start + _newAngle;
+        result.minimum = result.start + _minAngle;
+        result.maximum = result.start + _maxAngle;
+        result.range = fabs(result.maximum - result.minimum);
+    } else if (UIDeviceOrientationPortrait == _orientation) {
+        result.orientation = ORIENTATION_PORTRAIT;
+        result.start = 90.0 - _startAngle;
+        result.finish = result.start - _newAngle;
+    // In Portrait device orientation, the task uses pitch in the direction opposite to the original CoreMotion device axes (i.e. right hand rule). Therefore, maximum and minimum angles are reported the 'wrong' way around for the knee and shoulder tasks.
+        result.minimum = result.start - _maxAngle;
+        result.maximum = result.start - _minAngle;
+        result.range = fabs(result.maximum - result.minimum);
+    } else if (UIDeviceOrientationLandscapeRight == _orientation) {
+        result.orientation = ORIENTATION_LANDSCAPE_RIGHT;
+        result.start = 90.0 - _startAngle;
+        result.finish = result.start - _newAngle;
+    // In Landscape Right device orientation, the task uses roll in the direction opposite to the original CoreMotion device axes.
+        result.minimum = result.start - _maxAngle;
+        result.maximum = result.start - _minAngle;
+        result.range = fabs(result.maximum - result.minimum);
+    } else if (UIDeviceOrientationPortraitUpsideDown == _orientation) {
+        result.orientation = ORIENTATION_PORTRAIT_UPSIDE_DOWN;
+        result.start = -90 - _startAngle;
+        result.finish = result.start + _newAngle;
+        result.minimum = result.start + _minAngle;
+        result.maximum = result.start + _maxAngle;
+        result.range = fabs(result.maximum - result.minimum);
+    //} else if (UIDeviceOrientationFaceUp == _orientation || UIDeviceOrientationFaceDown == _orientation) {
+    } else if (!UIDeviceOrientationIsValidInterfaceOrientation(_orientation)) {
+        result.orientation = ORIENTATION_UNSPECIFIED;
+        result.start = NAN;
+        result.finish = NAN;
+        result.minimum = NAN;
+        result.maximum = NAN;
+        result.range = NAN;
+    }
+
     stepResult.results = [self.addedResults arrayByAddingObject:result] ? : @[result];
 
     return stepResult;

samples/ORKCatalog/ORKCatalog/Results/ResultTableViewProviders.swift

@@ -200,7 +200,7 @@ enum ResultRow {
         storyboard.
     */
     enum TableViewCellIdentifier: String {
-        case `default` =          "Default"
+        case `default` =        "Default"
         case noResultSet =      "NoResultSet"
         case noChildResults =   "NoChildResults"
         case textImage =        "TextImage"
@@ -958,6 +958,7 @@ class RangeOfMotionResultTableViewProvider: ResultTableViewProvider {
         let rangeOfMotionResult = result as! ORKRangeOfMotionResult
         let rows = super.resultRowsForSection(section)
         return rows + [
+            ResultRow(text: "orientation", detail: rangeOfMotionResult.orientation),
             ResultRow(text: "start", detail: rangeOfMotionResult.start),
             ResultRow(text: "finish", detail: rangeOfMotionResult.finish),
             ResultRow(text: "minimum", detail: rangeOfMotionResult.minimum),