public AudioPlayerViewModel(INavigation navigation = null) : base(navigation)
{
_localFile = DependencyService.Get <ILocalFile>();
_audioPlayer = DependencyService.Get <IAudioPlayerService>();
_devicePermissionServices = DependencyService.Get <IDevicePermissionServices>();
SetPageImageSize();
MediaFiles = new List <MediaFile>();
CurrentMediaFile = new MediaFile();
PlayButton = ImageResizer.ResizeImage(TextResources.icon_media_play, ButtonImageSize);
PauseButton = ImageResizer.ResizeImage(TextResources.icon_media_pause, ButtonImageSize);
StopButton = ImageResizer.ResizeImage(TextResources.icon_media_stop, ButtonImageSize);
NextButton = ImageResizer.ResizeImage(TextResources.icon_media_next, ButtonImageSize);
PreviousButton = ImageResizer.ResizeImage(TextResources.icon_media_previous, ButtonImageSize);
PlayPauseButton = PlayButton;
IsPlaying = false;
IsPause = false;
IsMediaExists = false;
CurrentSongIndex = 0;
CrossMediaManager.Current.PlayingChanged += async(sender, e) =>
{
CurrentPosition = e.Progress;
CurrentTimer = e.Position.ToString(@"hh\:mm\:ss");
TotalTimer = e.Duration.ToString(@"hh\:mm\:ss");
double TOLERANCE = 0;
if (Math.Abs(e.Progress - 1) < TOLERANCE)
{
await PlayCurrent(Next());
}
};
}
/// <summary>
/// Finish recording
/// </summary>
public void Finish()
{
if (!IsStarted)
{
return;
}
// _timer.Stop();
IsActive = false;
IsStarted = false;
if (_streamDest != null)
{
// if the activity should be saved, then export it
_exporter.WriteSummary();
_exporter.Close();
_streamDest.Dispose();
_streamDest = null;
// rename the temp file
_fileDest.RenameAsync(string.Format("{0:yyyy-MM-dd-HHmmss}.fit", _activity.StartTime));
_fileDest = null;
}
// reset measurement values
_activity.Reset();
// _moveCalculator.Reset();
Finished?.Invoke(this, new ActivityRecorderEventArgs {
Recorder = this
});
}
public GazetteDetailsPageViewModel(INavigationService navigationService, IPageDialogService pageDialogService, IGazetteService gazetteService, ILocalFile localFile)
: base(navigationService, pageDialogService)
{
_gazetteService = gazetteService;
_pageDialogService = pageDialogService;
_localFile = localFile;
Title = "PDF";
}
/// <summary>
/// Parses the metadata of the given <paramref name="files"/>.
/// </summary>
/// <param name="files">Files whose metadata to parse.</param>
/// <returns>Task.</returns>
private async Task ParseFiles(string[] files)
{
OnStatusUpdated("Trying to parse selected files...");
List <string> errors = new List <string>();
var newFiles = new List <LoadedFileViewModel>();
await Task.Run(() =>
{
foreach (string file in files)
{
try
{
if (SUPPORTEDFILES.Contains(Path.GetExtension(file).ToLower()))
{
ILocalFile audioFile = _localFileFactory.CreateFile(file);
if (string.IsNullOrEmpty(audioFile.Artist))
{
throw new Exception("No artist name found");
}
if (string.IsNullOrEmpty(audioFile.Track))
{
throw new Exception("No track name found");
}
var vm = new LoadedFileViewModel(audioFile);
vm.ToScrobbleChanged += Vm_ToScrobbleChanged;
newFiles.Add(vm);
}
}
catch (Exception ex)
{
errors.Add(string.Format("{0} {1}", file, ex.Message));
}
}
});
Scrobbles = new ObservableCollection <LoadedFileViewModel>(Scrobbles.Concat(newFiles));
if (errors.Count > 0)
{
OnStatusUpdated(string.Format("Finished parsing selected files. {0} files could not be parsed", errors.Count));
if (_windowManager.MessageBoxService.ShowDialog("Some files could not be parsed. Do you want to save a text file with the files that could not be parsed?",
"Error parsing files", IMessageBoxServiceButtons.YesNo) == IMessageBoxServiceResult.Yes)
{
IFileDialog sfd = _windowManager.CreateSaveFileDialog();
sfd.Filter = "Text Files|*.txt";
if (sfd.ShowDialog())
{
_fileOperator.WriteAllLines(sfd.FileName, errors.ToArray());
}
}
}
else
{
OnStatusUpdated("Successfully parsed selected files");
}
}
public static string GetNameWithoutExtension(this ILocalFile file)
{
int indexOfDot = file.Name.LastIndexOf('.');
if (indexOfDot == -1)
{
return(file.Name);
}
return(file.Name.Substring(0, indexOfDot));
}
public void Uninitialize()
{
if (!_initialized)
{
return;
}
SensorService.Clock.StatusChanged -= OnClockTick;
if (_streamDest != null)
{
_exporter.Close();
_streamDest.Dispose();
}
_fileDest = null;
_initialized = false;
}
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;
}
private Task UploadFile(IFtpClient client, ILocalFile file, string remoteDirectoryPath, bool overwrite)
{
return(file.OpenStreamForReadAsync().ContinueWith(fileStreamTask =>
{
if (client.FileExists(remoteDirectoryPath + "/" + file.Name) && !overwrite)
{
var localDirectoryItem = DependencyService.Resolve <IUploadLocalItem>();
localDirectoryItem.Item = file;
localDirectoryItem.DestinationPath = remoteDirectoryPath;
FileConflicts.Add(localDirectoryItem);
return;
}
using (var fileStream = fileStreamTask.Result)
{
client.Upload(fileStream, remoteDirectoryPath + "/" + file.Name, overwrite);
}
}));
}
/// <summary>
/// Start recording
/// </summary>
public async Task StartAsync(bool isTrial = false)
{
if (IsStarted)
{
if (IsActive)
{
return; // it's already running
}
// running and paused, let's resume
_lastRecordedTime = DateTime.Now;
AddTimeFrame(new ActivityTimeFrame {
Timestamp = _lastRecordedTime, Type = ActivityTimeFrameType.Start
});
IsActive = true;
}
else
{
// Not started yet
if (!isTrial)
{
// if the app has been bought now, prepare saving to file
var folderActivities = await GetFolderAsync();
_fileDest = await folderActivities.CreateFileAsync(TempFileName, CreateFileOption.ReplaceExisting);
await PrepareDestinationFileAsync();
}
_lastRecordedTime = DateTime.Now;
// _timer.Start();
IsStarted = true;
IsActive = true;
}
if (Started != null)
{
Started(this, new ActivityRecorderEventArgs {
Recorder = this
});
}
}
public string getPath(ILocalFile file)
{
string directoryPath = directoryPathBuilder.getPath(file.LogicalDirectory);
return(Path.Combine(directoryPath, file.FileName));
}
public FileExplorerViewModel(INavigation navigation = null) : base(navigation)
{
_localFile = DependencyService.Get <ILocalFile>();
}
public LocalActivitySummary(ILocalFile file)
{
this._file = file;
}
public Parser(ILocalFile localFile)
{
this.localFile = localFile;
}
public LocalConfiguration(ILocalFile localFile, string path)
{
Configuration = new ConfigurationModel();
_localFile = localFile;
_localFile.Path = path;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="file">The loaded file.</param>
public LoadedFileViewModel(ILocalFile file)
: base(new ScrobbleBase(file.Track, file.Artist, file.Album, file.AlbumArtist, file.Duration))
{
_file = file;
}
/// <summary>
/// Opens cache.
/// </summary>
/// <param name="file">Storage file name</param>
/// <param name="dbVersion">Storage version</param>
/// <returns>Return cache and storage initializer pair</returns>
private static Tuple <SQLitePersistentBlobCache, IStorageInitializer> OpenCache(ILocalFile file, int dbVersion)
{
var fullDbFileName = file.FullFileName;
var cache = new SQLitePersistentBlobCache(fullDbFileName);
var actualDbVersion = StorageInitializer.TryGetDbVersion(cache);
IStorageInitializer dataStorageInitializer = null;
if (actualDbVersion.HasValue == false || actualDbVersion.Value != dbVersion)
{
dataStorageInitializer = new StorageInitializer(cache, dbVersion);
}
return(new Tuple <SQLitePersistentBlobCache, IStorageInitializer>(cache, dataStorageInitializer));
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="file">The loaded file.</param>
public LoadedFileViewModel(ILocalFile file)
{
_file = file;
}