public Task<bool> RecordAsync(StorageFile file, CancellationToken cancToken)
		{
			return RunFunctionIfOpenAsyncTB(async delegate
			{
				if (file == null) return false;
				bool isOk = await StartRecordingAsync(file).ConfigureAwait(false);

				// Lock the thread asynchronously until explicitly closed from the caller. 
				// If an error prevented starting recording, stay open to display error messages.
				// The lock will last until the cancellation token is cancelled or the semaphore is released or disposed.
				_recordLockingSemaphore = new SemaphoreSlimSafeRelease(0, 1); // this semaphore is always closed at the beginning
				try
				{
					await _recordLockingSemaphore.WaitAsync(cancToken).ConfigureAwait(false);
					Debug.WriteLine("I am past _triggerSemaphore");
				}
				catch (OperationCanceledException)
				{
					isOk = false;
					Debug.WriteLine("I am past _triggerSemaphore after OperationCanceledException");
				}
				catch (Exception ex)
				{
					Debug.WriteLine("I am past _triggerSemaphore after exception: " + ex.ToString());
					if (SemaphoreSlimSafeRelease.IsAlive(_recordLockingSemaphore))
					{
						isOk = false;
						Logger.Add_TPL(ex.ToString(), Logger.ForegroundLogFilename);
					}
				}

				return isOk;
			});
		}
Esempio n. 2
0
        public static async Task <string> ReadAsync(string fileName)
        {
            string result = string.Empty;

            try
            {
                await _semaphore.WaitAsync().ConfigureAwait(false);

                result = await Read2Async(fileName).ConfigureAwait(false);
            }
            catch (FileNotFoundException exc0)
            {
                //put up with it: it may be the first time we use this file
                Debug.WriteLine("no worries but: " + exc0.ToString());
            }
            catch (Exception exc)
            {
                if (SemaphoreSlimSafeRelease.IsAlive(_semaphore))
                {
                    Debug.WriteLine("ERROR in Logger.ReadAsync(): " + exc.ToString());
                }
            }
            finally
            {
                SemaphoreSlimSafeRelease.TryRelease(_semaphore);
            }
            return(result);
        }
		public static bool TryRelease(SemaphoreSlimSafeRelease semaphore, int releaseCount)
		{
			try
			{
				if (IsAlive(semaphore))
				{
					semaphore.Release(releaseCount);
					return true;
				}
			}
			catch { }
			return false;
		}
Esempio n. 4
0
 public static bool TryRelease(SemaphoreSlimSafeRelease semaphore, int releaseCount)
 {
     try
     {
         if (IsAlive(semaphore))
         {
             semaphore.Release(releaseCount);
             return(true);
         }
     }
     catch { }
     return(false);
 }
Esempio n. 5
0
 /// <summary>
 /// Disposes of a semaphore.
 /// You can use this method to interrupt all operations, which are queuing at the semaphore, if you initialised it for max 1 thread.
 /// Wait at the semaphore before calling this method, to be sure you don't disrupt any running operations at an unexpected moment.
 /// Every method using this semaphore should make allowance for it being disposed.
 /// </summary>
 /// <example>
 /// Use it as follows:
 /// <code>
 /// try
 /// {
 ///     semaphore.Wait();
 ///     do some work
 /// }
 /// catch (Exception ex)
 /// {
 ///     if (SemaphoreSlimSafeRelease.IsAlive(semaphore))
 ///         // you have a real error, otherwise it's simply the semaphore being disposed and reset to null
 /// }
 /// finally
 /// {
 ///     SemaphoreSlimSafeRelease.TryRelease(semaphore);
 ///     // do not just call semaphore.Release() because the semaphore may be disposed or null at this stage
 /// }
 /// </code>
 /// </example>
 /// <param name="semaphore"></param>
 /// <returns></returns>
 public static bool TryDispose(SemaphoreSlimSafeRelease semaphore)
 {
     try
     {
         if (IsAlive(semaphore))
         {
             semaphore.Dispose();
             return(true);
         }
     }
     catch { }
     return(false);
 }
		public static bool TryRelease(SemaphoreSlimSafeRelease semaphore)
		{
			try
			{
				// the following commented out stuff wouldbe nice to avoid the exception but it is not atomic, so we leave it.
				if (IsAlive(semaphore) /*&& semaphore.CurrentCount < semaphore._maxCount*/)
				{
					semaphore.Release();
					return true;
				}
			}
			catch { }
			return false;
		}
