[Sensor] Add uncalibrated gyroscope and geomagnetic sensor types

Change-Id: Ideac79341070ce075fec3d3baa509c88dbd117a2
Signed-off-by: Pawel Wasowski <p.wasowski2@partner.samsung.com>

diff --git a/src/sensor/sensor_api.js b/src/sensor/sensor_api.js
index f30b58da93d79b38f05e765323c7a85d7ef57f2b..fec5ed52b56c35f2917cbe27ff615c7326e9de49 100755 (executable)
--- a/src/sensor/sensor_api.js
+++ b/src/sensor/sensor_api.js
@@ -33,7 +33,9 @@ var SensorType = {
     GRAVITY : 'GRAVITY',
     GYROSCOPE : 'GYROSCOPE',
     GYROSCOPE_ROTATION_VECTOR : 'GYROSCOPE_ROTATION_VECTOR',
-    LINEAR_ACCELERATION : 'LINEAR_ACCELERATION'
+    LINEAR_ACCELERATION : 'LINEAR_ACCELERATION',
+    MAGNETIC_UNCALIBRATED : 'MAGNETIC_UNCALIBRATED',
+    GYROSCOPE_UNCALIBRATED : 'GYROSCOPE_UNCALIBRATED'
 };
 
 var ProximityState = {
@@ -157,7 +159,9 @@ var _sensorListeners = {
     'GRAVITY'     : {},
     'GYROSCOPE'   : {},
     'GYROSCOPE_ROTATION_VECTOR' : {},
-    'LINEAR_ACCELERATION' : {}
+    'LINEAR_ACCELERATION' : {},
+    'MAGNETIC_UNCALIBRATED' : {},
+    'GYROSCOPE_UNCALIBRATED' : {}
 };
 
 var _listener = function(object) {
@@ -216,6 +220,10 @@ function getDefaultSensor() {
         return new GyroscopeRotationVectorSensor();
     } else if (_supportedSensors[index] === SensorType.LINEAR_ACCELERATION){
         return new LinearAccelerationSensor();
+    } else if (_supportedSensors[index] === SensorType.MAGNETIC_UNCALIBRATED) {
+        return new MagneticUncalibratedSensor();
+    } else if (_supportedSensors[index] === SensorType.GYROSCOPE_UNCALIBRATED) {
+       return new GyroscopeUncalibratedSensor();
     }
 };
 
@@ -616,6 +624,71 @@ LinearAccelerationSensor.prototype.getLinearAccelerationSensorData = function()
     _sensorListeners[this.sensorType].getData(args.successCallback, errorWrapper);
 };
 
+//// MagneticUncalibratedSensor
+var MagneticUncalibratedSensor = function(data) {
+    Sensor.call(this, SensorType.MAGNETIC_UNCALIBRATED);
+};
+
+MagneticUncalibratedSensor.prototype = new Sensor();
+
+MagneticUncalibratedSensor.prototype.constructor = new Sensor;
+
+MagneticUncalibratedSensor.prototype.getMagneticUncalibratedSensorData = function() {
+    var args = validator_.validateArgs(arguments, [
+        {
+            name : 'successCallback',
+            type : types_.FUNCTION
+        },
+        {
+            name : 'errorCallback',
+            type : types_.FUNCTION,
+            optional : true,
+            nullable : true
+        }
+    ]);
+
+    function errorWrapper(err) {
+        if (err.name === "UnknownError") {
+            args.errorCallback(new WebAPIException(WebAPIException.ABORT_ERR, err.message));
+        } else {
+            args.errorCallback(err);
+        }
+    }
+    _sensorListeners[this.sensorType].getData(args.successCallback, errorWrapper);
+}
+
+//// GyroscopeUncalibratedSensor
+var GyroscopeUncalibratedSensor = function(data) {
+    Sensor.call(this, SensorType.GYROSCOPE_UNCALIBRATED);
+};
+
+GyroscopeUncalibratedSensor.prototype = new Sensor();
+
+GyroscopeUncalibratedSensor.prototype.constructor = new Sensor;
+
+GyroscopeUncalibratedSensor.prototype.getGyroscopeUncalibratedSensorData = function() {
+    var args = validator_.validateArgs(arguments, [
+        {
+            name : 'successCallback',
+            type : types_.FUNCTION
+        },
+        {
+            name : 'errorCallback',
+            type : types_.FUNCTION,
+            optional : true,
+            nullable : true
+        }
+    ]);
+
+    function errorWrapper(err) {
+        if (err.name === "UnknownError") {
+            args.errorCallback(new WebAPIException(WebAPIException.ABORT_ERR, err.message));
+        } else {
+            args.errorCallback(err);
+        }
+    }
+    _sensorListeners[this.sensorType].getData(args.successCallback, errorWrapper);
+}
 
 ////////////////////// Sensor Data classes/////////////////////////////////////////////////////
 ////Base SensorData class
@@ -787,6 +860,46 @@ SensorLinearAccelerationData.prototype.constructor = SensorData;
 _sensorListeners[SensorType.LINEAR_ACCELERATION] = new SensorListener(SensorType.LINEAR_ACCELERATION,
         SensorLinearAccelerationData);
 
