public async Task Play(CoreDispatcher dispatcher)
{
LoggingMsg("Playing audio...");
MediaElement playback = new MediaElement();
IRandomAccessStream audio = buffer.CloneStream();
if (audio == null)
{
throw new ArgumentNullException("buffer");
}
StorageFolder storageFolder = ApplicationData.Current.LocalFolder;
if (!string.IsNullOrEmpty(filename))
{
StorageFile original = await storageFolder.GetFileAsync(filename);
await original.DeleteAsync();
}
await dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
{
recordingFile = await storageFolder.CreateFileAsync(RECORDING_FILE, CreationCollisionOption.ReplaceExisting);
filename = recordingFile.Name;
using (IRandomAccessStream fileStream = await recordingFile.OpenAsync(FileAccessMode.ReadWrite))
{
await RandomAccessStream.CopyAndCloseAsync(audio.GetInputStreamAt(0), fileStream.GetOutputStreamAt(0));
await audio.FlushAsync();
audio.Dispose();
}
IRandomAccessStream stream = await recordingFile.OpenAsync(FileAccessMode.Read);
playback.SetSource(stream, recordingFile.FileType);
//Time.Text = playback.NaturalDuration.TimeSpan.TotalSeconds.ToString();
playback.Play();
});
}
private async void StoreImage(WriteableBitmap bmp, SpriteTextureType spriteTextureType)
{
if (!EnableImageStoring)
{
return;
}
var folderDesc = await FolderOfType(spriteTextureType);
IRandomAccessStream stream = null;
DeleteFilesUntilIndex(folderDesc.folder, folderDesc.lastIndex);
try
{
folderDesc.lastIndex++;
var file = await folderDesc.folder.CreateFileAsync(folderDesc.lastIndex.ToString());
stream = await file.OpenAsync(FileAccessMode.ReadWrite);
if (stream.CanWrite)
{
await bmp.WriteBinAsync(stream);
await stream.FlushAsync();
stream.Dispose();
stream = null;
return;
}
}
catch
{
}
}
/// <inheritdoc/>
public async Task <string> WriteFileAsync(Stream stream, string nameWithExt, string localDirName = null)
{
StorageFolder dir;
if (string.IsNullOrWhiteSpace(localDirName))
{
dir = ApplicationData.Current.LocalFolder;
}
else
{
dir = await ApplicationData.Current.LocalFolder.CreateFolderAsync(
localDirName,
CreationCollisionOption.OpenIfExists);
}
StorageFile storageFile = await dir.CreateFileAsync(
nameWithExt,
CreationCollisionOption.ReplaceExisting);
using IRandomAccessStream fileStream = await storageFile.OpenAsync(FileAccessMode.ReadWrite);
await stream.CopyToAsync(fileStream.AsStreamForWrite());
await fileStream.FlushAsync();
return(storageFile.Path);
}
public async Task SaveRecordedAudio(CoreDispatcher UiDispatcher)
{
IRandomAccessStream audio = buffer.CloneStream();
if (audio == null)
{
throw new ArgumentNullException("buffer");
}
//StorageFolder storageFolder = Windows.ApplicationModel.Package.Current.InstalledLocation;
/*
* StorageFolder storageFolder = await DownloadsFolder.;
* if (!string.IsNullOrEmpty(filename))
* {
* StorageFile original = await storageFolder.GetFileAsync(filename);
* await original.DeleteAsync();
* }
*/
await UiDispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
{
//StorageFile storageFile = await storageFolder.CreateFileAsync(audioFile, CreationCollisionOption.GenerateUniqueName);
StorageFile storageFile = await DownloadsFolder.CreateFileAsync(audioFile, CreationCollisionOption.GenerateUniqueName);
filename = storageFile.Name;
using (IRandomAccessStream fileStream = await storageFile.OpenAsync(FileAccessMode.ReadWrite))
{
await RandomAccessStream.CopyAndCloseAsync(audio.GetInputStreamAt(0), fileStream.GetOutputStreamAt(0));
await audio.FlushAsync();
audio.Dispose();
}
//IRandomAccessStream stream = await storageFile.OpenAsync(FileAccessMode.Read);
LogMessage($"File {storageFile.Name} saved to {storageFile.Path}");
});
}
public async void SaveAudioToFile()
{
try
{
//await DeleteExistingFile();
MediaPlayer mediaPlayer = new MediaPlayer();
mediaPlayer.Source = MediaSource.CreateFromStream(_memoryBuffer, "MP3");
mediaPlayer.Play();
IRandomAccessStream audioStream = _memoryBuffer.CloneStream();
StorageFolder storageFolder = Package.Current.InstalledLocation;
StorageFile storageFile = await storageFolder.CreateFileAsync(DEFAULT_AUDIO_FILENAME, CreationCollisionOption.GenerateUniqueName);
this._fileName = storageFile.Name;
using (IRandomAccessStream fileStream = await storageFile.OpenAsync(FileAccessMode.ReadWrite))
{
await RandomAccessStream.CopyAndCloseAsync(audioStream.GetInputStreamAt(0), fileStream.GetOutputStreamAt(0));
await audioStream.FlushAsync();
audioStream.Dispose();
}
}
catch (Exception ex)
{
throw;
}
}
private async void SaveAudioToFile(InMemoryRandomAccessStream buffer)
{
try
{
IRandomAccessStream audioStream = buffer.CloneStream();
StorageFolder storageFolder = Package.Current.InstalledLocation;
StorageFile storageFile = await storageFolder.CreateFileAsync(DEFAULT_AUDIO_FILENAME, CreationCollisionOption.GenerateUniqueName);
this._fileName = storageFile.Name;
using (IRandomAccessStream fileStream = await storageFile.OpenAsync(FileAccessMode.ReadWrite))
{
await RandomAccessStream.CopyAndCloseAsync(audioStream.GetInputStreamAt(0), fileStream.GetOutputStreamAt(0));
await audioStream.FlushAsync();
audioStream.Dispose();
}
}
catch (Exception ex)
{
throw;
}
}
private async void LoadPdfFileAsync(StorageFile bookUrl)
{
try
{
ObservableCollection <BookPdf> bookPages = new ObservableCollection <BookPdf>();
PdfDocument pdfDocument = await PdfDocument.LoadFromFileAsync(bookUrl);
int count = 0;
popUp.IsOpen = true;
progressLoader.Maximum = (int)pdfDocument.PageCount;
pageCount.Text = pdfDocument.PageCount.ToString() + " Pages";
progressStatus.Text = "Loading Pages...";
for (int pageIndex = 0; pageIndex < pdfDocument.PageCount; pageIndex++)
{
var pdfPage = pdfDocument.GetPage((uint)pageIndex);
if (pdfPage != null)
{
StorageFolder tempFolder = ApplicationData.Current.TemporaryFolder;
StorageFile pngFile = await tempFolder.CreateFileAsync(Guid.NewGuid().ToString() + ".png", CreationCollisionOption.ReplaceExisting);
if (pngFile != null && pdfPage != null)
{
IRandomAccessStream randomStream = await pngFile.OpenAsync(FileAccessMode.ReadWrite);
await pdfPage.RenderToStreamAsync(randomStream);
await randomStream.FlushAsync();
randomStream.Dispose();
pdfPage.Dispose();
count++;
progressLoader.Value = pageIndex;
int progress = (100 * pageIndex) / (int)pdfDocument.PageCount;
downloadSize.Text = String.Format("{0} of {1} pages loaded - {2} % complete.", pageIndex, pdfDocument.PageCount, progress);
bookPages.Add(new BookPdf {
Id = pageIndex.ToString(), PageNumber = pageIndex.ToString(), ImagePath = pngFile.Path
});
}
}
}
if (progressLoader.Value >= 99 || count >= (int)pdfDocument.PageCount - 1)
{
progressStatus.Text = "Pages Loaded";
popUp.IsOpen = false;
}
bookPagesView.ItemsSource = bookPages;
}
catch (Exception ex)
{
var popup = new Windows.UI.Popups.MessageDialog("Cant load the file. The program might have failed to open the file or you are not connected");
popup.Commands.Add(new Windows.UI.Popups.UICommand("Ok"));
popup.DefaultCommandIndex = 0;
popup.CancelCommandIndex = 1;
var results = await popup.ShowAsync();
}
}
private async Task <StorageFile> DownloadDatasheet()
{
// Lien de la déclaration de confidentialité : "http://ma.ms.giz.fr/?name=Datasheet+Finder"
HttpClient client = new HttpClient();
client.DefaultRequestHeaders.TryAddWithoutValidation("User-Agent", "Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/31.0.1650.63 Safari/537.36");
StorageFile datasheetFile = null;
using (client)
using (var response = await client.GetAsync(DatasheetURL))
{
if (response.Content.Headers.ContentType.MediaType == "application/pdf")
{
// TODO : add temporary images and datasheets in specific folders
datasheetFile = await ApplicationData.Current.TemporaryFolder.CreateFileAsync(Guid.NewGuid().ToString() + ".pdf", CreationCollisionOption.ReplaceExisting);
using (IRandomAccessStream fs = await datasheetFile.OpenAsync(FileAccessMode.ReadWrite))
using (DataWriter writer = new DataWriter(fs.GetOutputStreamAt(0)))
{
writer.WriteBytes(await response.Content.ReadAsByteArrayAsync());
await writer.StoreAsync();
await fs.FlushAsync();
}
}
}
return(datasheetFile);
}
/// <summary>
/// Saves the audio to a file in our local state folder
/// </summary>
/// <returns>the saved file's name</returns>
/// <exception cref="ArgumentException"></exception>
/// <exception cref="ArgumentNullException"></exception>
public async Task <string> SaveAudioToFile()
{
string dateToday = DateTime.Now.ToString("yyyy-MM-dd");
string ticks = DateTime.Now.Ticks.ToString();
string mp3 = ".mp3";
string fileName = String.Format("record_{0}_{1}{2}", dateToday, ticks, mp3);
StorageFolder localStateFolder = ApplicationData.Current.LocalFolder;
StorageFolder storageFolder;
if (!Directory.Exists(Path.Combine(localStateFolder.Path, "VoiceNotes")))
{
storageFolder = await localStateFolder.CreateFolderAsync("VoiceNotes");
}
else
{
storageFolder = await localStateFolder.GetFolderAsync("VoiceNotes");
}
IRandomAccessStream audioStream = this.MemoryBuffer.CloneStream();
StorageFile storageFile = await storageFolder.CreateFileAsync(fileName, CreationCollisionOption.GenerateUniqueName);
this._fileName = storageFile.Name;
using (IRandomAccessStream fileStream = await storageFile.OpenAsync(FileAccessMode.ReadWrite))
{
await RandomAccessStream.CopyAndCloseAsync(audioStream.GetInputStreamAt(0), fileStream.GetOutputStreamAt(0));
await audioStream.FlushAsync();
audioStream.Dispose();
}
this.DisposeMemoryBuffer();
return(this._fileName);
}
public async Task <IMediaModel> GenerateThumbImageFromVideo(DirectoryInfo argCurrentDataFolder, MediaModel argExistingMediaModel, IMediaModel argNewMediaModel)
{
StorageFolder currentFolder = await StorageFolder.GetFolderFromPathAsync(argCurrentDataFolder.FullName);
StorageFile outfile = await currentFolder.CreateFileAsync(argNewMediaModel.OriginalFilePath, CreationCollisionOption.ReplaceExisting);
//if (outfile.Name == "_e9e27fbe8ed34e9b554a0ba93aa~imagevideo.jpg")
//{
//}
StorageFile videoFile = await currentFolder.GetFileAsync(argExistingMediaModel.OriginalFilePath);
StorageItemThumbnail thumbnail = await videoFile.GetThumbnailAsync(ThumbnailMode.SingleItem);
Windows.Storage.Streams.Buffer MyBuffer = new Windows.Storage.Streams.Buffer(Convert.ToUInt32(thumbnail.Size));
IBuffer iBuf = await thumbnail.ReadAsync(MyBuffer, MyBuffer.Capacity, InputStreamOptions.None);
IRandomAccessStream strm = await outfile.OpenAsync(FileAccessMode.ReadWrite);
await strm.WriteAsync(iBuf);
await strm.FlushAsync();
strm.Dispose();
// check size
BasicProperties outProperties = await outfile.GetBasicPropertiesAsync();
if (outProperties.Size == 0)
{
return(new MediaModel());
}
return(argNewMediaModel);
}
public async Task PlayVoice(CoreDispatcher dispatcher) //Plays the voice recording back
{
MediaElement playVoice = new MediaElement();
IRandomAccessStream voice = buffer.CloneStream();
if (voice == null)
{
throw new ArgumentNullException("BUFFER");
}
StorageFolder appFolder = Windows.ApplicationModel.Package.Current.InstalledLocation;
if (!string.IsNullOrEmpty(appFile))
{
StorageFile sf = await appFolder.GetFileAsync(appFile);
await sf.DeleteAsync();
}
await dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
{
StorageFile file = await appFolder.CreateFileAsync(voiceFile, CreationCollisionOption.GenerateUniqueName);
appFile = file.Name;
using (IRandomAccessStream fileStream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
await RandomAccessStream.CopyAndCloseAsync(voice.GetInputStreamAt(0), fileStream.GetOutputStreamAt(0));
await voice.FlushAsync();
voice.Dispose();
}
IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.Read);
playVoice.SetSource(stream, file.FileType);
playVoice.Play();
});
}
private async Task SaveImageToStream(IRandomAccessStream stream)
{
// render bitmap
var desiredWidth = (uint)Window.Current.Bounds.Right;
var desiredHeight = (uint)Window.Current.Bounds.Bottom;
TileCanvas.Width = desiredWidth;
TileCanvas.Height = desiredHeight;
var bitmap = new RenderTargetBitmap();
await bitmap.RenderAsync(TileCanvas);
IBuffer pixels = await bitmap.GetPixelsAsync();
byte[] bytes = pixels.ToArray();
// encode bitmap
var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, stream);
encoder.BitmapTransform.Bounds = new BitmapBounds
{
Width = desiredWidth,
Height = desiredHeight
};
encoder.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied, (uint)bitmap.PixelWidth, (uint)bitmap.PixelHeight, 96, 96, bytes);
await encoder.FlushAsync();
await stream.FlushAsync();
}
protected async Task <string> SaveBitmapFile(WriteableBitmap wb)
{
EventSource.Log.Debug("SaveBitmapFile()");
// Copy our current color image
DateTime now = DateTime.Now;
string fileName = "KinectPhotobooth" + "-" + now.ToString("s").Replace(":", "-") + "-" + now.Millisecond.ToString() + ".png";
StorageFile file = await this.targetFolder.CreateFileAsync(fileName, CreationCollisionOption.GenerateUniqueName);
IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.ReadWrite);
BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, stream);
Stream pixelStream = wb.PixelBuffer.AsStream();
byte[] pixels = new byte[pixelStream.Length];
await pixelStream.ReadAsync(pixels, 0, pixels.Length);
encoder.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore, (uint)wb.PixelWidth, (uint)wb.PixelHeight, 96.0, 96.0, pixels);
// clean up
pixelStream.Dispose();
await encoder.FlushAsync();
await stream.FlushAsync();
stream.Dispose();
return(fileName);
}
/// <summary>
/// The download.
/// </summary>
/// <returns>
/// The <see cref="Task"/> to run asynchronously.
/// </returns>
private async Task Download()
{
var page = DataManager.CurrentPage;
var url = page.Url.ToString();
var nameOnDisk =
url.Substring(url.LastIndexOf("//", StringComparison.CurrentCultureIgnoreCase) + 2)
.Replace(".", "_")
.Replace("/", "-");
if (nameOnDisk.EndsWith("-"))
{
nameOnDisk = nameOnDisk.Substring(0, nameOnDisk.Length - 1);
}
var filename = string.Format("{0}.txt", nameOnDisk);
var download = await DownloadsFolder.CreateFileAsync(filename, CreationCollisionOption.GenerateUniqueName);
// await FileIO.WriteTextAsync(download, page.Text, Windows.Storage.Streams.UnicodeEncoding.Utf8);
using (IRandomAccessStream stream = await download.OpenAsync(FileAccessMode.ReadWrite))
{
await stream.WriteAsync(Encoding.UTF8.GetBytes(page.Text).AsBuffer());
await stream.FlushAsync();
}
var dialog = new MessageDialog(
"Successfully downloaded the page as text to your Downloads folder.",
download.Name);
await dialog.ShowAsync();
}
async public static void Log(string s)
{
using (var releaser = await myLock.LockAsync())
{
StorageFile sfile = await ApplicationData.Current.LocalFolder.CreateFileAsync("errorlog.txt", CreationCollisionOption.OpenIfExists);
using (IRandomAccessStream rasw = await sfile.OpenAsync(FileAccessMode.ReadWrite))
{
IBuffer ibuf = null;
using (IInputStream inputStream = rasw.GetInputStreamAt(0))
{
ulong size = rasw.Size;
DataReader dataReader = new DataReader(inputStream);
await dataReader.LoadAsync((uint)size);
ibuf = dataReader.ReadBuffer((uint)size);
inputStream.Dispose();
}
if (ibuf.Length < 64000)
{
await rasw.WriteAsync(ibuf);
}
await rasw.WriteAsync(CryptographicBuffer.ConvertStringToBinary("\r\n" + DateTime.Now.ToUniversalTime().ToString() + " : " + s, BinaryStringEncoding.Utf8));
rasw.Seek(0);
await rasw.FlushAsync();
rasw.Dispose();
}
}
}
public async Task Play(CoreDispatcher dispatcher, MediaElement playback)
{
IRandomAccessStream video = buffer.CloneStream();
if (video == null)
{
throw new ArgumentNullException("buffer");
}
StorageFolder storageFolder = Windows.ApplicationModel.Package.Current.InstalledLocation;
if (!string.IsNullOrEmpty(filename))
{
StorageFile original = await storageFolder.GetFileAsync(filename);
await original.DeleteAsync();
}
await dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
{
StorageFile storageFile = await storageFolder.CreateFileAsync(videoFilename, CreationCollisionOption.GenerateUniqueName);
filename = storageFile.Name;
using (IRandomAccessStream fileStream = await storageFile.OpenAsync(FileAccessMode.ReadWrite))
{
await RandomAccessStream.CopyAndCloseAsync(video.GetInputStreamAt(0), fileStream.GetOutputStreamAt(0));
await video.FlushAsync();
video.Dispose();
}
IRandomAccessStream stream = await storageFile.OpenAsync(FileAccessMode.Read);
playback.SetSource(stream, storageFile.FileType);
playback.Play();
});
}
/// <summary>
/// Clicking on the save button saves the photo in MainPage.ImageStream
/// to media library camera roll. Once image has been saved, the
/// application will navigate back to the main page.
/// </summary>
private async void SaveButton_Click(object sender, RoutedEventArgs e)
{
int selectedIndex = FilterPreviewListView.SelectedIndex;
DataContext dataContext = FilterEffects.DataContext.Instance;
// Create the File Picker control
var picker = new FileSavePicker();
picker.FileTypeChoices.Add("JPG File", new List <string> {
".jpg"
});
StorageFile file = await picker.PickSaveFileAsync();
if (file != null)
{
// If the file path and name is entered properly, and user has not tapped 'cancel'..
AbstractFilter filter = _filters[selectedIndex];
IBuffer buffer = await filter.RenderJpegAsync(
dataContext.FullResolutionStream.GetWindowsRuntimeBuffer());
using (IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
await stream.WriteAsync(buffer);
await stream.FlushAsync();
}
ShowToast(Strings.ImageSavedAs + file.Name);
}
}
public async Task Play(CoreDispatcher dispatcher)
{
MediaElement playback = new MediaElement();
IRandomAccessStream audio = buffer.CloneStream();
if (audio == null)
{
throw new ArgumentNullException("buffer");
}
StorageFolder storageFolder = ApplicationData.Current.LocalFolder;
if (!string.IsNullOrEmpty(filename))
{
StorageFile original = await storageFolder.GetFileAsync(filename);
await original.DeleteAsync();
}
await dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
{
StorageFile storageFile = await storageFolder.CreateFileAsync(audioFilename, CreationCollisionOption.ReplaceExisting);
filename = storageFile.Name;
using (IRandomAccessStream fileStream = await storageFile.OpenAsync(FileAccessMode.ReadWrite))
{
await RandomAccessStream.CopyAndCloseAsync(audio.GetInputStreamAt(0), fileStream.GetOutputStreamAt(0));
await audio.FlushAsync();
audio.Dispose();
}
IRandomAccessStream stream = await storageFile.OpenAsync(FileAccessMode.Read);
playback.SetSource(stream, "");
playback.Play();
});
}
public static async Task <StorageFile> AsUIScreenShotFileAsync(this UIElement elememtName, string ReplaceLocalFileNameWithExtension)
{
StorageFile file = await ApplicationData.Current.LocalFolder.CreateFileAsync(ReplaceLocalFileNameWithExtension, CreationCollisionOption.ReplaceExisting);
try
{
RenderTargetBitmap renderTargetBitmap = new RenderTargetBitmap();
InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream();
// Render to an image at the current system scale and retrieve pixel contents
await renderTargetBitmap.RenderAsync(elememtName);
var pixelBuffer = await renderTargetBitmap.GetPixelsAsync();
// Encode image to an in-memory stream
var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, stream);
encoder.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore, (uint)renderTargetBitmap.PixelWidth, (uint)renderTargetBitmap.PixelHeight,
DisplayInformation.GetForCurrentView().LogicalDpi,
DisplayInformation.GetForCurrentView().LogicalDpi, pixelBuffer.ToArray());
await encoder.FlushAsync();
//CreatingFolder
// var folder = Windows.Storage.ApplicationData.Current.LocalFolder;
RandomAccessStreamReference rasr = RandomAccessStreamReference.CreateFromStream(stream);
var streamWithContent = await rasr.OpenReadAsync();
byte[] buffer = new byte[streamWithContent.Size];
await streamWithContent.ReadAsync(buffer.AsBuffer(), (uint)streamWithContent.Size, InputStreamOptions.None);
using (IRandomAccessStream fileStream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
using (IOutputStream outputStream = fileStream.GetOutputStreamAt(0))
{
using (DataWriter dataWriter = new DataWriter(outputStream))
{
dataWriter.WriteBytes(buffer);
await dataWriter.StoreAsync(); //
dataWriter.DetachStream();
}
// write data on the empty file:
await outputStream.FlushAsync();
}
await fileStream.FlushAsync();
}
// await file.CopyAsync(folder, "tempFile.jpg", NameCollisionOption.ReplaceExisting);
}
catch (Exception ex)
{
Reporting.DisplayMessageDebugExemption(ex);
}
return(file);
}
public override void Flush()
{
if (_disposed)
{
throw new ObjectDisposedException("_stream");
}
Task.Run(async() => await _stream.FlushAsync()).Wait();
}
public static async Task <StorageFile> CropImage(IRandomAccessStream fs, int newWidth, int newHeight)
{
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(fs);
StorageFile file = await FileHelper.CreateLocalFile("cropped.jpg", "Cache", true);
IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.ReadWrite);
BitmapEncoder enc = await BitmapEncoder.CreateForTranscodingAsync(stream, decoder);
enc.BitmapTransform.ScaledWidth = (uint)newWidth;
enc.BitmapTransform.ScaledHeight = (uint)newHeight;
var MaxImageWidth = 100;
var MaxImageHeight = 100;
if (newWidth > MaxImageWidth || newHeight > MaxImageHeight)
{
BitmapBounds bounds = new BitmapBounds();
if (newWidth > MaxImageWidth)
{
bounds.Width = (uint)MaxImageWidth;
bounds.X = (uint)(newWidth - MaxImageWidth) / 2;
}
else
{
bounds.Width = (uint)newWidth;
}
if (newHeight > MaxImageHeight)
{
bounds.Height = (uint)MaxImageHeight;
bounds.Y = (uint)(newHeight - MaxImageHeight) / 2;
}
else
{
bounds.Height = (uint)newHeight;
}
enc.BitmapTransform.Bounds = bounds;
}
try
{
await enc.FlushAsync();
}
catch (Exception ex)
{
string s = ex.ToString();
}
await stream.FlushAsync();
stream.Dispose();
fs.Dispose();
return(file);
}
private async void loadWebViewToStream(WebView webview, IRandomAccessStream stream)
{
await Task.Delay(TimeSpan.FromMilliseconds(10));
await webview.CapturePreviewToStreamAsync(stream);
await stream.FlushAsync();
stream.Seek(0);
}
private async void StropButton_Click(object sender, RoutedEventArgs e)
{
await mediaCapture.StopRecordAsync();
await randomAccessStream.FlushAsync();
randomAccessStream.Seek(0);
// want to convert this randomAccessStream into byte[]
mediaElement.SetSource(randomAccessStream, "video/x-ms-wmv");
}
async Task <byte[]> ToBytesArray(IRandomAccessStream s, int size)
{
var dr = new DataReader(s.GetInputStreamAt(0));
var bytes = new byte[size];
await dr.LoadAsync((uint)size);
dr.ReadBytes(bytes);
await s.FlushAsync();
return(bytes);
}
/// <summary>
///
/// </summary>
/// <param name="file"></param>
/// <returns></returns>
private async Task <bool> SaveImageFileAsync(StorageFile file)
{
using (IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
await stream.WriteAsync(_imageBuffer);
await stream.FlushAsync();
}
return(true);
}
public async Task <StorageFile> Download()
{
if (m_SourceUri == null || m_SourceUri.IsFile)
{
return(null);
}
StorageFile tempFile = await m_DestinationStorageFolder.CreateFileAsync(m_DestinationFileName + ".tmp", CreationCollisionOption.GenerateUniqueName);
using (HttpClient httpClient = new HttpClient())
{
httpClient.DefaultRequestHeaders.Add("user-agent", "Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; WOW64; Trident/6.0)");
HttpResponseMessage response = await httpClient.GetAsync(m_SourceUri, HttpCompletionOption.ResponseHeadersRead);
if (response.StatusCode != HttpStatusCode.Ok /*||
* Path.GetFileName(response.RequestMessage.RequestUri.AbsoluteUri) != Path.GetFileName(m_SourceUri.ToString())*/)
{
string result = await response.Content.ReadAsStringAsync();
throw new Exception(result);
}
if (response.Content.Headers.ContentLength != null)
{
m_TotalBytes = response.Content.Headers.ContentLength.Value;
}
IBuffer buffer = new Windows.Storage.Streams.Buffer(m_bufferSize);
using (IRandomAccessStream fileStream = await tempFile.OpenAsync(FileAccessMode.ReadWrite))
{
using (IInputStream httpStream = await response.Content.ReadAsInputStreamAsync())
{
do
{
await httpStream.ReadAsync(buffer, m_bufferSize, InputStreamOptions.ReadAhead);
if (buffer.Length > 0)
{
await fileStream.WriteAsync(buffer);
if (m_Progress != null)
{
m_DownloadedBytes += buffer.Length;
((IProgress <Downloader>)m_Progress).Report(this);
}
}
}while (buffer.Length > 0);
}
await fileStream.FlushAsync();
}
}
await tempFile.RenameAsync(Path.GetFileName(m_DestinationFileName), NameCollisionOption.ReplaceExisting);
return(tempFile);
}
private async void LoadTrang()
{
Debug.WriteLine(FileName);
DateTime startTime = DateTime.Now;
if (PdfImages == null)
{
PdfImages = new ObservableCollection <string>();
}
PdfImages.Clear();
Uri fileTarget = new Uri(@"ms-appx:///KhoChuaDe/" + FileName + ".pdf");
var file = await Package.Current.InstalledLocation.GetFileAsync(@"KhoChuaDe\" + FileName + ".pdf");
var pdfFile = await PdfDocument.LoadFromFileAsync(file);
if (pdfFile == null)
{
return;
}
tongsotrang.Text = pdfFile.PageCount.ToString();
pagecount = pdfFile.PageCount;
for (uint i = 0; i < pdfFile.PageCount; i++)
{
StorageFolder tempFolder = ApplicationData.Current.LocalFolder;
StorageFile jpgFile = await tempFolder.CreateFileAsync(
pdfFile + "-Page-" + i.ToString() + ".png",
CreationCollisionOption.ReplaceExisting
);
var pdfPage = pdfFile.GetPage(i);
if (jpgFile != null && pdfPage != null)
{
IRandomAccessStream randomStream = await jpgFile.OpenAsync(FileAccessMode.ReadWrite);
await pdfPage.RenderToStreamAsync(randomStream);
await randomStream.FlushAsync();
randomStream.Dispose();
pdfPage.Dispose();
}
PdfImages.Add(jpgFile.Path);
}
this.pdfViewer.ItemsSource = PdfImages;
TimeSpan processTime = DateTime.Now - startTime;
Debug.WriteLine(processTime.TotalMilliseconds + " ms to process PDF");
}
public void Flush()
{
if (acts.Count > 0)
{
acts.Add(rs.FlushAsync().AsTask().Wait);
foreach (var w in acts)
{
w();
}
}
acts.Clear();
}
private async void LoadPdfFileAsync(StorageFile selectedFile)
{
try
{
StorageFile pdfFile = selectedFile;
//Load Pdf File
PdfDocument pdfDocument = await PdfDocument.LoadFromFileAsync(pdfFile);;
ObservableCollection <SampleDataItem> items = new ObservableCollection <SampleDataItem>();
this.DefaultViewModel["Items"] = items;
if (pdfDocument != null && pdfDocument.PageCount > 0)
{
//Get Pdf page
for (int pageIndex = 0; pageIndex < pdfDocument.PageCount; pageIndex++)
{
var pdfPage = pdfDocument.GetPage((uint)pageIndex);
if (pdfPage != null && navigate == false)
{
// next, generate a bitmap of the page
StorageFolder tempFolder = ApplicationData.Current.TemporaryFolder;
StorageFile pngFile = await tempFolder.CreateFileAsync(Guid.NewGuid().ToString() + ".png", CreationCollisionOption.ReplaceExisting);
if (pngFile != null)
{
IRandomAccessStream randomStream = await pngFile.OpenAsync(FileAccessMode.ReadWrite);
PdfPageRenderOptions pdfPageRenderOptions = new PdfPageRenderOptions();
pdfPageRenderOptions.DestinationWidth = (uint)(this.ActualWidth - 130);
await pdfPage.RenderToStreamAsync(randomStream, pdfPageRenderOptions);
await randomStream.FlushAsync();
if (navigate == false)
{
randomStream.Dispose();
pdfPage.Dispose();
items.Add(new SampleDataItem(
pageIndex.ToString(),
pageIndex.ToString(),
pngFile.Path));
}
}
}
}
}
}
catch (Exception err)
{
}
}
private async void SaveLocalData_Unloaded(object sender, RoutedEventArgs e)
{
// Export XML to app local folder
var folder = Windows.Storage.ApplicationData.Current.LocalFolder;
var file = await folder.CreateFileAsync(Strings.ExportFileName, Windows.Storage.CreationCollisionOption.OpenIfExists);
IRandomAccessStream stream = await file.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite);
await sched1.DataStorage.ExportAsync(stream.AsStreamForWrite(), C1.C1Schedule.FileFormatEnum.XML);
await stream.FlushAsync();
stream.Dispose();
}
private async Task Play(IRandomAccessStream buffer)
{
if (buffer == null)
throw new ArgumentNullException("buffer");
var storageFolder = Windows.ApplicationModel.Package.Current.InstalledLocation;
if (!string.IsNullOrEmpty(_fileName))
{
var oldFile = await storageFolder.GetFileAsync(_fileName);
await oldFile.DeleteAsync();
}
await Dispatcher.RunAsync(
CoreDispatcherPriority.Normal,
async () =>
{
var storageFile = await storageFolder.CreateFileAsync(AudioFileName, CreationCollisionOption.GenerateUniqueName);
_fileName = storageFile.Name;
using (var fileStream = await storageFile.OpenAsync(FileAccessMode.ReadWrite))
{
await RandomAccessStream.CopyAndCloseAsync(
buffer.GetInputStreamAt(0),
fileStream.GetOutputStreamAt(0));
await buffer.FlushAsync();
buffer.Dispose();
}
var stream = await storageFile.OpenAsync(FileAccessMode.Read);
playBack.SetSource(stream, storageFile.FileType);
playBack.Play();
});
}
private async void loadWebViewToStream(WebView webview, IRandomAccessStream stream)
{
await Task.Delay(TimeSpan.FromMilliseconds(10));
await webview.CapturePreviewToStreamAsync(stream);
await stream.FlushAsync();
stream.Seek(0);
}
