public bool Start(SensorType sensorType, SensorDelay delay, Action<SensorEvent> sensorAction)
{
this.action = sensorAction;
var sensor = this.sensorManager.GetDefaultSensor(sensorType);
var result = this.sensorManager.RegisterListener(this, sensor, delay);
return result;
}
public void Start(SensorType Tip, 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;
}
//TODO IMPLEMENT IF NECESSARY! s switch stavkom
if (sensorLinearAcceleration != null)
{
sensorManager.RegisterListener(this, sensorLinearAcceleration, delay);
}
else
{
Console.WriteLine("Accelerometer not available");
}
sensorStatus[Tip] = true;
}
internal static SensorNotifyRate ExchangeNotifyRate(SensorDelay sensorDelay)
{
SensorNotifyRate ret = SensorNotifyRate.Normal;
switch (sensorDelay)
{
case SensorDelay.Fastest:
ret = SensorNotifyRate.Fastest;
break;
case SensorDelay.Game:
ret = SensorNotifyRate.Game;
break;
case SensorDelay.Ui:
ret = SensorNotifyRate.Ui;
break;
case SensorDelay.Normal:
ret = SensorNotifyRate.Normal;
break;
}
return(ret);
}
public void Start()
{
lock (_locker)
{
if (_listening)
{
return;
}
else
{
// use the largest delay that will provide samples at least as fast as the desired rate: https://developer.android.com/guide/topics/sensors/sensors_overview.html#sensors-monitor
SensorDelay androidSensorDelay = SensorDelay.Fastest;
if (_sensorDelay.HasValue)
{
long sensorDelayMicroseconds = _sensorDelay.Value.Ticks / 10;
if (sensorDelayMicroseconds >= 200000)
{
androidSensorDelay = SensorDelay.Normal;
}
else if (sensorDelayMicroseconds >= 60000)
{
androidSensorDelay = SensorDelay.Ui;
}
else if (sensorDelayMicroseconds >= 20000)
{
androidSensorDelay = SensorDelay.Game;
}
}
_sensorManager.RegisterListener(this, _sensor, androidSensorDelay);
_listening = true;
}
}
}
public AndroidSensorListener(SensorType sensorType, SensorDelay sensorDelay, Action <SensorStatus> sensorAccuracyChangedCallback, Action <SensorEvent> sensorValueChangedCallback)
{
_sensorType = sensorType;
_sensorDelay = sensorDelay;
_sensorAccuracyChangedCallback = sensorAccuracyChangedCallback;
_sensorValueChangedCallback = sensorValueChangedCallback;
_listening = false;
}
public AndroidSensorListener(SensorType sensorType, SensorDelay sensorDelay, Action<SensorStatus> sensorAccuracyChangedCallback, Action<SensorEvent> sensorValueChangedCallback)
{
_sensorType = sensorType;
_sensorDelay = sensorDelay;
_sensorAccuracyChangedCallback = sensorAccuracyChangedCallback;
_sensorValueChangedCallback = sensorValueChangedCallback;
_listening = false;
}
public async Task Start(SensorDelay delay = SensorDelay.Game, OnError errorAction = OnError.Toast)
{
try
{
DoStart(delay);
IsActive = true;
}
catch (Exception ex) { await errorAction.Apply(ex); }
}
internal SensorListener(bool useSyncContext, Action <CompassData> handler, SensorDelay delay)
{
this.handler = handler;
this.useSyncContext = useSyncContext;
accelerometer = Platform.SensorManager.GetDefaultSensor(SensorType.Accelerometer);
magnetometer = Platform.SensorManager.GetDefaultSensor(SensorType.MagneticField);
Platform.SensorManager.RegisterListener(this, accelerometer, delay);
Platform.SensorManager.RegisterListener(this, magnetometer, delay);
}
protected override void DoStart(SensorDelay _)
{
if (!IsAvailable())
{
throw new Exception("Compass is not available on this device.");
}
LocationManager.UpdatedHeading += HandleChanged;
LocationManager.StartUpdatingHeading();
}
protected override void DoStart(SensorDelay delay)
{
if (!IsAvailable())
{
throw new Exception("Accelerometer sensor is not available on this device.");
}
MotionManager.AccelerometerUpdateInterval = (int)delay * 0.001;
MotionManager.StartAccelerometerUpdates(NSOperationQueue.CurrentQueue, HandleChanged);
}
public void RegisterSensorListener(SensorDelay sensorDelay)
{
#if UNITY_ANDROID
if (Application.platform == RuntimePlatform.Android)
{
jo.CallStatic("registerSensorListener", (int)sensorDelay);
}
else
{
Message("warning: must run in actual android device");
}
#endif
}
public void register(string sensorName, SensorDelay delay = SensorDelay.Normal)
{
if (string.IsNullOrWhiteSpace(sensorName))
{
throw new LuaException("sensorName = null");
}
var sensor = getSensor(sensorName);
if (sensor == null)
{
}
}
/// <summary>
/// Starts the pedometer background service.
/// note: when you close the app the service will stop
/// and restart again and run even the app is close to
/// continue counting steps
/// note: without starting this you will not get the
/// callback so start this before doing any thing else
/// </summary>
/// <param name="sensorType">Sensor type.</param>
public void StartPedometerService(SensorDelay sensorType)
{
int selectedSensorType = (int)sensorType;
Message("check selected sensor type: " + selectedSensorType);
#if UNITY_ANDROID
if (Application.platform == RuntimePlatform.Android)
{
jo.CallStatic("startPedometerService", selectedSensorType);
}
else
{
Message("warning: must run in actual android device");
}
#endif
}
protected override void DoStart(SensorDelay delay)
{
if (EnvironmentSimulator.Accelerometer != null)
{
EnvironmentSimulator.Accelerometer.Changed += OnChanged;
}
else
{
if (Sensor == null)
{
throw new Exception("Accelerometer sensor is not available on this device.");
}
Sensor.ReportInterval = (uint)delay;
Sensor.ReadingChanged += Sensor_ReadingChanged;
}
}
public DeviceOrientationEventListener
(
Context eventContext,
SensorDelay sensorDelay,
Action <int> orientationChanged
)
: base(eventContext,
sensorDelay)
{
_orientationChanged = orientationChanged;
for (int retryNumber = 0; retryNumber < 3; retryNumber++)
{
while (CanDetectOrientation() == false)
{
Thread.Sleep(200);
}
}
}
/// <summary>
/// Start the specified sensorType and interval.
/// </summary>
/// <param name="sensorType">Sensor type.</param>
/// <param name="interval">Interval.</param>
public void StartAll(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;
}
if (sensorAccelerometer != null)
{
sensorManager.RegisterListener(this, sensorAccelerometer, delay);
sensorStatus[SensorType.Accelerometer] = true;
}
else
{
Console.WriteLine("Accelerometer not available");
}
if (sensorLinearAcceleration != null)
{
sensorManager.RegisterListener(this, sensorLinearAcceleration, delay);
sensorStatus[SensorType.LinearAcceleration] = true;
}
else
{
Console.WriteLine("LinearAcceleration not available");
}
}
// ===========================================================
// Constructors
// ===========================================================
public AccelerometerSensorOptions(/* final */ SensorDelay pSensorDelay)
{
this.mSensorDelay = pSensorDelay;
}
protected override void DoStart(SensorDelay delay)
{
OnChanged(false);
}
public OrientationListener(Context context, SensorDelay rate)
: base(context, rate)
{
}
public CameraOrientationEventListener(Context context, [GeneratedEnum] SensorDelay rate) : base(context, rate)
{
}
public OrientationEventListenerAnonymousInnerClassHelper(WebRTCDemo outerInstance, SensorDelay sensorDelayUI)
: base(outerInstance, SensorDelay.Ui)
{
this.outerInstance = outerInstance;
}
private void register(Sensor sensor, SensorDelay delay)
{
}
internal SensorListener(Sensor accelerometer, Sensor magnetometer, SensorDelay delay)
{
this.magnetometer = magnetometer;
this.accelerometer = accelerometer;
}
protected override void DoStart(SensorDelay delay)
{
UIDevice.CurrentDevice.ProximityMonitoringEnabled = true;
NSNotificationCenter.DefaultCenter.AddObserver(UIDevice.ProximityStateDidChangeNotification, (a) => OnChanged(UIDevice.CurrentDevice.ProximityState));
}
public Gyroscope(SensorDelay rate)
{
this.rate = rate;
}
/// <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;
}
internal SensorListener(string accelerometer, string magnetometer, SensorDelay delay, bool applyLowPassFilter)
{
this.magnetometer = magnetometer;
this.accelerometer = accelerometer;
this.applyLowPassFilter = applyLowPassFilter;
}
protected async Task RunSensor(SensorType sensorType, string expectedValue = "", SensorDelay sensorDelay = SensorDelay.Game)
{
var sensorName = Enum.GetName(typeof(SensorType), sensorType);
UpdateInfo($"Testing sensor {sensorName}...");
var token = SetupStopButtonOneShot("Sensor stopped.");
IProvider provider = GetProvider(sensorType);
provider.Delay = sensorDelay;
await RunSensor(provider, token, sensorName, expectedValue);
}
/// <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;
}
