public MainPage()
{
InitializeComponent();
BatteryLifeInSeconds = 18000;
LastCharge = 1F;
ElapsedTime = 0;
isEyeball = false;
Battery.BatteryInfoChanged += Battery_BatteryInfoChanged;
//https://www.youtube.com/watch?v=eDx8tbUrkP0
Device.StartTimer(TimeSpan.FromSeconds(1), () => {
Device.BeginInvokeOnMainThread(() =>
DisplayCountdown()
);
return(true);
});
Magnetometer.Start(SensorSpeed.UI);
Magnetometer.ReadingChanged += Magnetometer_ReadingChanged;
Compass.Start(SensorSpeed.UI);
Compass.ReadingChanged += Compass_ReadingChanged;
}
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 OnAppearing()
{
try
{
Magnetometer.ReadingChanged += OnMagnetometerReadingChanged;
if (!Magnetometer.IsMonitoring)
{
Magnetometer.Start(SensorSpeed.UI);
}
Accelerometer.ShakeDetected += OnShakeDetected;
Accelerometer.ReadingChanged += OnAccelerometerReadingChanged;
if (!Accelerometer.IsMonitoring)
{
Accelerometer.Start(SensorSpeed.UI);
}
Gyroscope.ReadingChanged += OnGyroscopeReadingChanged;
if (!Gyroscope.IsMonitoring)
{
Gyroscope.Start(SensorSpeed.UI);
}
}
catch (FeatureNotSupportedException ex)
{
Logger.Debug("Feature not supported: " + ex.Message);
}
}
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);
}
}
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 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 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>
/// Starts the magnetometer sensor.
/// </summary>
public void Start()
{
if (IsSupported() && !_magnetometer.IsSensing)
{
_magnetometer.DataUpdated += OnDataUpdated;
_magnetometer.Start();
}
}
protected override void OnAppearing()
{
Accelerometer.Start(SensorSpeed.UI);
Gyroscope.Start(SensorSpeed.UI);
Magnetometer.Start(SensorSpeed.UI);
Compass.Start(SensorSpeed.UI);
base.OnAppearing();
}
protected override void OnResume()
{
// Handle when your app resumes
if (DrivePage.isTiltEnabled)
{
Accelerometer.Start(SensorService.speed);
Magnetometer.Start(SensorService.speed);
}
}
public void StartReading(int reportInterval = -1)
{
if (reportInterval >= 0)
{
_magnetometer.Interval = (uint)reportInterval;
}
_magnetometer.DataUpdated += MagnetometerReadingChanged;
_magnetometer.Start();
}
/// <summary>
/// Starts sensor and registers listener to a sensor
/// </summary>
/// <param name="listener">Event handler to listen sensor events</param>
public void Start(EventHandler <SensorEventArgs> listener)
{
handler = (sender, e) =>
{
listener?.Invoke(this,
new SensorEventArgs(new List <float>()
{
e.X, e.Y, e.Z
}));
};
sensor.DataUpdated += handler;
sensor.Start();
}
/// <summary>
/// Starts the magnetometer sensor.
/// </summary>
public void Start()
{
if (!IsSupported())
{
return;
}
if (_magnetometer.IsSensing)
{
return;
}
_magnetometer.DataUpdated += OnDataUpdated;
_magnetometer.Start();
}
public void StartSensors()
{
try
{
Accelerometer.Start(SensorSpeed.Default);
Magnetometer.Start(SensorSpeed.Default);
Gyroscope.Start(SensorSpeed.Default);
OrientationSensor.Start(SensorSpeed.Default);
Accelerometer.ReadingChanged += Accelerometer_ReadingChanged;
Magnetometer.ReadingChanged += Magnetometer_ReadingChanged;
Gyroscope.ReadingChanged += Gyrotometer_ReadingChanged;
OrientationSensor.ReadingChanged += OrientationSensor_ReadingChanged;
}
catch (Exception EX)
{
//Log.Error(TAG, EX.GetBaseException().ToString());
}
}
public MainPage()
{
InitializeComponent();
Magnetometer.Start(SensorSpeed.UI);
Magnetometer.ReadingChanged += (s, e) =>
{
x.Text = e.Reading.MagneticField.X.ToString();
y.Text = e.Reading.MagneticField.Y.ToString();
z.Text = e.Reading.MagneticField.Z.ToString();
var absVal = Convert.ToInt32(Math.Round(e.Reading.MagneticField.Length()));
abs.Text = absVal.ToString();
this.BackgroundColor = Color.FromRgb(255 - (absVal <= 510 ? absVal / 2 : 255), 0 + (absVal <= 510 ? absVal / 2 : 255), 0);
if (absVal >= 300)
{
Vibration.Vibrate(50);
}
};
}
public Task Start()
{
try
{
Magnetometer.Start(speed);
}
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;
}
void Start()
{
this._sensingData.ID = "charlie";
this._sensingData.DeviceName = DeviceInfo.Name;
if (!Compass.IsMonitoring)
{
Compass.ReadingChanged += Compass_ReadingChanged;
Compass.Start(SensorSpeed.Fastest);
}
if (!Accelerometer.IsMonitoring)
{
Accelerometer.ReadingChanged += Accelerometer_Essentials_ReadingChanged;
Accelerometer.Start(SensorSpeed.Fastest);
}
if (!Gyroscope.IsMonitoring)
{
Gyroscope.ReadingChanged += Gyroscope_ReadingChanged;
Gyroscope.Start(SensorSpeed.Fastest);
}
if (!Magnetometer.IsMonitoring)
{
Magnetometer.ReadingChanged += Magnetometer_ReadingChanged;
Magnetometer.Start(SensorSpeed.Fastest);
}
// device-specific sensor readings
if (Device.RuntimePlatform.Equals((Device.Android)))
{
MessagingCenter.Subscribe <Sensors.Android.LinearAcceleration>(this, Sensors.Android.SubscriberMessage.LinearAcceleration, (linear_acceleration) =>
{
this.LinearAccelerometer_Android_ReadingChanged(linear_acceleration);
});
}
}
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 OnAppearing()
{
base.OnAppearing();
Magnetometer?.Start();
}
public void Magnetometer_Stop() => Assert.Throws <NotImplementedInReferenceAssemblyException>(() => Magnetometer.Start(SensorSpeed.Normal));
public void Monitor_On_NetStandard() => Assert.Throws <NotImplementedInReferenceAssemblyException>(() => Magnetometer.Start(SensorSpeed.Normal));
/// <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;
}
}
/// <inheritdoc /> public void Start(SensorSpeed sensorSpeed = SensorSpeed.Default) => Magnetometer.Start(sensorSpeed);
void StartButton_Clicked(object sender, EventArgs e)
{
Magnetometer.Start((SensorSpeed)speedPicker.SelectedIndex);
}