Example #1
0
        public void Start(MotionSensorType sensorType, MotionSensorDelay interval = MotionSensorDelay.Default)
        {
            uint delay = (uint)((double)Convert.ToInt32(interval) / ms);

            switch (sensorType)
            {
            case MotionSensorType.Accelerometer:
                if (accelerometer != null)
                {
                    accelerometer.ReportInterval  = delay;
                    accelerometer.ReadingChanged += AccelerometerReadingChanged;
                }
                else
                {
                    Debug.WriteLine("Accelerometer not available");
                }
                break;

            case MotionSensorType.Gyroscope:
                if (gyrometer != null)
                {
                    gyrometer.ReportInterval  = delay;
                    gyrometer.ReadingChanged += GyrometerReadingChanged;
                }
                else
                {
                    Debug.WriteLine("Gyrometer not available");
                }
                break;

            case MotionSensorType.Magnetometer:
                if (magnetometer != null)
                {
                    magnetometer.ReportInterval  = delay;
                    magnetometer.ReadingChanged += MagnetometerReadingChanged;
                }
                else
                {
                    Debug.WriteLine("Magnetometer not available");
                }
                break;

            case MotionSensorType.Compass:

                if (compass != null)
                {
                    compass.ReportInterval  = delay;
                    compass.ReadingChanged += CompassReadingChanged;
                }
                else
                {
                    Debug.WriteLine("Compass not available");
                }

                break;
            }
            sensorStatus[sensorType] = true;
        }
        /// <summary>
        /// Start the specified sensorType and interval.
        /// </summary>
        /// <param name="sensorType">Sensor type.</param>
        /// <param name="interval">Interval.</param>
        public void Start(MotionSensorType sensorType, MotionSensorDelay interval)
        {
            switch (sensorType)
            {
            case MotionSensorType.Accelerometer:
                if (motionManager.AccelerometerAvailable)
                {
                    motionManager.AccelerometerUpdateInterval = (double)interval / ms;
                    motionManager.StartAccelerometerUpdates(NSOperationQueue.CurrentQueue, OnAccelerometerChanged);
                }
                else
                {
                    Debug.WriteLine("Accelerometer not available");
                }
                break;

            case MotionSensorType.Gyroscope:
                if (motionManager.GyroAvailable)
                {
                    motionManager.GyroUpdateInterval = (double)interval / ms;
                    motionManager.StartGyroUpdates(NSOperationQueue.CurrentQueue, OnGyroscopeChanged);
                }
                else
                {
                    Debug.WriteLine("Gyroscope not available");
                }
                break;

            case MotionSensorType.Magnetometer:
                if (motionManager.MagnetometerAvailable)
                {
                    motionManager.MagnetometerUpdateInterval = (double)interval / ms;
                    motionManager.StartMagnetometerUpdates(NSOperationQueue.CurrentQueue, OnMagnometerChanged);
                }
                else
                {
                    Debug.WriteLine("Magnetometer not available");
                }
                break;

            case MotionSensorType.Compass:
                if (CLLocationManager.HeadingAvailable)
                {
                    locationManager.StartUpdatingHeading();
                    locationManager.UpdatedHeading += OnHeadingChanged;
                }
                else
                {
                    Debug.WriteLine("Compass not available");
                }
                break;
            }
            sensorStatus[sensorType] = true;
        }
