Merge branch 'tizen_4.0' into tizen_5.0

[platform/core/api/webapi-plugins.git] / src / sensor / sensor_api.js

diff --git a/src/sensor/sensor_api.js b/src/sensor/sensor_api.js
index 41c744e..f3380ef 100755 (executable)
--- a/src/sensor/sensor_api.js
+++ b/src/sensor/sensor_api.js
@@ -24,43 +24,42 @@ var native_ = new utils_.NativeManager(extension);
 
 // Enums
 var SensorType = {
-    LIGHT : 'LIGHT',
-    MAGNETIC : 'MAGNETIC',
-    PRESSURE : 'PRESSURE',
-    PROXIMITY : 'PROXIMITY',
-    ULTRAVIOLET : 'ULTRAVIOLET',
-    HRM_RAW : 'HRM_RAW',
-    GRAVITY : 'GRAVITY',
-    GYROSCOPE : 'GYROSCOPE',
-    GYROSCOPE_ROTATION_VECTOR : 'GYROSCOPE_ROTATION_VECTOR',
-    LINEAR_ACCELERATION : 'LINEAR_ACCELERATION',
-    MAGNETIC_UNCALIBRATED : 'MAGNETIC_UNCALIBRATED',
-    GYROSCOPE_UNCALIBRATED : 'GYROSCOPE_UNCALIBRATED',
-    ACCELERATION : 'ACCELERATION'
+    LIGHT: 'LIGHT',
+    MAGNETIC: 'MAGNETIC',
+    PRESSURE: 'PRESSURE',
+    PROXIMITY: 'PROXIMITY',
+    ULTRAVIOLET: 'ULTRAVIOLET',
+    HRM_RAW: 'HRM_RAW',
+    GRAVITY: 'GRAVITY',
+    GYROSCOPE: 'GYROSCOPE',
+    GYROSCOPE_ROTATION_VECTOR: 'GYROSCOPE_ROTATION_VECTOR',
+    LINEAR_ACCELERATION: 'LINEAR_ACCELERATION',
+    MAGNETIC_UNCALIBRATED: 'MAGNETIC_UNCALIBRATED',
+    GYROSCOPE_UNCALIBRATED: 'GYROSCOPE_UNCALIBRATED',
+    ACCELERATION: 'ACCELERATION'
 };
 
 var ProximityState = {
-    FAR : 'FAR',
-    NEAR : 'NEAR'
+    FAR: 'FAR',
+    NEAR: 'NEAR'
 };
 
 var MagneticSensorAccuracy = {
-    UNDEFINED : 'ACCURACY_UNDEFINED',
-    BAD : 'ACCURACY_BAD',
-    NORMAL : 'ACCURACY_NORMAL',
-    GOOD : 'ACCURACY_GOOD',
-    VERYGOOD : 'ACCURACY_VERYGOOD'
+    UNDEFINED: 'ACCURACY_UNDEFINED',
+    BAD: 'ACCURACY_BAD',
+    NORMAL: 'ACCURACY_NORMAL',
+    GOOD: 'ACCURACY_GOOD',
+    VERYGOOD: 'ACCURACY_VERYGOOD'
 };
 
 var SensorStates = {
-    NOT_STARTED : 0,
-    STARTING : 1,
-    STARTED : 2
+    NOT_STARTED: 0,
+    STARTING: 1,
+    STARTED: 2
 };
 
-
 // helper class for sensor listeners
