public void ControlSunscribe(bool flag)
{
try
{
if (Magnetometer.IsMonitoring && !flag)
{
Magnetometer.Stop();
MagnetometerWatch.Reset();
}
else if (!Magnetometer.IsMonitoring && flag)
{
MagnetometerWatch.Start();
Magnetometer.Start(Config.sensorSpeed);
}
else
{
//Dont think anything is needed here
}
}
catch (FeatureNotEnabledException ex)
{
}
catch (Exception ex)
{
}
}
public override void OnDisappearing()
{
try
{
Magnetometer.ReadingChanged -= OnMagnetometerReadingChanged;
if (Magnetometer.IsMonitoring)
{
Magnetometer.Stop();
}
Accelerometer.ShakeDetected -= OnShakeDetected;
Accelerometer.ReadingChanged -= OnAccelerometerReadingChanged;
if (Accelerometer.IsMonitoring)
{
Accelerometer.Stop();
}
Gyroscope.ReadingChanged -= OnGyroscopeReadingChanged;
if (Gyroscope.IsMonitoring)
{
Gyroscope.Stop();
}
}
catch (FeatureNotSupportedException ex)
{
Logger.Debug("Feature not supported: " + ex.Message);
}
}
public async Task Stop_Monitor(SensorSpeed sensorSpeed)
{
// TODO: the test runner app (UI version) should do this, until then...
if (!HardwareSupport.HasMagnetometer)
{
return;
}
var tcs = new TaskCompletionSource <MagnetometerData>();
Magnetometer.ReadingChanged += Magnetometer_ReadingChanged;
Magnetometer.Start(sensorSpeed);
void Magnetometer_ReadingChanged(object sender, MagnetometerChangedEventArgs e)
{
tcs.TrySetResult(e.Reading);
}
var d = await tcs.Task;
Magnetometer.Stop();
Magnetometer.ReadingChanged -= Magnetometer_ReadingChanged;
Assert.False(Magnetometer.IsMonitoring);
}
public void ToggleMagnetometer()
{
try
{
if (Magnetometer.IsMonitoring)
{
Magnetometer.Stop();
}
else
{
Magnetometer.Start(speed);
}
}
catch (FeatureNotSupportedException fnsEx)
{
// Feature not supported on device
Console.WriteLine(fnsEx);
exception.Text = "Feature not supported on device";
}
catch (Exception ex)
{
// Other error has occurred.
Console.WriteLine(ex);
exception.Text = "Other error has occurred";
}
}
public void ToggleMetrics(bool isToogled)
{
try
{
if (isToogled)
{
Accelerometer.Start(speed);
//Barometer.Start(speed);
Compass.Start(speed);
Gyroscope.Start(speed);
Magnetometer.Start(speed);
OrientationSensor.Start(speed);
}
else
{
Accelerometer.Stop();
//Barometer.Stop();
Compass.Stop();
Gyroscope.Stop();
Magnetometer.Stop();
OrientationSensor.Stop();
}
}
catch (FeatureNotSupportedException)
{
ShowNotSupportedError();
}
catch (Exception ex)
{
ShowError(ex.Message);
}
}
void Stop()
{
if (Compass.IsMonitoring)
{
Compass.ReadingChanged -= Compass_ReadingChanged;
Compass.Stop();
}
if (Accelerometer.IsMonitoring)
{
Accelerometer.ReadingChanged -= Accelerometer_Essentials_ReadingChanged;
Accelerometer.Stop();
}
if (Gyroscope.IsMonitoring)
{
Gyroscope.ReadingChanged -= Gyroscope_ReadingChanged;
Gyroscope.Stop();
}
if (Magnetometer.IsMonitoring)
{
Magnetometer.ReadingChanged -= Magnetometer_ReadingChanged;
Magnetometer.Stop();
}
// device-specific sensor readings
if (Device.RuntimePlatform.Equals((Device.Android)))
{
MessagingCenter.Unsubscribe <Sensors.Android.LinearAcceleration>(this, Sensors.Android.SubscriberMessage.LinearAcceleration);
}
}
public IObservable <MotionReading> WhenReadingTaken()
{
this.observable = this.observable ?? Observable.Create <MotionReading>(ob =>
{
var handler = new EventHandler <MagnetometerDataUpdatedEventArgs>((sender, args) =>
ob.OnNext(new MotionReading(args.X, args.Y, args.Z))
);
var sensor = new Magnetometer
{
Interval = 250
};
sensor.DataUpdated += handler;
sensor.Start();
return(() =>
{
sensor.Stop();
sensor.DataUpdated -= handler;
sensor.Dispose();
});
})
.Publish()
.RefCount();
return(this.observable);
}
public void ToggleSensor()
{
try
{
if (Accelerometer.IsMonitoring || Gyroscope.IsMonitoring)
{
Accelerometer.Stop();
Magnetometer.Stop();
}
else
{
Accelerometer.Start(speed);
Magnetometer.Start(speed);
}
}
catch (FeatureNotSupportedException fnsEx)
{
// Feature not supported on device
Debug.WriteLine(fnsEx.Message);
}
catch (Exception ex)
{
// Other error has occurred.
Debug.WriteLine(ex.Message);
}
}
public void ToggleMagnetometer()
{
try
{
if (Magnetometer.IsMonitoring)
{
Magnetometer.Stop();
this.lblResult.Text += "Stop!!!" + Environment.NewLine;
}
else
{
Magnetometer.Start(speed);
this.lblResult.Text = "";
}
}
catch (FeatureNotSupportedException fnsEx)
{
// Feature not supported on device
this.lblResult.Text = fnsEx.ToString();
}
catch (Exception ex)
{
// Other error has occurred.
this.lblResult.Text = ex.ToString();
}
}
/// <summary>
/// Stops the magnetometer sensor.
/// </summary>
public void Stop()
{
if (IsSupported() && _magnetometer.IsSensing)
{
_magnetometer.DataUpdated -= OnDataUpdated;
_magnetometer.Stop();
}
}
protected override void OnDisappearing()
{
Accelerometer.Stop();
Gyroscope.Stop();
Magnetometer.Stop();
Compass.Stop();
base.OnDisappearing();
}
protected override void OnSleep()
{
// Handle when your app sleeps
if (DrivePage.isTiltEnabled)
{
Accelerometer.Stop();
Magnetometer.Stop();
}
}
public void StopSensors()
{
Accelerometer.Stop();
Magnetometer.Stop();
Gyroscope.Stop();
Accelerometer.ReadingChanged -= Accelerometer_ReadingChanged;
Magnetometer.ReadingChanged -= Magnetometer_ReadingChanged;
Gyroscope.ReadingChanged -= Gyrotometer_ReadingChanged;
OrientationSensor.ReadingChanged -= OrientationSensor_ReadingChanged;
_instance = null;
}
/// <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>
/// Stops the magnetometer sensor.
/// </summary>
public void Stop()
{
if (!IsSupported())
{
return;
}
if (_magnetometer.IsSensing)
{
_magnetometer.DataUpdated -= OnDataUpdated;
_magnetometer.Stop();
}
}
public Task Stop()
{
try
{
Magnetometer.Stop();
}
catch (FeatureNotSupportedException fnsEx)
{
// Feature not supported on device
Console.WriteLine(fnsEx.Message);
}
catch (Exception ex)
{
// Other error has occurred.
Console.WriteLine(ex.Message);
}
return(Task.CompletedTask);
}
public async Task Monitor(SensorSpeed sensorSpeed)
{
if (!TestSupported)
{
return;
}
var tcs = new TaskCompletionSource <MagnetometerData>();
Magnetometer.ReadingChanged += Magnetometer_ReadingChanged;
Magnetometer.Start(sensorSpeed);
void Magnetometer_ReadingChanged(MagnetometerChangedEventArgs e)
{
tcs.TrySetResult(e.Reading);
}
var d = await tcs.Task;
Magnetometer.Stop();
Magnetometer.ReadingChanged -= Magnetometer_ReadingChanged;
}
public void ToggleMagnetometer_OnToggled(object sender, ToggledEventArgs e)
{
try
{
if (Magnetometer.IsMonitoring)
{
Magnetometer.Stop();
}
else
{
Magnetometer.Start(speed);
}
}
catch (FeatureNotSupportedException fnsEx)
{
DisplayAlert("Alert", "Magnetometer not supported", "OK");
Console.WriteLine("Error!" + fnsEx);
}
catch (Exception ex)
{
DisplayAlert("Alert", "An error has occurred using magnetometer", "OK");
Console.WriteLine("Error!" + ex);
}
}
protected override void OnDisappearing()
{
base.OnDisappearing();
Magnetometer?.Stop();
}
public void Magnetometer_Start() => Assert.Throws <NotImplementedInReferenceAssemblyException>(() => Magnetometer.Stop());
public void StopReading()
{
_magnetometer.DataUpdated -= MagnetometerReadingChanged;
_magnetometer.Stop();
}
public Magnetometer_Tests()
{
Magnetometer.Stop();
}
/// <inheritdoc /> public void Stop() => Magnetometer.Stop();
void StopButton_Clicked(object sender, EventArgs e)
{
Magnetometer.Stop();
}
/// <summary>
/// Stops sensor and unregisters the listener from a sensor
/// </summary>
/// <param name="listener">Event handler registered</param>
public void Stop(EventHandler <SensorEventArgs> listener)
{
sensor.Stop();
sensor.DataUpdated -= handler;
}