public async Task DecodeAsync(MemoryActivity dest = null)
{
Name = _file.GetNameWithoutExtension();
var input = await _file.OpenForReadAsync(); // file stream
if (input.Length == 0)
{
return;
}
MemoryActivity activity = dest != null ? dest : new MemoryActivity();
// use the appropriate importer type
ActivityImporter importer = null;
if (_file.Name.EndsWith(".fit", StringComparison.OrdinalIgnoreCase))
{
importer = new FitImporter(activity);
}
else if (_file.Name.EndsWith(".tcx", StringComparison.OrdinalIgnoreCase))
{
importer = new TcxImporter(activity);
}
if (importer != null)
{
await importer.LoadAsync(input);
}
await UpdateMetadata(ActivitySummary.FromActivity(dest));
}
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);
}
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);
}
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 async Task InitializeAsync()
{
if (_initialized)
{
return;
}
// Activity.Sport = Settings.ActivityRecorder.Sport; // default sport
// restore interrupted activity recording
var folderActivities = await GetFolderAsync();
_fileDest = await folderActivities.TryGetItemAsync(TempFileName);
if (_fileDest != null)
{
// there is an already started, interrupted recording, load data from it
var importer = new FitImporter(_activity);
try
{
using (var stream = await _fileDest.OpenForReadAsync())
{
await importer.LoadAsync(stream);
}
}
catch (Exception ex)
{
Log.Error(ex);
}
_activity.RecalculateCurrentLap();
if (_activity.TimeFrames.Count > 0)
{
await PrepareDestinationFileAsync();
IsStarted = true;
}
}
SensorService.Clock.StatusChanged += OnClockTick;
_initialized = true;
}
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
});
}