Example #3
0
        /// <summary>
        /// Stop the specified sensorType.
        /// </summary>
        /// <param name="sensorType">Sensor type.</param>
        public void Stop(MotionSensorType sensorType)
        {
            switch (sensorType)
            {
            case MotionSensorType.Accelerometer:
                if (accelerometer != null)
                {
                    accelerometer.DataUpdated -= AccelerometerDataUpdated;
                    accelerometer.Stop();
                }
                else
                {
                    Debug.WriteLine("Accelerometer not available");
                }
                break;

            case MotionSensorType.Gyroscope:
                if (gyroscope != null)
                {
                    gyroscope.DataUpdated -= GyroscopeDataUpdated;
                    gyroscope.Stop();
                }
                else
                {
                    Debug.WriteLine("Gyrometer not available");
                }
                break;

            case MotionSensorType.Magnetometer:
                if (magnetometer != null)
                {
                    magnetometer.DataUpdated -= MagnetometerDataUpdated;
                    magnetometer.Stop();
                }
                else
                {
                    Debug.WriteLine("Magnetometer not available");
                }
                break;

            case MotionSensorType.Compass:
                if (orientation != null)
                {
                    orientation.DataUpdated -= OrientationDataUpdated;
                    orientation.Stop();
                }
                else
                {
                    Debug.WriteLine("OrientationSensor not available");
                }
                break;
            }
            sensorStatus[sensorType] = false;
        }
        /// <summary>
        /// Stop the specified sensorType.
        /// </summary>
        /// <param name="sensorType">Sensor type.</param>
        public void Stop(MotionSensorType sensorType)
        {
            switch (sensorType)
            {
            case MotionSensorType.Accelerometer:
                if (accelerometer != null)
                {
                    accelerometer.ReadingChanged -= AccelerometerReadingChanged;
                }
                else
                {
                    Debug.WriteLine("Accelerometer not available");
                }
                break;

            case MotionSensorType.Gyroscope:
                if (gyrometer != null)
                {
                    gyrometer.ReadingChanged -= GyrometerReadingChanged;
                }
                else
                {
                    Debug.WriteLine("Gyrometer not available");
                }
                break;

            case MotionSensorType.Magnetometer:
#if WINDOWS_PHONE_APP
                if (magnetometer != null)
                {
                    magnetometer.ReadingChanged -= MagnetometerReadingChanged;
                }
                else
                {
                    Debug.WriteLine("Magnetometer not available");
                }
#else
                Debug.WriteLine("Magnetometer not supported");
#endif
                break;

            case MotionSensorType.Compass:
                if (compass != null)
                {
                    compass.ReadingChanged -= CompassReadingChanged;
                }
                else
                {
                    Debug.WriteLine("Compass not available");
                }
                break;
            }
            sensorStatus[sensorType] = false;
        }
        /// <summary>
        /// Start the specified sensorType and interval.
        /// </summary>
        /// <param name="sensorType">Sensor type.</param>
        /// <param name="interval">Interval.</param>
        public void Start(MotionSensorType sensorType, MotionSensorDelay interval)
        {

            switch (sensorType)
            {
                case MotionSensorType.Accelerometer:
                    if (motionManager.AccelerometerAvailable)
                    {
                        motionManager.AccelerometerUpdateInterval = (double)interval / ms;
                        motionManager.StartAccelerometerUpdates(NSOperationQueue.CurrentQueue, OnAccelerometerChanged);
                    }
                    else
                    {
                      Debug.WriteLine("Accelerometer not available");
                    }
                    break;
                case MotionSensorType.Gyroscope:
                    if (motionManager.GyroAvailable)
                    {
                        motionManager.GyroUpdateInterval = (double)interval / ms;
                        motionManager.StartGyroUpdates(NSOperationQueue.CurrentQueue, OnGyroscopeChanged);
                    }
                    else
                    {
                        Debug.WriteLine("Gyroscope not available");
                    }
                    break;
                case MotionSensorType.Magnetometer:
                    if (motionManager.MagnetometerAvailable)
                    {
                        motionManager.MagnetometerUpdateInterval = (double)interval / ms;
                        motionManager.StartMagnetometerUpdates(NSOperationQueue.CurrentQueue, OnMagnometerChanged);
                    }
                    else
                    {
                        Debug.WriteLine("Magnetometer not available");
                    }
                    break;
                case MotionSensorType.Compass:
                    if (CLLocationManager.HeadingAvailable)
                    {
                        locationManager.StartUpdatingHeading();
                        locationManager.UpdatedHeading += OnHeadingChanged;
                    }
                    else
                    {
                        Debug.WriteLine("Compass not available");
                    }
                    break;
            }
            sensorStatus[sensorType] = true;
        }
        /// <summary>
        /// Stop the specified sensorType.
        /// </summary>
        /// <param name="sensorType">Sensor type.</param>
        public void Stop(MotionSensorType sensorType)
        {
            switch (sensorType)
            {
            case MotionSensorType.Accelerometer:
                if (motionManager.AccelerometerActive)
                {
                    motionManager.StopAccelerometerUpdates();
                }
                else
                {
                    Debug.WriteLine("Accelerometer not available");
                }
                break;

            case MotionSensorType.Gyroscope:
                if (motionManager.GyroActive)
                {
                    motionManager.StopGyroUpdates();
                }
                else
                {
                    Debug.WriteLine("Gyroscope not available");
                }
                break;

            case MotionSensorType.Magnetometer:
                if (motionManager.MagnetometerActive)
                {
                    motionManager.StopMagnetometerUpdates();
                }
                else
                {
                    Debug.WriteLine("Magnetometer not available");
                }
                break;

            case MotionSensorType.Compass:
                if (CLLocationManager.HeadingAvailable)
                {
                    locationManager.StopUpdatingHeading();
                    locationManager.UpdatedHeading -= OnHeadingChanged;
                }
                else
                {
                    Debug.WriteLine("Compass not available");
                }
                break;
            }
            sensorStatus[sensorType] = false;
        }
        /// <summary>
        /// Stop the specified sensorType.
        /// </summary>
        /// <param name="sensorType">Sensor type.</param>
        public void Stop(MotionSensorType sensorType)
        {
            switch (sensorType)
            {
            case MotionSensorType.Accelerometer:
                if (sensorAccelerometer != null)
                {
                    sensorManager.UnregisterListener(this, sensorAccelerometer);
                }
                else
                {
                    Console.WriteLine("Accelerometer not available");
                }
                break;

            case MotionSensorType.Gyroscope:
                if (sensorGyroscope != null)
                {
                    sensorManager.UnregisterListener(this, sensorGyroscope);
                }
                else
                {
                    Console.WriteLine("Gyroscope not available");
                }
                break;

            case MotionSensorType.Magnetometer:
                if (sensorMagnetometer != null)
                {
                    sensorManager.UnregisterListener(this, sensorMagnetometer);
                }
                else
                {
                    Console.WriteLine("Magnetometer not available");
                }
                break;

            case MotionSensorType.Compass:
                if (sensorCompass != null)
                {
                    sensorManager.UnregisterListener(this, sensorCompass);
                }
                else
                {
                    Console.WriteLine("Compass not available");
                }
                break;
            }
            sensorStatus[sensorType] = false;
        }
        /// <summary>
        /// Start the specified sensorType and interval.
        /// </summary>
        /// <param name="sensorType">Sensor type.</param>
        /// <param name="interval">Interval.</param>
        public void Start(MotionSensorType sensorType, MotionSensorDelay interval = MotionSensorDelay.Default)
        {

            uint delay = (uint)((double)Convert.ToInt32(interval) / ms);
           
            switch (sensorType)
            {
                case MotionSensorType.Accelerometer:
                    if (accelerometer != null)
                    {
                        accelerometer.ReportInterval = delay;
                        accelerometer.ReadingChanged += AccelerometerReadingChanged;
                    }
                    else
                    {
                        Debug.WriteLine("Accelerometer not available");
                    }
                    break;
                case MotionSensorType.Gyroscope:
                    if (gyrometer != null) 
                    { 
                      gyrometer.ReportInterval = delay;
                      gyrometer.ReadingChanged += GyrometerReadingChanged;
                    }
                    else
                    {
                        Debug.WriteLine("Gyrometer not available");
                    }
                    break;
                case MotionSensorType.Magnetometer:
#if WINDOWS_PHONE_APP
                    if(magnetometer != null)
                    {

                      magnetometer.ReportInterval = delay;
                      magnetometer.ReadingChanged += MagnetometerReadingChanged;
                    }
                    else
                    {
                        Debug.WriteLine("Magnetometer not available");
                    }
#else
                    Debug.WriteLine("Magnetometer not supported");
#endif
                  
                    break;
                case MotionSensorType.Compass:

                    if(compass != null)
                    {

                        compass.ReportInterval = delay;
                        compass.ReadingChanged += CompassReadingChanged;
                    }
                    else
                    {
                        Debug.WriteLine("Compass not available");
                    }

                    break;

            }
            sensorStatus[sensorType] = true;
        }
      /// <summary>
      /// Stop the specified sensorType.
      /// </summary>
      /// <param name="sensorType">Sensor type.</param>
      public void Stop(MotionSensorType sensorType)
      {

          switch (sensorType)
          {
              case MotionSensorType.Accelerometer:
                  if (sensorAccelerometer != null)
                      sensorManager.UnregisterListener(this, sensorAccelerometer);
                  else
                      Console.WriteLine("Accelerometer not available");
                  break;
              case MotionSensorType.Gyroscope:
                  if (sensorGyroscope != null)
                      sensorManager.UnregisterListener(this, sensorGyroscope);
                  else
                      Console.WriteLine("Gyroscope not available");
                  break;
              case MotionSensorType.Magnetometer:
                  if (sensorMagnetometer != null)
                      sensorManager.UnregisterListener(this, sensorMagnetometer);
                  else
                      Console.WriteLine("Magnetometer not available");
                  break;
              case MotionSensorType.Compass:
                  if (sensorCompass != null)
                      sensorManager.UnregisterListener(this, sensorCompass);
                  else
                      Console.WriteLine("Compass not available");
                  break;
          }
          sensorStatus[sensorType] = false;
      }
