public static ActivitySummary FromActivity(IActivitySummary activity)
{
var summary = new ActivitySummary();
summary.CopyFrom(activity);
return(summary);
}
public async Task DeleteAsync(IActivitySummary activity)
{
var stravaActivity = activity as StravaActivitySummary;
if (stravaActivity != null)
{
await _client.Activities.Delete(stravaActivity.Activity.Id);
}
}
public override void CopyFrom(IActivitySummary source)
{
if (source == null)
{
return;
}
base.CopyFrom(source);
StartTime = source.StartTime;
}
public override async Task DeleteAsync(IActivitySummary activity)
{
var healthGraphActivity = activity as HealthGraphActivitySummary;
if (healthGraphActivity == null)
{
return;
}
var activitiesEndpoint = new FitnessActivitiesEndpoint(_client, await GetUser());
await activitiesEndpoint.DeleteActivity(healthGraphActivity.HealthGraphActivity.Uri);
}
public override async Task <MemoryActivity> DownloadAsync(IActivitySummary activity)
{
var healthGraphActivitySummary = activity as HealthGraphActivitySummary;
if (healthGraphActivitySummary == null)
{
return(null);
}
var healthGraphActivity = await _client.FitnessActivities.GetActivity(healthGraphActivitySummary.HealthGraphActivity.Uri);
return(ParseActivity(healthGraphActivity));
}
public virtual void CopyFrom(IActivitySummary source)
{
Name = source.Name;
StartTime = source.StartTime;
Sport = source.Sport;
Distance = source.Distance;
AvgSpeed = source.AvgSpeed;
MaxSpeed = source.MaxSpeed;
AvgHeartRate = source.AvgHeartRate;
MaxHeartRate = source.MaxHeartRate;
AvgPower = source.AvgPower;
MaxPower = source.MaxPower;
AvgCadence = source.AvgCadence;
MaxCadence = source.MaxCadence;
ElapsedTime = source.ElapsedTime;
MovingTime = source.MovingTime;
Ascent = source.Ascent;
Descent = source.Descent;
}
public void CopyFrom(IActivitySummary source)
{
throw new NotImplementedException();
}
public static string GetNameFromStartTime(this IActivitySummary activity)
{
return(activity.StartTime.ToString("yyyy-MM-dd-HH-mm-ss"));
}
public Task DeleteAsync(IActivitySummary activity)
{
throw new NotSupportedException();
}
public async Task <MemoryActivity> DownloadAsync(IActivitySummary activity)
{
if (_client == null)
{
return(null);
}
var pptActivity = activity as PPTActivitySummary;
if (pptActivity == null)
{
return(null);
}
var exercise = pptActivity.Exercise; // PolarPersonalTrainerLib model
GpxExercise gpsData = null;
try
{
gpsData = await _client.GetGpsData(exercise);
}
catch (PPTException)
{
Log.Diagnostics("No GPS data found for activity {0}.", activity.Name);
}
return(await Task.Run <MemoryActivity>(() =>
{
var samples = new[]
{
exercise.HeartRate.Values.Count,
exercise.CadenceValues.Count,
exercise.SpeedValues.Count
};
var samplesCount = samples.Max(); // number of samples
var result = new MemoryActivity();
DateTime timestamp = exercise.StartTime;
// process samples
for (int i = 0; i < samplesCount; i++)
{
var timeFrame = new ActivityTimeFrame();
timeFrame.Timestamp = timestamp;
if (exercise.HeartRate.Values.Count > i)
{
timeFrame.HeartRate = exercise.HeartRate.Values[i];
}
if (exercise.CadenceValues.Count > i)
{
timeFrame.Cadence = exercise.CadenceValues[i];
}
if (exercise.SpeedValues.Count > i)
{
timeFrame.Speed = new Speed(exercise.SpeedValues[i], SpeedUnit.KilometerPerHour);
}
if (gpsData != null)
{
var trackPoint = gpsData.Track.GetTrackPoint(i);
if (trackPoint != null)
{
timeFrame.Position = new Position(Convert.ToSingle(trackPoint.Longitude),
Convert.ToSingle(trackPoint.Latitude),
Convert.ToSingle(trackPoint.Elevation));
}
}
result.AddTimeFrame(timeFrame);
timestamp = timestamp.AddSeconds(exercise.RecordingRate); // time of next sample
}
var summary = ActivitySummary.FromActivity(pptActivity);
result.SetSummary(summary);
return result;
}));
}
public abstract Task DeleteAsync(IActivitySummary activity);
public abstract Task <MemoryActivity> DownloadAsync(IActivitySummary activity);
/// <summary>
/// Updates the total values with summary values
/// </summary>
/// <param name="summary"></param>
public void SetSummary(IActivitySummary summary)
{
// update with valid values from summary
base.SetSummary(summary);
Sport = summary.Sport;
}
public async Task <MemoryActivity> DownloadAsync(IActivitySummary activity)
{
var stravaActivity = activity as StravaActivitySummary;
if (stravaActivity != null) // only Strava activity can be downloaded
{
var streams = await _client.Activities.GetActivityStreams(stravaActivity.Activity, StreamType.Time, StreamType.LatLng, StreamType.Watts, StreamType.HeartRate, StreamType.Cadence, StreamType.VelocitySmooth, StreamType.Altitude, StreamType.Moving);
Debug.WriteLine("Memory allocated for downlading: " + FileHelper.GetSizeString(GC.GetTotalMemory(false)));
// determine what streams we have
StravaSharp.Stream timeStream = null, posStream = null, hrStream = null, speedStream = null, powerStream = null, cadenceStream = null, altitudeStream = null, movingStream = null;
foreach (var stream in streams)
{
if (stream.Type == StreamType.Time)
{
timeStream = stream;
}
else if (stream.Type == StreamType.HeartRate)
{
hrStream = stream;
}
else if (stream.Type == StreamType.LatLng)
{
posStream = stream;
}
else if (stream.Type == StreamType.VelocitySmooth)
{
speedStream = stream;
}
else if (stream.Type == StreamType.Cadence)
{
cadenceStream = stream;
}
else if (stream.Type == StreamType.Watts)
{
powerStream = stream;
}
else if (stream.Type == StreamType.Altitude)
{
altitudeStream = stream;
}
else if (stream.Type == StreamType.Moving)
{
movingStream = stream;
}
Log.Diagnostics("{0} stream length: {1}", stream.Type, stream.Data.Length);
}
return(await Task.Run <MemoryActivity>(() =>
{
// build activity from the streams' frames
// pauses are not recognized this way
var isMoving = false;
var destActivity = new MemoryActivity {
Sport = stravaActivity.Sport, Name = stravaActivity.Name
};
DateTime startDate = stravaActivity.Activity.StartDate;
for (int i = 0; i < streams[0].Data.Length; i++)
{
var timeFrame = new ActivityTimeFrame();
timeFrame.Timestamp = startDate.AddSeconds(Convert.ToInt32(timeStream.Data[i]));
var moving = Convert.ToBoolean(movingStream.Data[i]);
if (isMoving && !moving)
{
// now stops
timeFrame.Type = ActivityTimeFrameType.Stop;
destActivity.AddTimeFrame(timeFrame);
isMoving = false;
continue;
}
else if (!isMoving && moving)
{
// now starts moving again
timeFrame.Type = ActivityTimeFrameType.Start;
destActivity.AddTimeFrame(timeFrame);
isMoving = true;
}
else if (!isMoving && !moving)
{
continue; // still standing
}
if (hrStream != null)
{
timeFrame.HeartRate = Convert.ToByte(hrStream.Data[i]);
}
if (posStream != null)
{
// position is json array
var pos = posStream.Data[i] as JArray;
if (pos != null)
{
var p = new SharpGeo.Position();
p.Latitude = pos[0].ToObject <float>();
p.Longitude = pos[1].ToObject <float>();
if (altitudeStream != null)
{
p.Altitude = Convert.ToSingle(altitudeStream.Data[i]);
}
timeFrame.Position = p;
}
}
if (speedStream != null)
{
timeFrame.Speed = new Speed(Convert.ToSingle(speedStream.Data[i]), SpeedUnit.MeterPerSecond);
}
if (cadenceStream != null)
{
timeFrame.Cadence = Convert.ToByte(cadenceStream.Data[i]);
}
if (powerStream != null)
{
timeFrame.Power = Convert.ToUInt16(powerStream.Data[i]);
}
destActivity.AddTimeFrame(timeFrame);
}
var summary = new Models.ActivitySummary();
summary.ElapsedTime = stravaActivity.ElapsedTime;
summary.MovingTime = stravaActivity.MovingTime;
summary.Sport = stravaActivity.Sport;
summary.AvgSpeed = stravaActivity.AvgSpeed;
summary.MaxSpeed = stravaActivity.MaxSpeed;
summary.AvgHeartRate = stravaActivity.AvgHeartRate;
summary.MaxHeartRate = stravaActivity.MaxHeartRate;
summary.AvgCadence = stravaActivity.AvgCadence;
summary.MaxCadence = stravaActivity.MaxCadence;
if (stravaActivity.HasRealPowerData)
{
summary.AvgPower = stravaActivity.AvgPower;
summary.MaxPower = stravaActivity.MaxPower;
}
summary.Ascent = stravaActivity.Ascent;
summary.Descent = stravaActivity.Descent;
destActivity.SetSummary(summary);
return destActivity;
}));
}
return(null);
}
void IActivitySummary.CopyFrom(IActivitySummary source)
{
throw new NotSupportedException();
}
