public static Stream GetFileStream(string file)
{
Stream stream = null;
using (IsolatedStorageFile isf = IsolatedStorageFile.GetUserStoreForApplication())
{
if (!isf.FileExists(file))
{
using (IsolatedStorageFileStream fs = new IsolatedStorageFileStream(file, FileMode.Open, isf))
{
fs.CopyTo(stream, (int)fs.Length);
}
}
}
return stream;
}
/// <summary>
/// Resaves video clip from temporary directory to persistent
/// </summary>
private VideoResult SaveVideoClip()
{
try
{
using (IsolatedStorageFile isoFile = IsolatedStorageFile.GetUserStoreForApplication())
{
if (string.IsNullOrEmpty(filePath) || (!isoFile.FileExists(filePath)))
{
return new VideoResult(TaskResult.Cancel);
}
string fileName = String.Format(FileNameFormat, Guid.NewGuid().ToString());
string newPath = Path.Combine("/" + LocalFolderName + "/", fileName);
isoFile.CopyFile(filePath, newPath);
isoFile.DeleteFile(filePath);
memoryStream = new MemoryStream();
using (IsolatedStorageFileStream fileStream = new IsolatedStorageFileStream(newPath, FileMode.Open, isoFile))
{
fileStream.CopyTo(memoryStream);
}
VideoResult result = new VideoResult(TaskResult.OK);
result.VideoFileName = newPath;
result.VideoFile = this.memoryStream;
result.VideoFile.Seek(0, SeekOrigin.Begin);
return result;
}
}
catch (Exception)
{
return new VideoResult(TaskResult.None);
}
}
private static Stream GetReport() {
var stream = new MemoryStream();
try {
var writer = new StreamWriter(stream, Encoding.UTF8);
writer.WriteLine(reportOriginIdentity.ToString("B"));
writer.WriteLine(Util.LibraryVersion);
writer.WriteLine(".NET Framework {0}", Environment.Version);
foreach (var observation in observations) {
observation.Flush();
writer.WriteLine("====================================");
writer.WriteLine(observation.FileName);
try {
using (var fileStream = new IsolatedStorageFileStream(observation.FileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, file)) {
writer.Flush();
fileStream.CopyTo(writer.BaseStream);
}
} catch (FileNotFoundException) {
writer.WriteLine("(missing)");
}
}
// Not all event counters may have even loaded in this app instance.
// We flush the ones in memory, and then read all of them off disk.
foreach (var counter in events.Values) {
counter.Flush();
}
foreach (string eventFile in file.GetFileNames("event-*.txt")) {
writer.WriteLine("====================================");
writer.WriteLine(eventFile);
using (var fileStream = new IsolatedStorageFileStream(eventFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, file)) {
writer.Flush();
fileStream.CopyTo(writer.BaseStream);
}
}
// Make sure the stream is positioned at the beginning.
writer.Flush();
stream.Position = 0;
return stream;
} catch {
stream.Dispose();
throw;
}
}
} // StartVideoRecording()
private void StopVideoRecording()
{
try
{
// Stop recording.
if (captureSource.VideoCaptureDevice != null
&& captureSource.State == CaptureState.Started)
{
captureSource.Stop();
// Disconnect fileSink.
fileSink.CaptureSource = null;
fileSink.IsolatedStorageFileName = null;
// Set the button states and the message.
UpdateUI(ButtonState.Stopped, "Recording stopped...");
viewfinderRectangle.Fill = null;
// Create the file stream
isoVideoFile = new IsolatedStorageFileStream(fileName,
FileMode.Open, FileAccess.Read,
IsolatedStorageFile.GetUserStoreForApplication());
MemoryStream videoStream = new MemoryStream();
using (isoVideoFile)
{
isoVideoFile.CopyTo(videoStream);
}
PurposeColor.screens.AddEventsSituationsOrThoughts.ReceiveVideoFromWindows(videoStream, isoVideoFile.Name);
isoVideoFile.Flush();
isoVideoFile.Dispose();
isoVideoFile = null;
//videoStream = null;
DisposeVideoRecorder();
}
}
// If stop fails, display an error.
catch (Exception e)
{
this.Dispatcher.BeginInvoke(delegate()
{
txtDebug.Text = "ERROR: " + e.Message.ToString();
});
}
}//StopVideoRecording()
/// <summary>
/// Loads the State from Isolated Storage (in user store for domain)
/// </summary>
/// <remarks>
/// Sets <see cref="IsLoaded" /> after it's finished to prevent a race condition with saving the state to the MemoryStream.
/// </remarks>
public virtual void Load()
{
// Don't save or load state in design mode
if (DesignerProperties.GetIsInDesignMode(this.ribbon))
{
Debug.WriteLine("State not loaded from isolated storage. Because we are in design mode.");
this.IsLoaded = true;
return;
}
if (this.ribbon.AutomaticStateManagement == false)
{
this.IsLoaded = true;
Debug.WriteLine("State not loaded from isolated storage. Because automatic state management is disabled.");
return;
}
try
{
var storage = GetIsolatedStorageFile();
if (IsolatedStorageFileExists(storage, this.IsolatedStorageFileName))
{
using (var stream = new IsolatedStorageFileStream(this.IsolatedStorageFileName, FileMode.Open, FileAccess.Read, storage))
{
this.Load(stream);
// Copy loaded state to MemoryStream for temporary storage.
// Temporary storage is used for style changes etc. so we can apply the current state again.
stream.Position = 0;
this.memoryStream.Position = 0;
stream.CopyTo(this.memoryStream);
}
}
}
catch (Exception ex)
{
Trace.WriteLine($"Error while trying to load Ribbon state. Error: {ex}");
}
this.IsLoaded = true;
}
/// <summary>
/// Loads an audio buffer from isolated storage.
/// </summary>
public void LoadAudioBuffer(String fileName)
{
// Set the stream back to zero in case there is already something in it
stream.SetLength(0);
// Retrieve the named audio file from the storage.
IsolatedStorageFile myStore = IsolatedStorageFile.GetUserStoreForApplication();
try
{
using (var isoFileStream = new IsolatedStorageFileStream(
fileName,
FileMode.Open,
myStore))
{
isoFileStream.CopyTo(stream);
stream.Flush();
}
}
catch
{
MessageBox.Show("Error while trying to load audio buffer.");
}
}
/// <summary>
/// Read Isolated Storage file to memory
/// </summary>
/// <param name="fileName">filename</param>
/// <returns>MemoryStream</returns>
private static MemoryStream ReadFromIsolatedStorage(string fileName)
{
MemoryStream stream = new MemoryStream();
IsolatedStorageFile isoStore = IsolatedStorageFile.GetUserStoreForApplication();
if (isoStore.FileExists(fileName))
{
Console.WriteLine(fileName + " file read success.");
using (IsolatedStorageFileStream isoStream = new IsolatedStorageFileStream(fileName, FileMode.Open, isoStore))
{
isoStream.CopyTo(stream);
}
}
else
{
throw new Exception("Could not read from file");
}
return stream;
}