-var SensorListener = function (type, constructor) {
+var SensorListener = function(type, constructor) {
     this.sensorType = type;
     this.state = SensorStates.NOT_STARTED;
     this.callback = undefined;
@@ -69,39 +68,41 @@ var SensorListener = function (type, constructor) {
     this.constructor = constructor;
 };
 
-SensorListener.prototype.tryCall = function (object) {
+SensorListener.prototype.tryCall = function(object) {
     if (this.callback) {
         this.callback(new this.constructor(object));
     }
 };
 
-SensorListener.prototype.start = function (successCallback, errorCallback) {
+SensorListener.prototype.start = function(successCallback, errorCallback) {
     if (SensorStates.STARTED != this.state) {
         // sensor not started
         this.state = SensorStates.STARTING;
         var thisObject = this;
-        native_.call('Sensor_start', {'sensorType' : thisObject.sensorType},
-                function(result) {
-                    if (native_.isFailure(result)) {
-                        thisObject.state = SensorStates.NOT_STARTED;
-                        if (!T_.isNullOrUndefined(errorCallback)) {
-                            errorCallback(native_.getErrorObject(result));
-                        }
-                    } else {
-                        thisObject.state = SensorStates.STARTED;
-                        successCallback();
-                    }
+        native_.call('Sensor_start', { sensorType: thisObject.sensorType }, function(
+            result
+        ) {
+            if (native_.isFailure(result)) {
+                thisObject.state = SensorStates.NOT_STARTED;
+                if (!T_.isNullOrUndefined(errorCallback)) {
+                    errorCallback(native_.getErrorObject(result));
                 }
-        );
+            } else {
+                thisObject.state = SensorStates.STARTED;
+                successCallback();
+            }
+        });
     } else {
         // sensor is already started - just call success callback
-        setTimeout(function(){successCallback()}, 0);
+        setTimeout(function() {
+            successCallback();
+        }, 0);
     }
 };
 
-SensorListener.prototype.stop = function () {
+SensorListener.prototype.stop = function() {
     if (SensorStates.NOT_STARTED != this.state) {
-        var result = native_.callSync('Sensor_stop', {'sensorType' : this.sensorType});
+        var result = native_.callSync('Sensor_stop', { sensorType: this.sensorType });
         if (native_.isFailure(result)) {
             throw native_.getErrorObject(result);
         }
@@ -109,14 +110,18 @@ SensorListener.prototype.stop = function () {
     }
 };
 
-SensorListener.prototype.setListener = function (successCallback, interval, batchLatency) {
-    if (!this.callback || this.callbackInterval != interval ||
-        this.callbackBatchLatency != batchLatency) {
+SensorListener.prototype.setListener = function(successCallback, interval, batchLatency) {
+    if (
+        !this.callback ||
+        this.callbackInterval != interval ||
+        this.callbackBatchLatency != batchLatency
+    ) {
         //call platform only if there was no listener registered or parameters changed
         var result = native_.callSync('Sensor_setChangeListener', {
-            'sensorType' : this.sensorType,
-            'interval' : interval,
-            'batchLatency' : batchLatency});
+            sensorType: this.sensorType,
+            interval: interval,
+            batchLatency: batchLatency
+        });
 
         if (native_.isFailure(result)) {
             throw native_.getErrorObject(result);
@@ -127,30 +132,34 @@ SensorListener.prototype.setListener = function (successCallback, interval, batc
     this.callback = successCallback;
 };
 
-SensorListener.prototype.unsetListener = function () {
+SensorListener.prototype.unsetListener = function() {
     if (this.callback) {
         //unregister in platform only if there is callback registered
         this.callback = undefined;
-        var result = native_.callSync('Sensor_unsetChangeListener', {'sensorType' : this.sensorType});
+        var result = native_.callSync('Sensor_unsetChangeListener', {
+            sensorType: this.sensorType
+        });
         if (native_.isFailure(result)) {
             throw native_.getErrorObject(result);
         }
     }
 };
 
-SensorListener.prototype.getData = function (successCallback, errorCallback) {
+SensorListener.prototype.getData = function(successCallback, errorCallback) {
     var thisObj = this;
     if (SensorStates.STARTED != this.state) {
         setTimeout(function() {
             if (!T_.isNullOrUndefined(errorCallback)) {
-                errorCallback(new WebAPIException(
+                errorCallback(
+                    new WebAPIException(
                         WebAPIException.SERVICE_NOT_AVAILABLE_ERR,
-                        'Service is not available.'));
+                        'Service is not available.'
+                    )
+                );
             }
         }, 0);
     } else {
-        native_.call('Sensor_getData', { type : thisObj.sensorType },
-                function(result) {
+        native_.call('Sensor_getData', { type: thisObj.sensorType }, function(result) {
             if (native_.isFailure(result)) {
                 if (!T_.isNullOrUndefined(errorCallback)) {
                     errorCallback(native_.getErrorObject(result));
@@ -165,23 +174,23 @@ SensorListener.prototype.getData = function (successCallback, errorCallback) {
 var _supportedSensors = [];
 var _isChecked = false;
 var _sensorListeners = {
-    'LIGHT'       : {},
-    'MAGNETIC'    : {},
-    'PRESSURE'    : {},
-    'PROXIMITY'   : {},
-    'ULTRAVIOLET' : {},
-    'HRM_RAW'     : {},
-    'GRAVITY'     : {},
-    'GYROSCOPE'   : {},
-    'GYROSCOPE_ROTATION_VECTOR' : {},
-    'LINEAR_ACCELERATION' : {},
-    'MAGNETIC_UNCALIBRATED' : {},
-    'GYROSCOPE_UNCALIBRATED' : {},
-    'ACCELERATION' : {}
-};
-
-var errorWrapper = function (err) {
-    if(err.name === "UnknownError") {
+    LIGHT: {},
+    MAGNETIC: {},
+    PRESSURE: {},
+    PROXIMITY: {},
+    ULTRAVIOLET: {},
+    HRM_RAW: {},
+    GRAVITY: {},
+    GYROSCOPE: {},
+    GYROSCOPE_ROTATION_VECTOR: {},
+    LINEAR_ACCELERATION: {},
+    MAGNETIC_UNCALIBRATED: {},
+    GYROSCOPE_UNCALIBRATED: {},
+    ACCELERATION: {}
+};
+
+var errorWrapper = function(err) {
+    if (err.name === 'UnknownError') {
         err = new WebAPIException(WebAPIException.ABORT_ERR, err.message);
     }
 
@@ -189,7 +198,7 @@ var errorWrapper = function (err) {
 };
 
 var _listener = function(object) {
-    if (object.sensorType.substring(0,4) === 'LED_') {
+    if (object.sensorType.substring(0, 4) === 'LED_') {
         object.sensorType = 'HRM_RAW';
     }
     _sensorListeners[object.sensorType].tryCall(object);
@@ -207,15 +216,14 @@ function getAvailableSensors() {
     _isChecked = true;
 }
 
-function SensorService() {
-};
+function SensorService() {}
 
 function getDefaultSensor() {
     var args = validator_.validateArgs(arguments, [
         {
-            name : 'type',
-            type : types_.ENUM,
-            values : T_.getValues(SensorType)
+            name: 'type',
+            type: types_.ENUM,
+            values: T_.getValues(SensorType)
         }
     ]);
 
@@ -241,11 +249,11 @@ function getDefaultSensor() {
         return new HRMRawSensor();
     } else if (_supportedSensors[index] === SensorType.GRAVITY) {
         return new GravitySensor();
-    } else if (_supportedSensors[index] === SensorType.GYROSCOPE){
+    } else if (_supportedSensors[index] === SensorType.GYROSCOPE) {
         return new GyroscopeSensor();
-    } else if (_supportedSensors[index] === SensorType.GYROSCOPE_ROTATION_VECTOR){
+    } else if (_supportedSensors[index] === SensorType.GYROSCOPE_ROTATION_VECTOR) {
         return new GyroscopeRotationVectorSensor();
-    } else if (_supportedSensors[index] === SensorType.LINEAR_ACCELERATION){
+    } else if (_supportedSensors[index] === SensorType.LINEAR_ACCELERATION) {
         return new LinearAccelerationSensor();
     } else if (_supportedSensors[index] === SensorType.MAGNETIC_UNCALIBRATED) {
         return new MagneticUncalibratedSensor();
@@ -254,10 +262,10 @@ function getDefaultSensor() {
     } else if (_supportedSensors[index] === SensorType.ACCELERATION) {
         return new AccelerationSensor();
     }
-};
+}
 
 SensorService.prototype.getDefaultSensor = function() {
-  return getDefaultSensor.apply(this, arguments);
+    return getDefaultSensor.apply(this, arguments);
 };
 
 SensorService.prototype.getAvailableSensors = function() {
@@ -268,26 +276,26 @@ SensorService.prototype.getAvailableSensors = function() {
     return _supportedSensors.slice();
 };
 
-//////////////////////Sensor classes//////////////////////////////////////////////////////////
+//////////////////////Sensor classes/////////////////////////////
 //// Base Sensor class
-var Sensor = function (type) {
+var Sensor = function(type) {
     Object.defineProperties(this, {
-        sensorType : {value: type, writable: false, enumerable: true}
+        sensorType: { value: type, writable: false, enumerable: true }
     });
 };
 
 Sensor.prototype.start = function() {
     var args = validator_.validateArgs(arguments, [
-       {
-           name : 'successCallback',
-           type : types_.FUNCTION
-       },
-       {
-           name : 'errorCallback',
-           type : types_.FUNCTION,
-           optional : true,
-           nullable : true
-       }
+        {
+            name: 'successCallback',
+            type: types_.FUNCTION
+        },
+        {
+            name: 'errorCallback',
+            type: types_.FUNCTION,
+            optional: true,
+            nullable: true
+        }
     ]);
 
     _sensorListeners[this.sensorType].start(args.successCallback, args.errorCallback);
@@ -299,64 +307,75 @@ Sensor.prototype.stop = function() {
 
 Sensor.prototype.setChangeListener = function() {
     var args = validator_.validateArgs(arguments, [
-       {
-           name : 'successCallback',
-           type: types_.FUNCTION
-       },
-       {
-           name : 'interval',
-           type: types_.LONG,
-           optional: true,
-           nullable: true
-       },
-       {
-           name : 'batchLatency',
-           type: types_.LONG,
-           optional: true,
-           nullable: false
-       }
+        {
+            name: 'successCallback',
+            type: types_.FUNCTION
+        },
+        {
+            name: 'interval',
+            type: types_.LONG,
+            optional: true,
+            nullable: true
+        },
+        {
+            name: 'batchLatency',
+            type: types_.LONG,
+            optional: true,
+            nullable: false
+        }
     ]);
 
     var interval = args.interval || 100;
     if (interval < 10 || interval > 1000) {
-      throw new WebAPIException(WebAPIException.INVALID_VALUES_ERR, 'Interval should be in range [10, 1000] milliseconds.');
+        throw new WebAPIException(
+            WebAPIException.INVALID_VALUES_ERR,
+            'Interval should be in range [10, 1000] milliseconds.'
+        );
     }
 
     var batchLatency = args.batchLatency || 0;
 
-    _sensorListeners[this.sensorType].setListener(args.successCallback, interval, batchLatency);
+    _sensorListeners[this.sensorType].setListener(
+        args.successCallback,
+        interval,
+        batchLatency
+    );
 };
 
 Sensor.prototype.unsetChangeListener = function() {
     _sensorListeners[this.sensorType].unsetListener();
 };
 
-Sensor.prototype.getSensorHardwareInfo = function(){
-  var args = validator_.validateArgs(arguments, [
-       {
-           name : 'successCallback',
-           type : types_.FUNCTION
-       },
-       {
-           name : 'errorCallback',
-           type : types_.FUNCTION,
-           optional : true,
-           nullable : true
-       }
+Sensor.prototype.getSensorHardwareInfo = function() {
+    var args = validator_.validateArgs(arguments, [
+        {
+            name: 'successCallback',
+            type: types_.FUNCTION
+        },
+        {
+            name: 'errorCallback',
+            type: types_.FUNCTION,
+            optional: true,
+            nullable: true
+        }
     ]);
 
-  var callback = function(result){
-    if (native_.isFailure(result)){
-      if (!T_.isNullOrUndefined(errorCallback)) {
-        errorCallback(native_.getErrorObject(result));
-      }
-    }else {
-      args.successCallback(new SensorHardwareInfo(result));
-    }
-  }
+    var callback = function(result) {
+        if (native_.isFailure(result)) {
+            if (!T_.isNullOrUndefined(errorCallback)) {
+                errorCallback(native_.getErrorObject(result));
+            }
+        } else {
+            args.successCallback(new SensorHardwareInfo(result));
+        }
+    };
 
-  var result = native_.call("Sensor_getSensorHardwareInfo", {type: this.sensorType}, callback);
-}
+    var result = native_.call(
+        'Sensor_getSensorHardwareInfo',
+        { type: this.sensorType },
+        callback
+    );
+};
 
 //// LightSensor
 var LightSensor = function(data) {
@@ -369,16 +388,16 @@ LightSensor.prototype.constructor = Sensor;
 
 LightSensor.prototype.getLightSensorData = function() {
     var args = validator_.validateArgs(arguments, [
-       {
-           name : 'successCallback',
-           type : types_.FUNCTION
-       },
-       {
-           name : 'errorCallback',
-           type : types_.FUNCTION,
-           optional : true,
-           nullable : true
-       }
+        {
+            name: 'successCallback',
+            type: types_.FUNCTION
+        },
+        {
+            name: 'errorCallback',
+            type: types_.FUNCTION,
+            optional: true,
+            nullable: true
+        }
     ]);
 
     _sensorListeners[this.sensorType].getData(args.successCallback, args.errorCallback);
@@ -395,16 +414,16 @@ MagneticSensor.prototype.constructor = Sensor;
 
 MagneticSensor.prototype.getMagneticSensorData = function() {
     var args = validator_.validateArgs(arguments, [
-       {
-           name : 'successCallback',
-           type : types_.FUNCTION
-       },
-       {
-           name : 'errorCallback',
-           type : types_.FUNCTION,
-           optional : true,
-           nullable : true
-       }
+        {
+            name: 'successCallback',
+            type: types_.FUNCTION
+        },
+        {
+            name: 'errorCallback',
+            type: types_.FUNCTION,
+            optional: true,
+            nullable: true
+        }
     ]);
 
     _sensorListeners[this.sensorType].getData(args.successCallback, args.errorCallback);
@@ -421,16 +440,16 @@ PressureSensor.prototype.constructor = Sensor;
 
 PressureSensor.prototype.getPressureSensorData = function() {
     var args = validator_.validateArgs(arguments, [
-       {
-           name : 'successCallback',
-           type : types_.FUNCTION
-       },
-       {
-           name : 'errorCallback',
-           type : types_.FUNCTION,
-           optional : true,
-           nullable : true
-       }
+        {
+            name: 'successCallback',
+            type: types_.FUNCTION
+        },
+        {
+            name: 'errorCallback',
+            type: types_.FUNCTION,
+            optional: true,
+            nullable: true
+        }
     ]);
 
     _sensorListeners[this.sensorType].getData(args.successCallback, args.errorCallback);
@@ -447,16 +466,16 @@ ProximitySensor.prototype.constructor = Sensor;
 
 ProximitySensor.prototype.getProximitySensorData = function() {
     var args = validator_.validateArgs(arguments, [
-       {
-           name : 'successCallback',
-           type : types_.FUNCTION
-       },
-       {
-           name : 'errorCallback',
-           type : types_.FUNCTION,
-           optional : true,
-           nullable : true
-       }
+        {
+            name: 'successCallback',
+            type: types_.FUNCTION
+        },
+        {
+            name: 'errorCallback',
+            type: types_.FUNCTION,
+            optional: true,
+            nullable: true
+        }
     ]);
 
     _sensorListeners[this.sensorType].getData(args.successCallback, args.errorCallback);
@@ -473,16 +492,16 @@ UltravioletSensor.prototype.constructor = Sensor;
 
 UltravioletSensor.prototype.getUltravioletSensorData = function() {
     var args = validator_.validateArgs(arguments, [
-       {
-           name : 'successCallback',
-           type : types_.FUNCTION
-       },
-       {
-           name : 'errorCallback',
-           type : types_.FUNCTION,
-           optional : true,
-           nullable : true
-       }
+        {
+            name: 'successCallback',
+            type: types_.FUNCTION
+        },
+        {
+            name: 'errorCallback',
+            type: types_.FUNCTION,
+            optional: true,
+            nullable: true
+        }
     ]);
 
     _sensorListeners[this.sensorType].getData(args.successCallback, args.errorCallback);
@@ -499,25 +518,25 @@ HRMRawSensor.prototype.constructor = Sensor;
 
 function getHRMRawSensorData() {
     var args = validator_.validateArgs(arguments, [
-       {
-           name : 'successCallback',
-           type : types_.FUNCTION
-       },
-       {
-           name : 'errorCallback',
-           type : types_.FUNCTION,
-           optional : true,
-           nullable : true
-       }
+        {
+            name: 'successCallback',
+            type: types_.FUNCTION
+        },
+        {
+            name: 'errorCallback',
+            type: types_.FUNCTION,
+            optional: true,
+            nullable: true
+        }
     ]);
 
     utils_.checkPrivilegeAccess(privilege_.HEALTHINFO);
 
     _sensorListeners[this.sensorType].getData(args.successCallback, args.errorCallback);
-};
+}
 
 HRMRawSensor.prototype.getHRMRawSensorData = function() {
-  getHRMRawSensorData.apply(this, arguments);
+    getHRMRawSensorData.apply(this, arguments);
 };
 
 //// GravitySensor
@@ -531,22 +550,24 @@ GravitySensor.prototype.constructor = Sensor;
 
 GravitySensor.prototype.getGravitySensorData = function() {
     var args = validator_.validateArgs(arguments, [
-       {
-           name : 'successCallback',
-           type : types_.FUNCTION
-       },
-       {
-           name : 'errorCallback',
-           type : types_.FUNCTION,
-           optional : true,
-           nullable : true
-       }
+        {
+            name: 'successCallback',
+            type: types_.FUNCTION
+        },
+        {
+            name: 'errorCallback',
+            type: types_.FUNCTION,
+            optional: true,
+            nullable: true
+        }
     ]);
 
-    _sensorListeners[this.sensorType].getData(args.successCallback, errorWrapper.bind(args));
+    _sensorListeners[this.sensorType].getData(
+        args.successCallback,
+        errorWrapper.bind(args)
+    );
 };
 
-
 //// GyroscopeSensor
 var GyroscopeSensor = function(data) {
     Sensor.call(this, SensorType.GYROSCOPE);
@@ -558,19 +579,22 @@ GyroscopeSensor.prototype.constructor = Sensor;
 
 GyroscopeSensor.prototype.getGyroscopeSensorData = function() {
     var args = validator_.validateArgs(arguments, [
-       {
-           name : 'successCallback',
-           type : types_.FUNCTION
-       },
-       {
-           name : 'errorCallback',
-           type : types_.FUNCTION,
-           optional : true,
-           nullable : true
-       }
+        {
+            name: 'successCallback',
+            type: types_.FUNCTION
+        },
+        {
+            name: 'errorCallback',
+            type: types_.FUNCTION,
+            optional: true,
+            nullable: true
+        }
     ]);
 
-    _sensorListeners[this.sensorType].getData(args.successCallback, errorWrapper.bind(args));
+    _sensorListeners[this.sensorType].getData(
+        args.successCallback,
+        errorWrapper.bind(args)
+    );
 };
 
 //// GyroscopeRotationVectorSensor
@@ -582,22 +606,27 @@ GyroscopeRotationVectorSensor.prototype = new Sensor();
 
 GyroscopeRotationVectorSensor.prototype.constructor = Sensor;
 
-GyroscopeRotationVectorSensor.prototype.getGyroscopeRotationVectorSensorData = function() {
-    var args = validator_.validateArgs(arguments, [
-       {
-           name : 'successCallback',
-           type : types_.FUNCTION
-       },
-       {
-           name : 'errorCallback',
-           type : types_.FUNCTION,
-           optional : true,
-           nullable : true
-       }
-    ]);
+// prettier-ignore
+GyroscopeRotationVectorSensor.prototype.getGyroscopeRotationVectorSensorData =
+    function() {
+        var args = validator_.validateArgs(arguments, [
+            {
+                name: 'successCallback',
+                type: types_.FUNCTION
+            },
+            {
+                name: 'errorCallback',
+                type: types_.FUNCTION,
+                optional: true,
+                nullable: true
+            }
+        ]);
 
-    _sensorListeners[this.sensorType].getData(args.successCallback, errorWrapper.bind(args));
-};
+        _sensorListeners[this.sensorType].getData(
+            args.successCallback,
+            errorWrapper.bind(args)
+        );
+    };
 
 //// LinearAccelerationSensor
 var LinearAccelerationSensor = function(data) {
@@ -610,19 +639,22 @@ LinearAccelerationSensor.prototype.constructor = Sensor;
 
 LinearAccelerationSensor.prototype.getLinearAccelerationSensorData = function() {
     var args = validator_.validateArgs(arguments, [
-       {
-           name : 'successCallback',
-           type : types_.FUNCTION
-       },
-       {
-           name : 'errorCallback',
-           type : types_.FUNCTION,
-           optional : true,
-           nullable : true
-       }
+        {
+            name: 'successCallback',
+            type: types_.FUNCTION
+        },
+        {
+            name: 'errorCallback',
+            type: types_.FUNCTION,
+            optional: true,
+            nullable: true
+        }
     ]);
 
-    _sensorListeners[this.sensorType].getData(args.successCallback, errorWrapper.bind(args));
+    _sensorListeners[this.sensorType].getData(
+        args.successCallback,
+        errorWrapper.bind(args)
+    );
 };
 
 //// MagneticUncalibratedSensor
@@ -637,18 +669,21 @@ MagneticUncalibratedSensor.prototype.constructor = Sensor;
 MagneticUncalibratedSensor.prototype.getMagneticUncalibratedSensorData = function() {
     var args = validator_.validateArgs(arguments, [
         {
-            name : 'successCallback',
-            type : types_.FUNCTION
+            name: 'successCallback',
+            type: types_.FUNCTION
         },
         {
-            name : 'errorCallback',
-            type : types_.FUNCTION,
-            optional : true,
-            nullable : true
+            name: 'errorCallback',
+            type: types_.FUNCTION,
+            optional: true,
+            nullable: true
         }
     ]);
 
-    _sensorListeners[this.sensorType].getData(args.successCallback, errorWrapper.bind(args));
+    _sensorListeners[this.sensorType].getData(
+        args.successCallback,
+        errorWrapper.bind(args)
+    );
 };
 
 //// GyroscopeUncalibratedSensor
@@ -663,18 +698,21 @@ GyroscopeUncalibratedSensor.prototype.constructor = Sensor;
 GyroscopeUncalibratedSensor.prototype.getGyroscopeUncalibratedSensorData = function() {
     var args = validator_.validateArgs(arguments, [
         {
-            name : 'successCallback',
-            type : types_.FUNCTION
+            name: 'successCallback',
+            type: types_.FUNCTION
         },
         {
-            name : 'errorCallback',
-            type : types_.FUNCTION,
-            optional : true,
-            nullable : true
+            name: 'errorCallback',
+            type: types_.FUNCTION,
+            optional: true,
+            nullable: true
         }
     ]);
 
-    _sensorListeners[this.sensorType].getData(args.successCallback, errorWrapper.bind(args));
+    _sensorListeners[this.sensorType].getData(
+        args.successCallback,
+        errorWrapper.bind(args)
+    );
 };
 
 //// AccelerationSensor
@@ -688,31 +726,33 @@ AccelerationSensor.prototype.constructor = Sensor;
 
 AccelerationSensor.prototype.getAccelerationSensorData = function() {
     var args = validator_.validateArgs(arguments, [
-       {
-           name : 'successCallback',
-           type : types_.FUNCTION
-       },
-       {
-           name : 'errorCallback',
-           type : types_.FUNCTION,
-           optional : true,
-           nullable : true
-       }
+        {
+            name: 'successCallback',
+            type: types_.FUNCTION
+        },
+        {
+            name: 'errorCallback',
+            type: types_.FUNCTION,
+            optional: true,
+            nullable: true
+        }
     ]);
 
-    _sensorListeners[this.sensorType].getData(args.successCallback, errorWrapper.bind(args));
+    _sensorListeners[this.sensorType].getData(
+        args.successCallback,
+        errorWrapper.bind(args)
+    );
 };
 
-////////////////////// Sensor Data classes/////////////////////////////////////////////////////
+////////////////////// Sensor Data classes//////////////////////////
 ////Base SensorData class
-var SensorData = function () {
-};
+var SensorData = function() {};
 
 //// SensorLightData
 var SensorLightData = function(data) {
     SensorData.call(this);
     Object.defineProperties(this, {
-        lightLevel : {value: data.lightLevel, writable: false, enumerable: true}
+        lightLevel: { value: data.lightLevel, writable: false, enumerable: true }
     });
 };
 
@@ -720,17 +760,19 @@ SensorLightData.prototype = new SensorData();
 
 SensorLightData.prototype.constructor = SensorData;
 
-_sensorListeners[SensorType.LIGHT] = new SensorListener(SensorType.LIGHT,
-        SensorLightData);
+_sensorListeners[SensorType.LIGHT] = new SensorListener(
+    SensorType.LIGHT,
+    SensorLightData
+);
 
 //// SensorMagneticData
 var SensorMagneticData = 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},
-        accuracy : {value: data.accuracy, writable: false, enumerable: true}
+        x: { value: data.x, writable: false, enumerable: true },
+        y: { value: data.y, writable: false, enumerable: true },
+        z: { value: data.z, writable: false, enumerable: true },
+        accuracy: { value: data.accuracy, writable: false, enumerable: true }
     });
 };
 
@@ -738,14 +780,16 @@ SensorMagneticData.prototype = new SensorData();
 
 SensorMagneticData.prototype.constructor = SensorData;
 
-_sensorListeners[SensorType.MAGNETIC] = new SensorListener(SensorType.MAGNETIC,
-        SensorMagneticData);
+_sensorListeners[SensorType.MAGNETIC] = new SensorListener(
+    SensorType.MAGNETIC,
+    SensorMagneticData
+);
 
 //// SensorPressureData
 var SensorPressureData = function(data) {
     SensorData.call(this);
     Object.defineProperties(this, {
-        pressure : {value: data.pressure, writable: false, enumerable: true}
+        pressure: { value: data.pressure, writable: false, enumerable: true }
     });
 };
 
@@ -753,14 +797,16 @@ SensorPressureData.prototype = new SensorData();
 
 SensorPressureData.prototype.constructor = SensorData;
 
-_sensorListeners[SensorType.PRESSURE] = new SensorListener(SensorType.PRESSURE,
-        SensorPressureData);
+_sensorListeners[SensorType.PRESSURE] = new SensorListener(
+    SensorType.PRESSURE,
+    SensorPressureData
+);
 
 //// SensorProximityData
 var SensorProximityData = function(data) {
     SensorData.call(this);
     Object.defineProperties(this, {
-        proximityState : {value: data.proximityState, writable: false, enumerable: true}
+        proximityState: { value: data.proximityState, writable: false, enumerable: true }
     });
 };
 
@@ -768,49 +814,57 @@ SensorProximityData.prototype = new SensorData();
 
 SensorProximityData.prototype.constructor = SensorData;
 
-_sensorListeners[SensorType.PROXIMITY] = new SensorListener(SensorType.PROXIMITY,
-        SensorProximityData);
+_sensorListeners[SensorType.PROXIMITY] = new SensorListener(
+    SensorType.PROXIMITY,
+    SensorProximityData
+);
 
 //// SensorUltravioletData
 var SensorUltravioletData = function(data) {
     SensorData.call(this);
     Object.defineProperties(this, {
-        ultravioletLevel : {value: data.ultravioletLevel, writable: false, enumerable: true}
+        ultravioletLevel: {
+            value: data.ultravioletLevel,
+            writable: false,
+            enumerable: true
+        }
     });
 };
 
-
 SensorUltravioletData.prototype = new SensorData();
 
 SensorUltravioletData.prototype.constructor = SensorData;
 
-_sensorListeners[SensorType.ULTRAVIOLET] = new SensorListener(SensorType.ULTRAVIOLET,
-        SensorUltravioletData);
+_sensorListeners[SensorType.ULTRAVIOLET] = new SensorListener(
+    SensorType.ULTRAVIOLET,
+    SensorUltravioletData
+);
 
 ////SensorHRMRawData
 var SensorHRMRawData = function(data) {
     SensorData.call(this);
     Object.defineProperties(this, {
-        lightType : {value: data.lightType, writable: false, enumerable: true},
-        lightIntensity : {value: data.lightIntensity, writable: false, enumerable: true}
+        lightType: { value: data.lightType, writable: false, enumerable: true },
+        lightIntensity: { value: data.lightIntensity, writable: false, enumerable: true }
     });
 };
 
-
 SensorHRMRawData.prototype = new SensorData();
 
 SensorHRMRawData.prototype.constructor = SensorData;
 
-_sensorListeners[SensorType.HRM_RAW] = new SensorListener(SensorType.HRM_RAW,
-        SensorHRMRawData);
+_sensorListeners[SensorType.HRM_RAW] = new SensorListener(
+    SensorType.HRM_RAW,
+    SensorHRMRawData
+);
 
 //// SensorGravityData
 var SensorGravityData = 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},
+        x: { value: data.x, writable: false, enumerable: true },
+        y: { value: data.y, writable: false, enumerable: true },
+        z: { value: data.z, writable: false, enumerable: true }
     });
 };
 
@@ -818,16 +872,18 @@ SensorGravityData.prototype = new SensorData();
 
 SensorGravityData.prototype.constructor = SensorData;
 
-_sensorListeners[SensorType.GRAVITY] = new SensorListener(SensorType.GRAVITY,
-        SensorGravityData);
+_sensorListeners[SensorType.GRAVITY] = new SensorListener(
+    SensorType.GRAVITY,
+    SensorGravityData
+);
 
 //// SensorGyroscopeData
 var SensorGyroscopeData = 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},
+        x: { value: data.x, writable: false, enumerable: true },
+        y: { value: data.y, writable: false, enumerable: true },
+        z: { value: data.z, writable: false, enumerable: true }
     });
 };
 
@@ -835,17 +891,19 @@ SensorGyroscopeData.prototype = new SensorData();
 
 SensorGyroscopeData.prototype.constructor = SensorData;
 
-_sensorListeners[SensorType.GYROSCOPE] = new SensorListener(SensorType.GYROSCOPE,
-        SensorGyroscopeData);
+_sensorListeners[SensorType.GYROSCOPE] = new SensorListener(
+    SensorType.GYROSCOPE,
+    SensorGyroscopeData
+);
 
 //// SensorGyroscopeRotationVectorData
 var SensorGyroscopeRotationVectorData = 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},
-        w : {value: data.w, writable: false, enumerable: true},
+        x: { value: data.x, writable: false, enumerable: true },
+        y: { value: data.y, writable: false, enumerable: true },
+        z: { value: data.z, writable: false, enumerable: true },
+        w: { value: data.w, writable: false, enumerable: true }
     });
 };
 
@@ -853,16 +911,18 @@ SensorGyroscopeRotationVectorData.prototype = new SensorData();
 
 SensorGyroscopeRotationVectorData.prototype.constructor = SensorData;
 
-_sensorListeners[SensorType.GYROSCOPE_ROTATION_VECTOR] = new SensorListener(SensorType.GYROSCOPE_ROTATION_VECTOR,
-        SensorGyroscopeRotationVectorData);
+_sensorListeners[SensorType.GYROSCOPE_ROTATION_VECTOR] = new SensorListener(
+    SensorType.GYROSCOPE_ROTATION_VECTOR,
+    SensorGyroscopeRotationVectorData
+);
 
 //// SensorLinearAccelerationData
 var SensorLinearAccelerationData = 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},
+        x: { value: data.x, writable: false, enumerable: true },
+        y: { value: data.y, writable: false, enumerable: true },
+        z: { value: data.z, writable: false, enumerable: true }
     });
 };
 
@@ -870,19 +930,21 @@ SensorLinearAccelerationData.prototype = new SensorData();
 
 SensorLinearAccelerationData.prototype.constructor = SensorData;
 
-_sensorListeners[SensorType.LINEAR_ACCELERATION] = new SensorListener(SensorType.LINEAR_ACCELERATION,
-        SensorLinearAccelerationData);
+_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}
+        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 }
     });
 };
 
@@ -890,37 +952,40 @@ SensorMagneticUncalibratedData.prototype = new SensorData();
 
 SensorMagneticUncalibratedData.prototype.constructor = SensorData;
 
-_sensorListeners[SensorType.MAGNETIC_UNCALIBRATED] = new SensorListener(SensorType.MAGNETIC_UNCALIBRATED,
-    SensorMagneticUncalibratedData);
+_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}
+        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);
+_sensorListeners[SensorType.GYROSCOPE_UNCALIBRATED] = new SensorListener(
+    SensorType.GYROSCOPE_UNCALIBRATED,
+    SensorGyroscopeUncalibratedData
+);
 
 //// SensorAccelerationData
 var SensorAccelerationData = 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},
+        x: { value: data.x, writable: false, enumerable: true },
+        y: { value: data.y, writable: false, enumerable: true },
+        z: { value: data.z, writable: false, enumerable: true }
     });
 };
 
@@ -928,20 +993,22 @@ SensorAccelerationData.prototype = new SensorData();
 
 SensorAccelerationData.prototype.constructor = SensorData;
 
-_sensorListeners[SensorType.ACCELERATION] = new SensorListener(SensorType.ACCELERATION,
-        SensorAccelerationData);
+_sensorListeners[SensorType.ACCELERATION] = new SensorListener(
+    SensorType.ACCELERATION,
+    SensorAccelerationData
+);
 
-//////////////////////SensorHardwareInfo classes//////////////////////////////////////////////////////////
+//////////////////////SensorHardwareInfo classes/////////////////////////////
 function SensorHardwareInfo(data) {
     Object.defineProperties(this, {
-        name : {value: data.name, writable: false, enumerable: true},
-        type : {value: data.type, writable: false, enumerable: true},
-        vendor : {value: data.vendor, writable: false, enumerable: true},
-        minValue : {value: data.minValue, writable: false, enumerable: true},
-        maxValue : {value: data.maxValue, writable: false,  enumerable: true},
-        resolution : {value: data.resolution, writable: false, enumerable: true},
-        minInterval : {value: data.minInterval, writable: false, enumerable: true},
-        maxBatchCount : {value: data.batchCount, writable: false, enumerable: true}
+        name: { value: data.name, writable: false, enumerable: true },
+        type: { value: data.type, writable: false, enumerable: true },
+        vendor: { value: data.vendor, writable: false, enumerable: true },
+        minValue: { value: data.minValue, writable: false, enumerable: true },
+        maxValue: { value: data.maxValue, writable: false, enumerable: true },
+        resolution: { value: data.resolution, writable: false, enumerable: true },
+        minInterval: { value: data.minInterval, writable: false, enumerable: true },
+        maxBatchCount: { value: data.batchCount, writable: false, enumerable: true }
     });
 }
 // Exports