Example #10
0
        /// <summary>
        /// Start the specified sensorType and interval.
        /// </summary>
        /// <param name="sensorType">Sensor type.</param>
        /// <param name="interval">Interval.</param>
        public void Start(MotionSensorType sensorType, MotionSensorDelay interval = MotionSensorDelay.Default)
        {
            SensorDelay delay = SensorDelay.Normal;

            switch (interval)
            {
            case MotionSensorDelay.Fastest:
                delay = SensorDelay.Fastest;
                break;

            case MotionSensorDelay.Game:
                delay = SensorDelay.Game;
                break;

            case MotionSensorDelay.Ui:
                delay = SensorDelay.Ui;
                break;
            }
            switch (sensorType)
            {
            case MotionSensorType.Accelerometer:
                if (_sensorAccelerometer != null)
                {
                    _sensorManager.RegisterListener(this, _sensorAccelerometer, delay);
                }
                else
                {
                    Console.WriteLine("Accelerometer not available");
                }
                break;

            case MotionSensorType.Gyroscope:
                if (_sensorGyroscope != null)
                {
                    _sensorManager.RegisterListener(this, _sensorGyroscope, delay);
                }
                else
                {
                    Console.WriteLine("Gyroscope not available");
                }
                break;

            case MotionSensorType.Magnetometer:
                if (_sensorMagnetometer != null)
                {
                    _sensorManager.RegisterListener(this, _sensorMagnetometer, delay);
                }
                else
                {
                    Console.WriteLine("Magnetometer not available");
                }
                break;

            case MotionSensorType.Compass:
                if (_sensorCompass != null)
                {
                    _sensorManager.RegisterListener(this, _sensorCompass, delay);
                }
                else
                {
                    Console.WriteLine("Compass not available");
                }
                break;

            case MotionSensorType.StepDetector:
                if (_sensorStepDetector != null)
                {
                    _sensorManager.RegisterListener(this, _sensorStepDetector, delay);
                }
                else
                {
                    Console.WriteLine("Step Detector is not available");
                }
                break;

            case MotionSensorType.StepCounter:
                if (_sensorStepCounter != null)
                {
                    _sensorManager.RegisterListener(this, _sensorStepCounter, delay);
                }
                else
                {
                    Console.WriteLine("Sensor Counter is not available");
                }
                break;

            default:
                throw new ArgumentOutOfRangeException(nameof(sensorType), sensorType, null);
            }
            _sensorStatus[sensorType] = true;
        }
 /// <summary>
 /// Stop the specified sensorType.
 /// </summary>
 /// <param name="sensorType">Sensor type.</param>
 public void Stop(MotionSensorType sensorType)
 {
     switch (sensorType)
     {
         case MotionSensorType.Accelerometer:
             if (motionManager.AccelerometerActive)
                 motionManager.StopAccelerometerUpdates();
             else
                 Debug.WriteLine("Accelerometer not available");
             break;
         case MotionSensorType.Gyroscope:
             if (motionManager.GyroActive)
                 motionManager.StopGyroUpdates();
             else
                 Debug.WriteLine("Gyroscope not available");
             break;
         case MotionSensorType.Magnetometer:
             if (motionManager.MagnetometerActive)
                 motionManager.StopMagnetometerUpdates();
             else
                 Debug.WriteLine("Magnetometer not available");
             break;
         case MotionSensorType.Compass:
             if (CLLocationManager.HeadingAvailable)
             {
                 locationManager.StopUpdatingHeading();
                 locationManager.UpdatedHeading-= OnHeadingChanged;
             }
             else
             {
                 Debug.WriteLine("Compass not available");
             }
             break;
     }
     sensorStatus[sensorType] = false;
 }
