private static List <DetectedMotion> CreatePossibleMotions(CMMotionActivity activity)
{
List <DetectedMotion> result = new List <DetectedMotion>();
int confidence = activity.Confidence.ToPercentage();
if (activity.Automotive)
{
result.Add(new DetectedMotion(confidence, MotionType.InVehicle));
}
else if (activity.Cycling)
{
result.Add(new DetectedMotion(confidence, MotionType.OnBicycle));
}
else if (activity.Running)
{
result.Add(new DetectedMotion(confidence, MotionType.Running));
}
else if (activity.Walking)
{
result.Add(new DetectedMotion(confidence, MotionType.Walking));
}
else if (activity.Stationary)
{
result.Add(new DetectedMotion(confidence, MotionType.Stationary));
}
else
{
result.Add(new DetectedMotion(confidence, MotionType.Unknown));
}
return(result);
}
public static MotionType GetMotionType(this CMMotionActivity motionActivity)
{
if (motionActivity.Automotive)
{
return(MotionType.InVehicle);
}
else if (motionActivity.Cycling)
{
return(MotionType.OnBicycle);
}
else if (motionActivity.Running)
{
return(MotionType.Running);
}
else if (motionActivity.Walking)
{
return(MotionType.Walking);
}
else if (motionActivity.Stationary)
{
return(MotionType.Stationary);
}
else
{
return(MotionType.Unknown);
}
}
void computeTotalDurations (CMMotionActivity[] activities)
{
WalkingDuration = 0;
RunningDuration = 0;
VehicularDuration = 0;
MovingDuration = 0;
for (int i = 0; i < activities.Length; ++i) {
if (i == activities.Length - 1)
return;
CMMotionActivity activity = activities [i];
CMMotionActivity nextActivity = activities [i + 1];
var duration = nextActivity.StartDate.SecondsSinceReferenceDate - activity.StartDate.SecondsSinceReferenceDate;
if (!activity.Unknown && !activity.Stationary)
MovingDuration += duration;
if (activity.Walking)
WalkingDuration += duration;
else if (activity.Running)
RunningDuration += duration;
else if (activity.Automotive)
VehicularDuration += duration;
}
}
public static ActivityType ActivityToType(CMMotionActivity activity)
{
if (activity.Walking)
{
return(ActivityType.Walking);
}
if (activity.Running)
{
return(ActivityType.Running);
}
if (activity.Automotive)
{
return(ActivityType.Driving);
}
if (activity.Stationary)
{
return(ActivityType.Stationary);
}
if (!activity.Unknown)
{
return(ActivityType.Moving);
}
else
{
return(ActivityType.None);
}
}
static void OnCMMotionActivity(CMMotionActivity activity)
{
// Convert CMMotionActivity to cross type
var activityTypes = GetActivities(activity);
OnChanged(_manager, new ActivityEventArgs(activityTypes));
}
public static bool IsSimilarToActivity (this CMMotionActivity activity, CMMotionActivity anotherActivity)
{
return activity.Walking && anotherActivity.Walking ||
activity.Running && anotherActivity.Running ||
activity.Automotive && anotherActivity.Automotive ||
activity.Cycling && anotherActivity.Cycling ||
activity.Stationary && anotherActivity.Stationary;
}
public static bool IsSimilarToActivity(this CMMotionActivity activity, CMMotionActivity anotherActivity)
{
return(activity.Walking && anotherActivity.Walking ||
activity.Running && anotherActivity.Running ||
activity.Automotive && anotherActivity.Automotive ||
activity.Cycling && anotherActivity.Cycling ||
activity.Stationary && anotherActivity.Stationary);
}
void SaveMotionActivity(CMMotionActivity activity)
{
recentMotionActivities.Insert(0, activity);
recentMotionActivities = recentMotionActivities.Where(c => c.StartDate.SecondsSinceReferenceDate <= 60).ToList <CMMotionActivity> ();
if (recentMotionActivities.Count > MotionManager.MaxActivitySamples)
{
recentMotionActivities.RemoveAt(recentPedometerData.Count - 1);
}
}
public Activity(CMMotionActivity activity, DateTime startDate, DateTime endDate, CMPedometerData pedometerData)
{
MotionActivity = activity;
this.startDate = startDate;
this.endDate = endDate;
timeInterval = (endDate - startDate).TotalSeconds;
if (!activity.Walking && !activity.Running)
{
return;
}
NumberOfSteps = pedometerData.NumberOfSteps.Int32Value;
Distance = pedometerData.Distance.Int32Value;
FloorsAscended = pedometerData.FloorsAscended.Int32Value;
FloorsDescended = pedometerData.FloorsDescended.Int32Value;
}
void GetMotionActivity(CMMotionActivity activity)
{
if (activity.Walking)
{
MotionType = MotionType.Walking;
}
else if (activity.Running)
{
MotionType = MotionType.Running;
}
else if (activity.Automotive)
{
MotionType = MotionType.Automotive;
}
else if (activity.Stationary || activity.Unknown)
{
MotionType = MotionType.Still;
}
//Core.Helpers.Log.LogMessage (_motionType.ToString ());
}
static MotionActivityEvent ToEvent(CMMotionActivity target)
{
var flags = MotionActivityType.Unknown;
if (!target.Unknown)
{
flags &= MotionActivityType.Unknown;
if (target.Automotive)
{
flags |= MotionActivityType.Automotive;
}
if (target.Cycling)
{
flags |= MotionActivityType.Cycling;
}
if (target.Running)
{
flags |= MotionActivityType.Running;
}
if (target.Stationary)
{
flags |= MotionActivityType.Stationary;
}
if (target.Walking)
{
flags |= MotionActivityType.Walking;
}
}
var conf = (MotionActivityConfidence)Enum.Parse(typeof(MotionActivityConfidence), target.Confidence.ToString(), true);
var activity = new MotionActivityEvent(flags, conf, (DateTime)target.StartDate);
return(activity);
}
static IDictionary <ActivityType, Confidence> GetActivities(CMMotionActivity activity)
{
var activities = new Dictionary <ActivityType, Confidence>();
var confidence = GetConfidence(activity.Confidence);
if (activity.Unknown)
{
activities.Add(ActivityType.Unknown, confidence);
}
if (activity.Stationary)
{
activities.Add(ActivityType.Stationary, confidence);
}
if (activity.Walking)
{
activities.Add(ActivityType.Walking, confidence);
}
if (activity.Running)
{
activities.Add(ActivityType.Running, confidence);
}
if (activity.Cycling)
{
activities.Add(ActivityType.Cycling, confidence);
}
if (activity.Automotive)
{
activities.Add(ActivityType.InVehicle, confidence);
}
return(activities);
}
void computeTotalDurations(CMMotionActivity[] activities)
{
WalkingDuration = 0;
RunningDuration = 0;
VehicularDuration = 0;
MovingDuration = 0;
for (int i = 0; i < activities.Length; ++i)
{
if (i == activities.Length - 1)
{
return;
}
CMMotionActivity activity = activities [i];
CMMotionActivity nextActivity = activities [i + 1];
var duration = nextActivity.StartDate.SecondsSinceReferenceDate - activity.StartDate.SecondsSinceReferenceDate;
if (!activity.Unknown && !activity.Stationary)
{
MovingDuration += duration;
}
if (activity.Walking)
{
WalkingDuration += duration;
}
else if (activity.Running)
{
RunningDuration += duration;
}
else if (activity.Automotive)
{
VehicularDuration += duration;
}
}
}
List<Tuple<CMMotionActivity, DateTime>> FindActivitySegments (CMMotionActivity[] activities)
{
var segments = new List<Tuple<CMMotionActivity, DateTime>> ();
for (int i = 0; i < activities.Length - 1; i++) {
var activity = activities [i];
var startDate = (DateTime)activity.StartDate;
var nextActivity = activities [++i];
var endDate = (DateTime)nextActivity.StartDate;
while (i < activities.Length - 1) {
if (!activity.IsSimilarToActivity (nextActivity))
break;
var previousActivityEnd = (DateTime)activities [i - 1].StartDate;
var secondsBetweenActivites = (endDate - previousActivityEnd).TotalSeconds;
if (secondsBetweenActivites >= 60 * 60)
break;
nextActivity = activities [++i];
endDate = (DateTime)nextActivity.StartDate;
}
nextActivity = (i != activities.Length - 1) ? activities [--i] : activities [i];
endDate = (DateTime)nextActivity.StartDate;
if ((endDate - startDate).TotalSeconds > 60)
segments.Add (new Tuple<CMMotionActivity, DateTime> (activity, endDate));
}
return segments;
}
public static bool HasActivitySignature(this CMMotionActivity activity)
{
return(activity.Walking || activity.Running || activity.Automotive || activity.Cycling || activity.Stationary);
}
async Task additionalProcessingOnAsync (CMMotionActivity[] activities)
{
computeTotalDurations (activities);
SignificantActivities = (await aggregateSignificantActivitiesAsync (activities)).ToList ();
}
public static ActivityType ActivityToType (CMMotionActivity activity)
{
if (activity.Walking)
return ActivityType.Walking;
if (activity.Running)
return ActivityType.Running;
if (activity.Automotive)
return ActivityType.Driving;
if (activity.Stationary)
return ActivityType.Stationary;
if (!activity.Unknown)
return ActivityType.Moving;
else
return ActivityType.None;
}
async Task<List<SignificantActivity>> aggregateSignificantActivitiesAsync (CMMotionActivity[] activities)
{
List<CMMotionActivity> filteredActivities = new List<CMMotionActivity> ();
// Skip all contiguous unclassified actiivty so that only one remains.
for (int i = 0; i < activities.Length; ++i) {
CMMotionActivity activity = activities [i];
filteredActivities.Add (activity);
if (!activity.Walking && !activity.Running && !activity.Automotive) {
while (++i < activities.Length) {
CMMotionActivity skipThisActivity = activities [i];
if (skipThisActivity.Walking || skipThisActivity.Running || skipThisActivity.Automotive) {
i = i - 1;
break;
}
}
}
}
// Ignore all low confidence activities.
for (int i = 0; i < filteredActivities.Count;) {
CMMotionActivity activity = filteredActivities[i];
if (activity.Confidence == CMMotionActivityConfidence.Low) {
filteredActivities.RemoveAt (i);
} else {
++i;
}
}
// Skip all unclassified activities if their duration is smaller than
// some threshold. This has the effect of coalescing the remaining med + high
// confidence activies together.
for (int i = 0; i < filteredActivities.Count - 1;){
CMMotionActivity activity = filteredActivities [i];
CMMotionActivity nextActivity = filteredActivities [i + 1];
var duration = nextActivity.StartDate.SecondsSinceReferenceDate - activity.StartDate.SecondsSinceReferenceDate;
if (duration < 60 * 3 && !activity.Walking && !activity.Running && !activity.Automotive) {
filteredActivities.RemoveAt (i);
} else {
++i;
}
}
// Coalesce activities where they differ only in confidence.
for (int i = 1; i < filteredActivities.Count;) {
CMMotionActivity prevActivity = filteredActivities [i - 1];
CMMotionActivity activity = filteredActivities [i];
if ((prevActivity.Walking && activity.Walking) ||
(prevActivity.Running && activity.Running) ||
(prevActivity.Automotive && activity.Automotive)) {
filteredActivities.RemoveAt (i);
} else {
++i;
}
}
// Finally transform into SignificantActivity;
List<SignificantActivity> significantActivities = new List<SignificantActivity> ();
for (int i = 0; i < filteredActivities.Count - 1; i++) {
CMMotionActivity activity = filteredActivities [i];
CMMotionActivity nextActivity = filteredActivities [i + 1];
if (!activity.Walking && !activity.Running && !activity.Automotive)
continue;
var significantActivity = new SignificantActivity (ActivityDataManager.ActivityToType (activity), activity.StartDate, nextActivity.StartDate);
try {
var pedometerData = await pedometer.QueryPedometerDataAsync (significantActivity.StartDate, significantActivity.EndDate);
significantActivity.StepCounts = pedometerData.NumberOfSteps.Int32Value;
} catch {
Console.WriteLine ("Error, unable to retrieve step counts for range {0}, {1}", significantActivity.StartDate.SecondsSinceReferenceDate, significantActivity.EndDate.SecondsSinceReferenceDate);
}
significantActivities.Add (significantActivity);
}
return significantActivities;
}
async Task <List <SignificantActivity> > aggregateSignificantActivitiesAsync(CMMotionActivity[] activities)
{
List <CMMotionActivity> filteredActivities = new List <CMMotionActivity> ();
// Skip all contiguous unclassified actiivty so that only one remains.
for (int i = 0; i < activities.Length; ++i)
{
CMMotionActivity activity = activities [i];
filteredActivities.Add(activity);
if (!activity.Walking && !activity.Running && !activity.Automotive)
{
while (++i < activities.Length)
{
CMMotionActivity skipThisActivity = activities [i];
if (skipThisActivity.Walking || skipThisActivity.Running || skipThisActivity.Automotive)
{
i = i - 1;
break;
}
}
}
}
// Ignore all low confidence activities.
for (int i = 0; i < filteredActivities.Count;)
{
CMMotionActivity activity = filteredActivities [i];
if (activity.Confidence == CMMotionActivityConfidence.Low)
{
filteredActivities.RemoveAt(i);
}
else
{
++i;
}
}
// Skip all unclassified activities if their duration is smaller than
// some threshold. This has the effect of coalescing the remaining med + high
// confidence activies together.
for (int i = 0; i < filteredActivities.Count - 1;)
{
CMMotionActivity activity = filteredActivities [i];
CMMotionActivity nextActivity = filteredActivities [i + 1];
var duration = nextActivity.StartDate.SecondsSinceReferenceDate - activity.StartDate.SecondsSinceReferenceDate;
if (duration < 60 * 3 && !activity.Walking && !activity.Running && !activity.Automotive)
{
filteredActivities.RemoveAt(i);
}
else
{
++i;
}
}
// Coalesce activities where they differ only in confidence.
for (int i = 1; i < filteredActivities.Count;)
{
CMMotionActivity prevActivity = filteredActivities [i - 1];
CMMotionActivity activity = filteredActivities [i];
if ((prevActivity.Walking && activity.Walking) ||
(prevActivity.Running && activity.Running) ||
(prevActivity.Automotive && activity.Automotive))
{
filteredActivities.RemoveAt(i);
}
else
{
++i;
}
}
// Finally transform into SignificantActivity;
List <SignificantActivity> significantActivities = new List <SignificantActivity> ();
for (int i = 0; i < filteredActivities.Count - 1; i++)
{
CMMotionActivity activity = filteredActivities [i];
CMMotionActivity nextActivity = filteredActivities [i + 1];
if (!activity.Walking && !activity.Running && !activity.Automotive)
{
continue;
}
var significantActivity = new SignificantActivity(ActivityDataManager.ActivityToType(activity), (DateTime)activity.StartDate, (DateTime)nextActivity.StartDate);
try {
var pedometerData = await pedometer.QueryPedometerDataAsync(significantActivity.StartDate, significantActivity.EndDate);
significantActivity.StepCounts = pedometerData.NumberOfSteps.Int32Value;
} catch {
Console.WriteLine("Error, unable to retrieve step counts for range {0}, {1}", significantActivity.StartDate.SecondsSinceReferenceDate, significantActivity.EndDate.SecondsSinceReferenceDate);
}
significantActivities.Add(significantActivity);
}
return(significantActivities);
}
List<Activity> CreateActivityDataWithActivities (CMMotionActivity[] activities, Action completionHandler)
{
var results = new List<Activity> ();
var group = DispatchGroup.Create ();
var queue = new DispatchQueue ("resultQueue");
var filteredActivities = activities.Where (activity => activity.HasActivitySignature ()
&& !activity.Stationary
&& activity.Confidence != CMMotionActivityConfidence.Low).ToArray<CMMotionActivity> ();
var activitySegments = FindActivitySegments (filteredActivities);
foreach (var segment in activitySegments) {
group.Enter ();
pedometer.QueryPedometerData (segment.Item1.StartDate, (NSDate)segment.Item2, (pedometerData, error) => {
queue.DispatchAsync (() => {
var activity = new Activity (segment.Item1,
((DateTime)segment.Item1.StartDate).ToLocalTime (),
segment.Item2.ToLocalTime (),
pedometerData);
results.Add (activity);
});
if (error != null)
HandleError (error);
group.Leave ();
});
}
group.Notify (DispatchQueue.MainQueue, () => {
queue.DispatchSync (() => {
RecentActivities = results;
RecentActivities.Reverse ();
completionHandler?.Invoke ();
});
});
return results;
}
void SaveMotionActivity (CMMotionActivity activity)
{
recentMotionActivities.Insert (0, activity);
recentMotionActivities = recentMotionActivities.Where (c => c.StartDate.SecondsSinceReferenceDate <= 60).ToList<CMMotionActivity> ();
if (recentMotionActivities.Count > MotionManager.MaxActivitySamples)
recentMotionActivities.RemoveAt (recentPedometerData.Count - 1);
}