Esempio n. 7
0
 public static bool TryRelease(SemaphoreSlimSafeRelease semaphore)
 {
     try
     {
         // the following commented out stuff wouldbe nice to avoid the exception but it is not atomic, so we leave it.
         if (IsAlive(semaphore) /*&& semaphore.CurrentCount < semaphore._maxCount*/)
         {
             semaphore.Release();
             return(true);
         }
     }
     catch { }
     return(false);
 }
Esempio n. 8
0
 public static void ClearAll()
 {
     Task.Run(async delegate
     {
         try
         {
             await _semaphore.WaitAsync().ConfigureAwait(false);
             //await _logsFolder.DeleteAsync().AsTask().ConfigureAwait(false);
             _logsFolder = await ApplicationData.Current.LocalCacheFolder.CreateFolderAsync(LogFolderName, CreationCollisionOption.ReplaceExisting).AsTask().ConfigureAwait(false);
         }
         catch (Exception exc)
         {
             if (SemaphoreSlimSafeRelease.IsAlive(_semaphore))
             {
                 Debug.WriteLine("ERROR in Logger.ClearAll(): " + exc.ToString());
             }
         }
         finally
         {
             SemaphoreSlimSafeRelease.TryRelease(_semaphore);
         }
     });
 }
Esempio n. 9
0
        private static async Task Add2Async(string msg, string fileName)
        {
            try
            {
                await _semaphore.WaitAsync().ConfigureAwait(false);

                await UpdateLogAsync(fileName, msg).ConfigureAwait(false);

                //Debug.WriteLine("the thread id is " + Environment.CurrentManagedThreadId + " after the await");
            }
            catch (Exception exc)
            {
                if (SemaphoreSlimSafeRelease.IsAlive(_semaphore))
                {
                    Debug.WriteLine("ERROR in Logger: " + exc.ToString());
                }
            }
            finally
            {
                SemaphoreSlimSafeRelease.TryRelease(_semaphore);
            }
            // await SendEmailWithLogsAsync("*****@*****.**"); // maybe move Logger into the utils and use the right email address and maybe new parameter "sendemailifcrash"
            // On second thought, the email could be annoying and scary. Better leave the option to send it in the "About" panel only.
        }
		/// <summary>
		/// Disposes of a semaphore.
		/// You can use this method to interrupt all operations, which are queuing at the semaphore, if you initialised it for max 1 thread.
		/// Wait at the semaphore before calling this method, to be sure you don't disrupt any running operations at an unexpected moment.
		/// Every method using this semaphore should make allowance for it being disposed.
		/// </summary>
		/// <example> 
		/// Use it as follows:
		/// <code>
		/// try
		/// {
		///     semaphore.Wait();
		///     do some work
		/// }
		/// catch (Exception ex)
		/// {
		///     if (SemaphoreSlimSafeRelease.IsAlive(semaphore))
		///         // you have a real error, otherwise it's simply the semaphore being disposed and reset to null
		/// }
		/// finally
		/// {
		///     SemaphoreSlimSafeRelease.TryRelease(semaphore);
		///     // do not just call semaphore.Release() because the semaphore may be disposed or null at this stage
		/// }
		/// </code>
		/// </example>
		/// <param name="semaphore"></param>
		/// <returns></returns>
		public static bool TryDispose(SemaphoreSlimSafeRelease semaphore)
		{
			try
			{
				if (IsAlive(semaphore))
				{
					semaphore.Dispose();
					return true;
				}
			}
			catch { }
			return false;
		}
		/// <summary>
		/// Returns true if a SemaphoreSlimSafeRelease is not null and not disposed.
		/// </summary>
		/// <param name="semaphore"></param>
		/// <returns></returns>
		public static bool IsAlive(SemaphoreSlimSafeRelease semaphore)
		{
			return semaphore != null && !semaphore._isDisposed;
		}