Example #12
0
 public void Start(MotionSensorType sensorType, MotionSensorDelay interval = MotionSensorDelay.Default)
 {
     throw new NotImplementedException();
 }
Example #13
0
 public bool IsActive(MotionSensorType sensorType)
 {
     throw new NotImplementedException();
 }
Example #14
0
 public void Stop(MotionSensorType sensorType)
 {
     throw new NotImplementedException();
 }
Example #15
0
        /// <summary>
        /// Stop the specified sensorType.
        /// </summary>
        /// <param name="sensorType">Sensor type.</param>
        public void Stop(MotionSensorType sensorType)
        {
            switch (sensorType)
            {
            case MotionSensorType.Accelerometer:
                if (_sensorAccelerometer != null)
                {
                    _sensorManager.UnregisterListener(this, _sensorAccelerometer);
                }
                else
                {
                    Console.WriteLine("Accelerometer not available");
                }
                break;

            case MotionSensorType.Gyroscope:
                if (_sensorGyroscope != null)
                {
                    _sensorManager.UnregisterListener(this, _sensorGyroscope);
                }
                else
                {
                    Console.WriteLine("Gyroscope not available");
                }
                break;

            case MotionSensorType.Magnetometer:
                if (_sensorMagnetometer != null)
                {
                    _sensorManager.UnregisterListener(this, _sensorMagnetometer);
                }
                else
                {
                    Console.WriteLine("Magnetometer not available");
                }
                break;

            case MotionSensorType.Compass:
                if (_sensorCompass != null)
                {
                    _sensorManager.UnregisterListener(this, _sensorCompass);
                }
                else
                {
                    Console.WriteLine("Compass not available");
                }
                break;

            case MotionSensorType.StepDetector:
                if (_sensorStepDetector != null)
                {
                    _sensorManager.UnregisterListener(this, _sensorStepDetector);
                }
                else
                {
                    Console.WriteLine("Step Detector is not available");
                }
                break;

            case MotionSensorType.StepCounter:
                if (_sensorStepCounter != null)
                {
                    _sensorManager.UnregisterListener(this, _sensorStepCounter);
                }
                else
                {
                    Console.WriteLine("Step Counter is not available");
                }
                break;

            default:
                throw new ArgumentOutOfRangeException(nameof(sensorType), sensorType, null);
            }
            _sensorStatus[sensorType] = false;
        }
        /// <summary>
        /// Start the specified sensorType and interval.
        /// </summary>
        /// <param name="sensorType">Sensor type.</param>
        /// <param name="interval">Interval.</param>
        public void Start(MotionSensorType sensorType, MotionSensorDelay interval = MotionSensorDelay.Default)
        {
            SensorDelay delay = SensorDelay.Normal;

            switch (interval)
            {
            case MotionSensorDelay.Fastest:
                delay = SensorDelay.Fastest;
                break;

            case MotionSensorDelay.Game:
                delay = SensorDelay.Game;
                break;

            case MotionSensorDelay.Ui:
                delay = SensorDelay.Ui;
                break;
            }
            switch (sensorType)
            {
            case MotionSensorType.Accelerometer:
                if (sensorAccelerometer != null)
                {
                    sensorManager.RegisterListener(this, sensorAccelerometer, delay);
                }
                else
                {
                    Console.WriteLine("Accelerometer not available");
                }
                break;

            case MotionSensorType.Gyroscope:
                if (sensorGyroscope != null)
                {
                    sensorManager.RegisterListener(this, sensorGyroscope, delay);
                }
                else
                {
                    Console.WriteLine("Gyroscope not available");
                }
                break;

            case MotionSensorType.Magnetometer:
                if (sensorMagnetometer != null)
                {
                    sensorManager.RegisterListener(this, sensorMagnetometer, delay);
                }
                else
                {
                    Console.WriteLine("Magnetometer not available");
                }
                break;

            case MotionSensorType.Compass:
                if (sensorCompass != null)
                {
                    sensorManager.RegisterListener(this, sensorCompass, delay);
                }
                else
                {
                    Console.WriteLine("Compass not available");
                }
                break;
            }
            sensorStatus[sensorType] = true;
        }
        /// <summary>
        /// Stop the specified sensorType.
        /// </summary>
        /// <param name="sensorType">Sensor type.</param>
        public void Stop(MotionSensorType sensorType)
        {
            switch (sensorType)
            {
                case MotionSensorType.Accelerometer:
                    if(accelerometer!=null)
                    {
                       accelerometer.ReadingChanged -= AccelerometerReadingChanged;
                    }
                    else
                    {
                        Debug.WriteLine("Accelerometer not available");
                    }
                    break;
                case MotionSensorType.Gyroscope:
                    if (gyrometer != null)
                    {
                        gyrometer.ReadingChanged -= GyrometerReadingChanged;
                    }
                    else
                    {
                        Debug.WriteLine("Gyrometer not available");
                    }
                    break;
                case MotionSensorType.Magnetometer:
#if WINDOWS_PHONE_APP
                    if(magnetometer!=null)
                    {
                        magnetometer.ReadingChanged -= MagnetometerReadingChanged;
                    }
                    else
                    {
                        Debug.WriteLine("Magnetometer not available");
                    }
#else
                    Debug.WriteLine("Magnetometer not supported");
#endif
                    break;
                    case MotionSensorType.Compass:
                    if (compass != null)
                    {
                       compass.ReadingChanged -= CompassReadingChanged;
                    }
                    else
                    {
                        Debug.WriteLine("Compass not available");
                    }
                    break;
            }
            sensorStatus[sensorType] = false;
        }
 /// <summary>
 /// Determines whether this instance is active the specified sensorType.
 /// </summary>
 /// <returns><c>true</c> if this instance is active the specified sensorType; otherwise, <c>false</c>.</returns>
 /// <param name="sensorType">Sensor type.</param>
 public bool IsActive(MotionSensorType sensorType)
 {
     return(sensorStatus[sensorType]);
 }
 /// <summary>
 /// Determines whether this instance is active the specified sensorType.
 /// </summary>
 /// <returns><c>true</c> if this instance is active the specified sensorType; otherwise, <c>false</c>.</returns>
 /// <param name="sensorType">Sensor type.</param>
 public bool IsActive(MotionSensorType sensorType)
 {
     return sensorStatus[sensorType];
 }
