private MemoryActivity ParseActivity(FitnessActivitiesPastModel healthGraphActivity)
{
var activityDetails = new MemoryActivity();
activityDetails.StartTime = healthGraphActivity.StartTime;
activityDetails.Sport = healthGraphActivity.Type.ToFitSport();
// TODO: watch for other samples too!
var numberOfTimeframes = healthGraphActivity.Path.Count;
for (var i = 0; i < numberOfTimeframes; i++)
{
var timeFrame = new ActivityTimeFrame();
timeFrame.Timestamp = activityDetails.StartTime.AddSeconds(healthGraphActivity.Distance[i].Timestamp);
timeFrame.Position = new Position((float)healthGraphActivity.Path[i].Longitude, (float)healthGraphActivity.Path[i].Latitude,
(float)healthGraphActivity.Path[i].Altitude);
if (healthGraphActivity.HeartRate.Count > i)
{
timeFrame.HeartRate = (byte)healthGraphActivity.HeartRate[i].HeartRate;
}
activityDetails.AddTimeFrame(timeFrame);
}
return(activityDetails);
}
public ActivityImporter(MemoryActivity activity)
{
if (activity == null)
{
throw new ArgumentException("activity");
}
_activity = activity;
}
private async Task SaveAsync(MemoryActivity activity, string fileName)
{
using (var output = await TestFileHelper.OpenForWriteAsync(fileName))
{
var exporter = new FitExporter(activity);
await exporter.SaveAsync(output);
}
}
private async Task Export(MemoryActivity activity)
{
using (var output = await TestFileHelper.OpenForWriteAsync(GetExportedFileName()))
{
var exporter = new GpxExporter(activity);
await exporter.SaveAsync(output);
}
}
private void ExportReloadCheck(MemoryActivity activity)
{
var activityResult = ExportAndReload(activity);
Assert.AreEqual(activity.StartTime, activityResult.StartTime);
Assert.AreEqual(activity.ElapsedTime, activityResult.ElapsedTime);
Assert.AreEqual(activity.Distance, activityResult.Distance);
Assert.AreEqual(activity.AvgSpeed.GetValueAs(SpeedUnit.KilometerPerHour), activityResult.AvgSpeed.GetValueAs(SpeedUnit.KilometerPerHour), 0.1f);
}
public async Task TcxImport()
{
using (var input = await TestFileHelper.OpenForReadAsync(_fileName))
{
var activity = new MemoryActivity();
var importer = new TcxImporter(activity);
importer.Load(input);
Assert.IsTrue(activity.TimeFrames.Count > 0);
}
}
private async Task <MemoryActivity> LoadAsync(string fileName)
{
var activity = new MemoryActivity();
using (var input = await TestFileHelper.OpenForReadAsync(fileName))
{
var importer = new FitImporter(activity);
await importer.LoadAsync(input);
}
return(activity);
}
/// <summary>
/// Loads an <see cref="MemoryActivity"/> from a file
/// </summary>
/// <param name="fileName">Path of the file.</param>
/// <param name="funcImporter">The importer to be created for loading the activity.</param>
/// <returns>The imported <see cref="MemoryActivity"/>.</returns>
protected async Task <MemoryActivity> LoadAsync(string fileName, Func <MemoryActivity, ActivityImporter> funcImporter)
{
var activity = new MemoryActivity();
using (var input = await TestFileHelper.OpenForReadAsync(fileName))
{
var importer = funcImporter(activity);
importer.Load(input);
}
return(activity);
}
public async Task SmlImport()
{
var activity = new MemoryActivity();
using (var input = await TestFileHelper.OpenForReadAsync(_fileName))
{
var importer = new SmlImporter(activity);
await importer.LoadAsync(input);
}
Assert.True(activity.TimeFrames.Count > 0);
Assert.AreEqual(70.263f, activity.Distance.GetValueAs(DistanceUnit.Kilometer), 0.1f);
}
protected MemoryActivity ExportAndReload(MemoryActivity activity)
{
var exporter = new FitExporter(activity);
var stream = new MemoryStream();
exporter.Save(stream);
// reimport the activity
stream.Seek(0, SeekOrigin.Begin);
var activityReloaded = new MemoryActivity();
var importer = new FitImporter(activityReloaded);
importer.Load(stream);
return(importer.Activity);
}
public async Task Recode()
{
var activity = new MemoryActivity();
using (var input = await TestFileHelper.OpenForReadAsync(GetFileName("2015-10-31-100331.fit")))
{
var importer = new FitImporter(activity);
importer.Load(input);
}
var activityRepaired = activity.Repair();
Assert.AreEqual(26.092411, activityRepaired.AvgSpeed.GetValueAs(SpeedUnit.KilometerPerHour), 0.05);
}
private async Task <MemoryActivity> Import(string fileName)
{
using (var input = await TestFileHelper.OpenForReadAsync(fileName))
{
var activity = new MemoryActivity();
var importer = new GpxImporter(activity);
importer.Load(input);
//var exporter = new FitExporter(activity);
//using (var output = await TestFileHelper.OpenForWriteAsync(_fileName + ".fit"))
//{
// exporter.Save(output);
//}
return(activity);
}
}
public void AddMemoryActivity(DateTime timeStampUtc, long data)
{
var memoryActivity = new MemoryActivity
{
CommitSizeInBytes = data,
EventTimeStamp = timeStampUtc,
Tenant = _tenant
};
if (!_memoryActivities.TryAdd(memoryActivity))
{
_logger.LogWarning($"Buffer for holding memory activities is full with {_memoryActivities.Count} elements.Dropping current batch of memory activities");
DrainActivities(_currentMemoryActivities, _memoryActivities);
}
}
public async Task Import()
{
var activity = new MemoryActivity();
using (var input = await TestFileHelper.OpenForReadAsync(Test2FileName))
{
var importer = new FitImporter(activity);
importer.MessageBroadcaster.SessionMesgEvent += (sender, args) =>
{
var msg = args.mesg as SessionMesg;
var summary = msg.ToSummary();
};
importer.Load(input);
Assert.AreEqual(activity.AvgHeartRate, 153);
Assert.AreEqual(activity.MaxHeartRate, 180);
}
}
public FitImporter(MemoryActivity activity)
: base(activity)
{
Decoder = new Decode();
MessageBroadcaster = new MesgBroadcaster();
// Connect the Broadcaster to our event (message) source (in this case the Decoder)
Decoder.MesgEvent += MessageBroadcaster.OnMesg;
Decoder.MesgDefinitionEvent += MessageBroadcaster.OnMesgDefinition;
// Subscribe to message events of interest by connecting to the Broadcaster
MessageBroadcaster.SessionMesgEvent += MessageBroadcaster_SessionMesgEvent;
MessageBroadcaster.RecordMesgEvent += MessageBroadcaster_RecordMesgEvent;
MessageBroadcaster.EventMesgEvent += MessageBroadcaster_EventMesgEvent;
MessageBroadcaster.LapMesgEvent += MessageBroadcaster_LapMesgEvent;
MessageBroadcaster.DeviceInfoMesgEvent += MessageBroadcaster_DeviceInfoMesgEvent;
MessageBroadcaster.FileIdMesgEvent += MessageBroadcaster_FileIdMesgEvent;
}
public async Task ImportCycling()
{
var activity = new MemoryActivity();
using (var input = await TestFileHelper.OpenForReadAsync(Hrm106Cycling))
{
var importer = new HrmImporter(activity);
importer.Load(input);
Assert.AreEqual(Dynastream.Fit.Sport.Cycling, activity.Sport);
Assert.AreEqual(new DateTime(2009, 05, 21, 06, 58, 41), activity.StartTime);
Assert.AreNotEqual(0, activity.TimeFrames.Count);
Assert.AreEqual(new TimeSpan(11, 59, 41).TotalSeconds, activity.ElapsedTime, 30); // treshold = 2 x recording interval
Assert.AreEqual(239.1f, activity.Distance.GetValueAs(DistanceUnit.Kilometer), 0.1f);
Assert.AreEqual(20.1f, activity.AvgSpeed.GetValueAs(SpeedUnit.KilometerPerHour), 0.1f);
Assert.AreEqual(53.8f, activity.MaxSpeed.GetValueAs(SpeedUnit.KilometerPerHour), 0.1f);
Assert.AreEqual(477, activity.TimeFrames[4].Altitude.Value.GetValueAs(DistanceUnit.Meter));
}
// now check exporting it
ExportReloadCheck(activity);
}
protected void Start(Stream source, int millisecondsDelay)
{
if (_task != null)
{
return;
}
_task = Task.Run(() =>
{
// import activity from GPX
var activity = new MemoryActivity();
var importer = new FitImporter(activity);
importer.Load(source);
// mock positions from the activity
var moveCalculator = new MoveCalculator();
while (true)
{
foreach (var frame in activity.TimeFrames)
{
Task.Delay(millisecondsDelay).Wait(); // wait for 1 second
if (!_isConnected)
{
continue;
}
if (frame.Position.HasValue)
{
moveCalculator.Add(frame.Position.Value, TimeSpan.FromSeconds(1));
if (StatusChanged != null)
{
_status.Position = frame.Position.Value;
_status.Speed = moveCalculator.CurrentSpeed;
var args = new GeoLocatorStatusChangedEventArgs(_status);
StatusChanged(this, args);
}
}
}
}
});
_task.ConfigureAwait(false);
}
public override async Task <UploadStatus> UploadAsync(Stream source, UploadOptions options)
{
// TODO: UploadAsync should use MemoryActivity as a parameter instead of Stream
var activity = new MemoryActivity();
var fitImporter = new FitImporter(activity);
await fitImporter.LoadAsync(source);
var activityToCreate = new FitnessActivitiesNewModel
{
StartTime = activity.StartTime,
AverageHeartRate = activity.AvgHeartRate,
HeartRate = new List <HeartRateModel>(),
Path = new List <PathModel>()
};
foreach (var timeFrame in activity.TimeFrames)
{
var timestamp = timeFrame.Timestamp.Subtract(activity.StartTime).TotalSeconds;
var location = timeFrame.Position.GetValueOrDefault(Position.Empty);
activityToCreate.HeartRate.Add(new HeartRateModel
{
HeartRate = timeFrame.HeartRate.GetValueOrDefault(),
Timestamp = timestamp
});
activityToCreate.Path.Add(new PathModel
{
Timestamp = timestamp,
Altitude = location.Altitude,
Longitude = location.Longitude,
Latitude = location.Latitude,
Type = "gps"
});
}
var result = await _client.FitnessActivities.CreateActivity(activityToCreate);
return(new HealthGraphUploadStatus {
Status = result
});
}
public async Task ImportRunning()
{
var activity = new MemoryActivity();
using (var input = await TestFileHelper.OpenForReadAsync(Hrm106Running))
{
var importer = new HrmImporter(activity);
importer.Load(input);
Assert.AreEqual(Dynastream.Fit.Sport.Running, activity.Sport);
Assert.AreEqual(new DateTime(2007, 12, 31, 09, 05, 29), activity.StartTime);
Assert.AreNotEqual(0, activity.TimeFrames.Count);
Assert.AreEqual(new TimeSpan(03, 58, 59).TotalSeconds, activity.ElapsedTime, 30); // treshold = 2 x recording interval
//Assert.AreEqual(135.6f, activity.Distance.GetValueAs(DistanceUnit.Kilometer), 0.1f);
//Assert.AreEqual(26.9f, activity.AvgSpeed.GetValueAs(SpeedUnit.KilometerPerHour), 0.1f);
//Assert.AreEqual(56.9f, activity.MaxSpeed.GetValueAs(SpeedUnit.KilometerPerHour), 0.1f);
//Assert.AreEqual(94, activity.TimeFrames[3].Cadence.Value);
//Assert.AreEqual(191, activity.TimeFrames[3].Altitude.Value.GetValueAs(DistanceUnit.Meter));
}
// now check exporting it
ExportReloadCheck(activity);
}
public async Task ImportCyclingPower()
{
var activity = new MemoryActivity();
using (var input = await TestFileHelper.OpenForReadAsync(Hrm106CyclingPower))
{
var importer = new HrmImporter(activity);
importer.Load(input);
Assert.AreEqual(Dynastream.Fit.Sport.Cycling, activity.Sport);
Assert.AreEqual(new DateTime(2009, 01, 03, 11, 54, 23), activity.StartTime);
Assert.AreNotEqual(0, activity.TimeFrames.Count);
Assert.AreEqual(new TimeSpan(02, 43, 30).TotalSeconds, activity.ElapsedTime, 30); // treshold = 2 x recording interval
Assert.AreEqual(66.8f, activity.Distance.GetValueAs(DistanceUnit.Kilometer), 0.1f);
Assert.AreEqual(25.3f, activity.AvgSpeed.GetValueAs(SpeedUnit.KilometerPerHour), 0.1f);
Assert.AreEqual(51.8f, activity.MaxSpeed.GetValueAs(SpeedUnit.KilometerPerHour), 0.1f);
Assert.True(activity.TimeFrames.Count > 3);
Assert.AreEqual(66, activity.TimeFrames[3].Cadence.Value);
Assert.AreEqual(174, activity.TimeFrames[3].Altitude.Value.GetValueAs(DistanceUnit.Meter));
Assert.AreEqual(16, activity.TimeFrames[3].Power.Value);
}
// now check exporting it
ExportReloadCheck(activity);
}
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 HrmImporter(MemoryActivity activity)
: base(activity)
{
}
public TcxImporter(MemoryActivity activity)
: base(activity)
{
Activity.Sport = Dynastream.Fit.Sport.Generic;
}
public GpxImporter(MemoryActivity activity) : base(activity)
{
}
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);
}
public FitExporter(MemoryActivity activity)
: base(activity)
{
}
public ActivityExporter(MemoryActivity activity)
{
_activity = activity;
}
/// <summary>
/// Checks for common properties
/// </summary>
/// <param name="activity">Original activity.</param>
/// <param name="strippedActivity">Stripped activity.</param>
private void Check(MemoryActivity activity, MemoryActivity strippedActivity)
{
Assert.AreEqual(activity.Sport, strippedActivity.Sport);
Assert.AreEqual(activity.Distance, strippedActivity.Distance);
Assert.AreEqual(activity.ElapsedTime, strippedActivity.ElapsedTime);
}
public SmlImporter(MemoryActivity activity) : base(activity)
{
}
public PolarXmlImporter(MemoryActivity activity)
: base(activity)
{
}
