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; }