protected override async Task OnReceiveAsync(Context?context, Intent?intent)
{
if (ActivityRecognitionResult.HasResult(intent) && Process != null)
{
var result = ActivityRecognitionResult.ExtractResult(intent);
await Process(result);
}
}
protected override void OnHandleIntent(Intent intent)
{
UpdateMinConfidence();
if (ActivityRecognitionResult.HasResult(intent))
{
HandleActivityRecognitionResult(intent);
}
}
void HandleActivityRecognition(Intent intent)
{
var result = ActivityRecognitionResult.ExtractResult(intent);
var activity = result.MostProbableActivity;
TripDebugLog.LogActivityEvent(activity.Type, activity.Confidence);
// We don't care about tilting activity
if (activity.Type == DetectedActivity.Tilting)
{
return;
}
var prevBikingState = currentBikingState;
switch (currentBikingState)
{
case BikingState.NotBiking:
if (activity.Type == DetectedActivity.OnBicycle && activity.Confidence >= StrongConfidence)
{
SetLocationUpdateEnabled(true);
currentBikingState = BikingState.Biking;
}
break;
case BikingState.Biking:
CheckDelayedFinishTripConditions(activity);
break;
case BikingState.MovingNotOnBike:
if (activity.Type == DetectedActivity.OnBicycle && activity.Confidence >= StrongConfidence)
{
currentBikingState = BikingState.Biking;
Interlocked.Increment(ref graceID);
}
break;
case BikingState.InGrace:
if (activity.Type == DetectedActivity.OnBicycle && activity.Confidence >= WeakConfidence)
{
currentBikingState = BikingState.Biking;
Interlocked.Increment(ref graceID);
}
else
{
CheckDelayedFinishTripConditions(activity);
}
break;
}
Log.Debug("ActivityHandler", "Activity ({0} w/ {1}%): {2} -> {3}",
activity.Type, activity.Confidence, prevBikingState, currentBikingState);
if (prevBikingState != currentBikingState)
{
OnBikingStateChanged(prevBikingState, currentBikingState);
}
}
protected override void OnHandleIntent(Intent intent)
{
var result = ActivityRecognitionResult.ExtractResult(intent);
if (result == null)
{
return;
}
var broadcastIntent = new Intent(Constants.BroadcastAction);
broadcastIntent.PutExtra(Constants.ActivitiesExtra, result);
LocalBroadcastManager.GetInstance(Application.Context).SendBroadcast(broadcastIntent);
}
public override void OnReceive(Context context, Intent intent) => this.Execute(async() =>
{
// DELETE FROM motion_activity WHERE Timestamp < DateTimeOffset.UtcNow.AddDays(-30).Ticks
if (!ActivityRecognitionResult.HasResult(intent))
{
return;
}
var result = ActivityRecognitionResult.ExtractResult(intent);
var type = MotionActivityType.Unknown;
foreach (var activity in result.ProbableActivities)
{
switch (activity.Type)
{
case DetectedActivity.InVehicle:
type |= MotionActivityType.Automotive;
break;
case DetectedActivity.OnBicycle:
type |= MotionActivityType.Cycling;
break;
case DetectedActivity.OnFoot:
type |= MotionActivityType.Walking;
break;
case DetectedActivity.Running:
type |= MotionActivityType.Running;
break;
case DetectedActivity.Still:
type |= MotionActivityType.Stationary;
break;
case DetectedActivity.Walking:
type |= MotionActivityType.Walking;
break;
}
}
var confidence = this.ToConfidence(result.MostProbableActivity.Confidence);
var timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
await this.database.ExecuteNonQuery(
$"INSERT INTO motion_activity(Event, Confidence, Timestamp) VALUES ({(int)type}, {(int)confidence}, {timestamp})"
);
this.messageBus.Publish(new MotionActivityEvent(type, confidence, DateTimeOffset.UtcNow));
});
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})");
}
}
protected override void OnHandleIntent(Intent intent)
{
var result = ActivityRecognitionResult.ExtractResult(intent);
var localIntent = new Intent(Constants.BroadcastAction);
IList <DetectedActivity> detectedActivities = result.ProbableActivities;
Log.Info(TAG, "activities detected");
foreach (DetectedActivity da in detectedActivities)
{
Log.Info(TAG, Constants.GetActivityString(
ApplicationContext, da.Type) + " " + da.Confidence + "%"
);
}
localIntent.PutExtra(Constants.ActivityExtra, detectedActivities.ToArray());
LocalBroadcastManager.GetInstance(this).SendBroadcast(localIntent);
}
bool OnHandleIntent(Intent intent)
{
if (intent != null)
{
if (intent.Action == FinishTripAction)
{
FinishTrip();
}
else if (ActivityRecognitionResult.HasResult(intent))
{
HandleActivityRecognition(intent);
}
else if (intent.HasExtra(FusedLocationProviderApi.KeyLocationChanged))
{
HandleLocationUpdate(intent);
}
}
return(currentBikingState != BikingState.NotBiking);
}
protected override void OnHandleIntent(Intent intent)
{
var result = ActivityRecognitionResult.ExtractResult(intent);
IList <DetectedActivity> detectedActivities = result.ProbableActivities;
PreferenceManager.GetDefaultSharedPreferences(this)
.Edit()
.PutString(Constants.KeyDetectedActivities,
Utils.DetectedActivitiesToJson(detectedActivities))
.Apply();
Log.Info(TAG, "activities detected");
foreach (DetectedActivity da in detectedActivities)
{
Log.Info(TAG, Utils.GetActivityString(
ApplicationContext, da.Type) + " " + da.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 override void OnReceive(Context context, Intent intent)
{
base.OnReceive(Application.Context, intent);
if (ActivityRecognitionResult.HasResult(intent))
{
ActivityRecognitionResult result = ActivityRecognitionResult.ExtractResult(intent);
if (result != null)
{
var motion = result.MostProbableActivity.GetMotionType();
if (motion != Core.Models.MotionType.Unknown)
{
Mvx.Resolve <IMotionActivity>().MotionType = motion;
}
//new Handler(context.MainLooper).Post(() =>
//{
// Toast.MakeText(context, motion.ToString(), ToastLength.Short).Show();
//});
}
}
}
public static DateTime GetDateTime(this ActivityRecognitionResult result)
{
return(ReferenceDate.AddMilliseconds(result.Time));
}
