public static MotionType GetMotionType(this DetectedActivity detectedAcitvity)
{
switch (detectedAcitvity.Type)
{
case DetectedActivity.InVehicle:
return(MotionType.Automotive);
case DetectedActivity.OnBicycle:
return(MotionType.Automotive);
case DetectedActivity.OnFoot:
return(MotionType.Walking);
case DetectedActivity.Running:
return(MotionType.Running);
case DetectedActivity.Still:
return(MotionType.Still);
case DetectedActivity.Tilting:
return(MotionType.Unknown);
case DetectedActivity.Walking:
return(MotionType.Walking);
default:
return(MotionType.Unknown);
}
}
void CheckDelayedFinishTripConditions(DetectedActivity activity)
{
// Only increment the grace ID (thus invalidating existing delayed finish transactions
// if the previous state was an active one.
bool shouldIncrementGraceID =
currentBikingState != BikingState.InGrace && currentBikingState != BikingState.MovingNotOnBike;
// The service mistakenly thinks fast biking is a vehicule activity so we require an even stronger confidence
if ((activity.Type == DetectedActivity.OnFoot && activity.Confidence > StrongConfidence) ||
(activity.Type == DetectedActivity.InVehicle && activity.Confidence > ExtremeConfidence))
{
var id = graceID;
if (shouldIncrementGraceID)
{
id = Interlocked.Increment(ref graceID);
}
currentBikingState = BikingState.MovingNotOnBike;
StartDelayedFinishTrip(id, (long)MovingNotBikePeriod.TotalMilliseconds);
}
else if ((activity.Type == DetectedActivity.OnBicycle && activity.Confidence < WeakConfidence) ||
(activity.Type != DetectedActivity.OnBicycle && activity.Confidence >= StrongConfidence))
{
var id = graceID;
if (shouldIncrementGraceID)
{
id = Interlocked.Increment(ref graceID);
}
if (currentBikingState != BikingState.InGrace)
{
currentBikingState = BikingState.InGrace;
StartDelayedFinishTrip(id, (long)GracePeriod.TotalMilliseconds);
}
}
}
/// <summary>
/// Return <see cref="DetectedActivity.Type"/> as human readable string
/// </summary>
/// <param name="detectedActivity"></param>
/// <returns>Human readable string</returns>
public static string ToHumanText(this DetectedActivity detectedActivity)
{
switch (detectedActivity.Type)
{
case DetectedActivity.InVehicle:
return("in_vehicle");
case DetectedActivity.OnBicycle:
return("on_bicycle");
case DetectedActivity.OnFoot:
return("on_foot");
case DetectedActivity.Still:
return("still");
case DetectedActivity.Unknown:
return("unknown");
case DetectedActivity.Tilting:
return("tilting");
default:
return("unkown result");
}
}
private void BroadcastDetectedActivity(DetectedActivity activitiy)
{
Intent broadcastIntent = new Intent(BroadcastAction);
broadcastIntent.PutExtra(KeyActivity, activitiy);
SendBroadcast(broadcastIntent);
}
private void ChangeBluetooth(DetectedActivity activity)
{
if (activity.Type == DetectedActivity.InVehicle)
{
Log.Info(Tag, $"Detected ({activity.ToHumanText()}) with confidence ({activity.Confidence}), so enabling bluetooth");
EnableBluetooth();
}
else
{
DisableBluetooth();
}
}
private void HandleActivityRecognitionResult(Intent intent)
{
var result = ActivityRecognitionResult.ExtractResult(intent);
DetectedActivity activity = result.MostProbableActivity;
int confidence = activity.Confidence;
if (IsConfident(confidence))
{
HandleDetectedActivity(activity);
}
else
{
Log.Verbose(Tag, $"Ignored detected activity ({activity.ToHumanText()}) because of low confidence ({confidence})");
}
}
private static DetectedMotion GetMostProbableMotion(ActivityRecognitionResult activityResult)
{
const int threshold = 5;
DetectedActivity first = activityResult.MostProbableActivity;
int type = first.Type;
// OnFoot activity is sent for all motion activities, it's redundant so we remove it...
if (type == DetectedActivity.OnFoot)
{
DetectedActivity second = activityResult.ProbableActivities.Where(da => da.Type != DetectedActivity.OnFoot)
.DefaultIfEmpty()
.Aggregate((max, x) => max.Confidence < x.Confidence ? x : max);
if (second != null && second.Confidence >= first.Confidence - threshold)
{
return(new DetectedMotion(second.Confidence, second.GetMotionType()));
}
}
return(new DetectedMotion(first.Confidence, first.GetMotionType()));
}
public DetectedActivitiesEventArgs(DetectedActivity[] activities)
{
this.MostProbable = activities[0];
this.SecondMostProbable = activities[1];
}
void CheckDelayedFinishTripConditions(DetectedActivity activity)
{
// Only increment the grace ID (thus invalidating existing delayed finish transactions
// if the previous state was an active one.
bool shouldIncrementGraceID =
currentBikingState != BikingState.InGrace && currentBikingState != BikingState.MovingNotOnBike;
// The service mistakenly thinks fast biking is a vehicule activity so we require an even stronger confidence
if ((activity.Type == DetectedActivity.OnFoot && activity.Confidence > StrongConfidence)
|| (activity.Type == DetectedActivity.InVehicle && activity.Confidence > ExtremeConfidence)) {
var id = graceID;
if (shouldIncrementGraceID)
id = Interlocked.Increment (ref graceID);
currentBikingState = BikingState.MovingNotOnBike;
StartDelayedFinishTrip (id, (long)MovingNotBikePeriod.TotalMilliseconds);
} else if ((activity.Type == DetectedActivity.OnBicycle && activity.Confidence < WeakConfidence)
|| (activity.Type != DetectedActivity.OnBicycle && activity.Confidence >= StrongConfidence)) {
var id = graceID;
if (shouldIncrementGraceID)
id = Interlocked.Increment (ref graceID);
if (currentBikingState != BikingState.InGrace) {
currentBikingState = BikingState.InGrace;
StartDelayedFinishTrip (id, (long)GracePeriod.TotalMilliseconds);
}
}
}
public Task <DetectedActivityResponse> GetDetectedActivityAsync()
{
return(DetectedActivity.AsAsync <DetectedActivityResponse>());
}
private void HandleDetectedActivity(DetectedActivity activity)
{
ChangeBluetooth(activity);
BroadcastDetectedActivity(activity);
}