Example #20
0
        /// <summary>
        /// Start the specified sensorType and interval.
        /// </summary>
        /// <param name="sensorType">Sensor type.</param>
        /// <param name="interval">Interval.</param>
        public void Start(MotionSensorType sensorType, MotionSensorDelay interval = MotionSensorDelay.Default)
        {
            uint delay = (uint)((double)Convert.ToInt32(interval) / ms);

            switch (sensorType)
            {
            case MotionSensorType.Accelerometer:
                if (accelerometer != null)
                {
                    accelerometer.Interval     = delay;
                    accelerometer.DataUpdated += AccelerometerDataUpdated;
                    accelerometer.Start();
                    sensorStatus[sensorType] = true;
                }
                else
                {
                    Debug.WriteLine("Accelerometer not available");
                }
                break;

            case MotionSensorType.Gyroscope:
                if (gyroscope != null)
                {
                    gyroscope.Interval     = delay;
                    gyroscope.DataUpdated += GyroscopeDataUpdated;
                    gyroscope.Start();
                    sensorStatus[sensorType] = true;
                }
                else
                {
                    Debug.WriteLine("Gyroscope not available");
                }
                break;

            case MotionSensorType.Magnetometer:
                if (magnetometer != null)
                {
                    magnetometer.Interval     = delay;
                    magnetometer.DataUpdated += MagnetometerDataUpdated;
                    magnetometer.Start();
                    sensorStatus[sensorType] = true;
                }
                else
                {
                    Debug.WriteLine("Magnetometer not available");
                }
                break;

            case MotionSensorType.Compass:

                if (orientation != null)
                {
                    orientation.Interval     = delay;
                    orientation.DataUpdated += OrientationDataUpdated;
                    orientation.Start();
                    sensorStatus[sensorType] = true;
                }
                else
                {
                    Debug.WriteLine("OrientationSensor not available");
                }
                break;
            }
        }
      /// <summary>
      /// Start the specified sensorType and interval.
      /// </summary>
      /// <param name="sensorType">Sensor type.</param>
      /// <param name="interval">Interval.</param>
      public void Start(MotionSensorType sensorType, MotionSensorDelay interval = MotionSensorDelay.Default)
      {


          SensorDelay delay = SensorDelay.Normal;
          switch (interval)
          {
              case MotionSensorDelay.Fastest:
                  delay = SensorDelay.Fastest;
                  break;
              case MotionSensorDelay.Game:
                  delay = SensorDelay.Game;
                  break;
              case MotionSensorDelay.Ui:
                  delay = SensorDelay.Ui;
                  break;

          }
          switch (sensorType)
          {
              case MotionSensorType.Accelerometer:
                  if (sensorAccelerometer != null)
                      sensorManager.RegisterListener(this, sensorAccelerometer, delay);
                  else
                      Console.WriteLine("Accelerometer not available");
                  break;
              case MotionSensorType.Gyroscope:
                  if (sensorGyroscope != null)
                      sensorManager.RegisterListener(this, sensorGyroscope, delay);
                  else
                      Console.WriteLine("Gyroscope not available");
                  break;
              case MotionSensorType.Magnetometer:
                  if (sensorMagnetometer != null)
                      sensorManager.RegisterListener(this, sensorMagnetometer, delay);
                  else
                      Console.WriteLine("Magnetometer not available");
                  break;
              case MotionSensorType.Compass:
                  if (sensorCompass != null)
                      sensorManager.RegisterListener(this, sensorCompass, delay);
                  else
                      Console.WriteLine("Compass not available");
                  break;
          
          }
          sensorStatus[sensorType] = true;

      }