Esempio n. 12
0
		public DocumentView()
		{
			_appView = ApplicationView.GetForCurrentView(); _appView.VisibleBoundsChanged += OnVisibleBoundsChanged;
			_renderSemaphore = new SemaphoreSlimSafeRelease(1, 1);
			Loaded += OnLoaded;
			Unloaded += OnUnloaded;
			InitializeComponent();
		}
Esempio n. 13
0
		public Task<bool> RecordAsync(StorageFile file, CancellationToken cancToken)
		{
			return RunFunctionIfOpenAsyncTB(async delegate
			{
				_file = file;
				await SetupUiAsync();
				bool isOk = await InitializeCameraAsync().ConfigureAwait(false);
				if (isOk)
				{
					_triggerSemaphore = new SemaphoreSlimSafeRelease(0, 1); // this semaphore is always closed at the beginning
					try
					{
						await _triggerSemaphore.WaitAsync(cancToken).ConfigureAwait(false);
					}
					catch (OperationCanceledException)
					{ }
					catch (Exception ex)
					{
						if (SemaphoreSlimSafeRelease.IsAlive(_triggerSemaphore))
						{
							Logger.Add_TPL(ex.ToString(), Logger.ForegroundLogFilename);
						}
					}
				}
				//else
				//{
				//	Task beginFailureAnim = RunInUiThreadAsync(delegate { FailureStoryboard.Begin(); });
				//}
				return isOk;
			});
		}
Esempio n. 14
0
		/// <summary>
		/// I need this override to stop any running media recording
		/// </summary>
		/// <returns></returns>
		//public override async Task<bool> CloseAsync() // LOLLO fix this like in AudioRecorderView if you want to use this class
		//{
		//	if (!_isOpen) return false;
		//	SemaphoreSlimSafeRelease.TryRelease(_triggerSemaphore);
		//	return await base.CloseAsync().ConfigureAwait(false);
		//}
		protected override async Task CloseMayOverrideAsync()
		{
			await Stop2Async().ConfigureAwait(false);
			SemaphoreSlimSafeRelease.TryDispose(_triggerSemaphore);
			_triggerSemaphore = null;
		}
Esempio n. 15
0
 /// <summary>
 /// Returns true if a SemaphoreSlimSafeRelease is not null and not disposed.
 /// </summary>
 /// <param name="semaphore"></param>
 /// <returns></returns>
 public static bool IsAlive(SemaphoreSlimSafeRelease semaphore)
 {
     return(semaphore != null && !semaphore._isDisposed);
 }
		protected override async Task CloseMayOverrideAsync()
		{
			await StopRecordingAsync().ConfigureAwait(false);

			SemaphoreSlimSafeRelease.TryDispose(_recordLockingSemaphore);
			_recordLockingSemaphore = null;

			var mc = _mediaCapture;
			if (mc != null)
			{
				mc.Failed -= OnMediaCapture_Failed;
				try
				{
					mc.Dispose();
				}
				catch { }
			}
			_mediaCapture = null;

			var audioRecorder = _audioRecorder;
			if (audioRecorder != null)
			{
				audioRecorder.UnrecoverableError -= OnAudioRecorder_UnrecoverableError;
				await audioRecorder.CloseAsync();
			}
			_audioRecorder = null;

			Task stopAllAnims = RunInUiThreadAsync(delegate
			{
				RecordingStoryboard.SkipToFill();
				RecordingStoryboard.Stop();
				FailureStoryboard.SkipToFill();
				FailureStoryboard.Stop();
			});
		}