+//// SensorMagneticUncalibratedData
+var SensorMagneticUncalibratedData = function(data) {
+    SensorData.call(this);
+    Object.defineProperties(this, {
+        x : {value: data.x, writable: false, enumerable: true},
+        y : {value: data.y, writable: false, enumerable: true},
+        z : {value: data.z, writable: false, enumerable: true},
+        xAxisBias : {value: data.xAxisBias, writable: false, enumerable: true},
+        yAxisBias : {value: data.yAxisBias, writable: false, enumerable: true},
+        zAxisBias : {value: data.zAxisBias, writable: false, enumerable: true}
+    });
+};
+
+SensorMagneticUncalibratedData.prototype = new SensorData();
+
+SensorMagneticUncalibratedData.prototype.constructor = SensorData;
+
+_sensorListeners[SensorType.MAGNETIC_UNCALIBRATED] = new SensorListener(SensorType.MAGNETIC_UNCALIBRATED,
+    SensorMagneticUncalibratedData);
+
+//// SensorGyroscopeUncalibratedData
+var SensorGyroscopeUncalibratedData = function(data) {
+    SensorData.call(this);
+    Object.defineProperties(this, {
+        x : {value: data.x, writable: false, enumerable: true},
+        y : {value: data.y, writable: false, enumerable: true},
+        z : {value: data.z, writable: false, enumerable: true},
+        xAxisDrift : {value: data.xAxisDrift, writable: false, enumerable: true},
+        yAxisDrift : {value: data.yAxisDrift, writable: false, enumerable: true},
+        zAxisDrift : {value: data.zAxisDrift, writable: false, enumerable: true}
+    });
+
+};
+
+SensorGyroscopeUncalibratedData.prototype = new SensorData();
+
+SensorGyroscopeUncalibratedData.prototype.constructor = SensorData;
+
+_sensorListeners[SensorType.GYROSCOPE_UNCALIBRATED] = new SensorListener(SensorType.GYROSCOPE_UNCALIBRATED,
+    SensorGyroscopeUncalibratedData);
 
 //////////////////////SensorHardwareInfo classes//////////////////////////////////////////////////////////
 function SensorHardwareInfo(data) {

diff --git a/src/sensor/sensor_service.cc b/src/sensor/sensor_service.cc
index ae76ba086c661487a818a23958dcf41ae37915bd..09206ef16ff64ed5f912f641f3412c8d89d8d80c 100755 (executable)
--- a/src/sensor/sensor_service.cc
+++ b/src/sensor/sensor_service.cc
@@ -128,6 +128,24 @@ void ReportSensorData(sensor_type_e sensor_type, sensor_event_s* sensor_event,
       (*out)["z"] = picojson::value(static_cast<double>(sensor_event->values[2]));
       break;
     }
+    case SENSOR_GEOMAGNETIC_UNCALIBRATED: {
+      (*out)["x"] = picojson::value(static_cast<double>(sensor_event->values[0]));
+      (*out)["y"] = picojson::value(static_cast<double>(sensor_event->values[1]));
+      (*out)["z"] = picojson::value(static_cast<double>(sensor_event->values[2]));
+      (*out)["xAxisBias"] = picojson::value(static_cast<double>(sensor_event->values[3]));
+      (*out)["yAxisBias"] = picojson::value(static_cast<double>(sensor_event->values[4]));
+      (*out)["zAxisBias"] = picojson::value(static_cast<double>(sensor_event->values[5]));
+      break;
+    }
+    case SENSOR_GYROSCOPE_UNCALIBRATED: {
+      (*out)["x"] = picojson::value(static_cast<double>(sensor_event->values[0]));
+      (*out)["y"] = picojson::value(static_cast<double>(sensor_event->values[1]));
+      (*out)["z"] = picojson::value(static_cast<double>(sensor_event->values[2]));
+      (*out)["xAxisDrift"] = picojson::value(static_cast<double>(sensor_event->values[3]));
+      (*out)["yAxisDrift"] = picojson::value(static_cast<double>(sensor_event->values[4]));
+      (*out)["zAxisDrift"] = picojson::value(static_cast<double>(sensor_event->values[5]));
+      break;
+    }
     default: {
       LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unsupported type"), out);
       return;
@@ -706,6 +724,8 @@ SensorService::SensorService(SensorInstance& instance)
   AddSensor(new SensorData(instance, SENSOR_GYROSCOPE, "GYROSCOPE"));
   AddSensor(new SensorData(instance, SENSOR_GYROSCOPE_ROTATION_VECTOR, "GYROSCOPE_ROTATION_VECTOR"));
   AddSensor(new SensorData(instance, SENSOR_LINEAR_ACCELERATION, "LINEAR_ACCELERATION"));
+  AddSensor(new SensorData(instance, SENSOR_GEOMAGNETIC_UNCALIBRATED, "MAGNETIC_UNCALIBRATED"));
+  AddSensor(new SensorData(instance, SENSOR_GYROSCOPE_UNCALIBRATED, "GYROSCOPE_UNCALIBRATED"));
 }
 
 SensorService::~SensorService() {