public static IRandomAccessStream AsRandomAccessStream( this Stream stream )
{
var randomAccessStream = new InMemoryRandomAccessStream();
var s = randomAccessStream.AsStreamForWrite();
stream.CopyTo(s);
return randomAccessStream;
}
public byte[] DrawStrokeOnImageBackground(IReadOnlyList<InkStroke> strokes, byte[] backgroundImageBuffer)
{
var stmbuffer = new InMemoryRandomAccessStream();
stmbuffer.AsStreamForWrite().AsOutputStream().WriteAsync(backgroundImageBuffer.AsBuffer()).AsTask().Wait();
CanvasDevice device = CanvasDevice.GetSharedDevice();
var canbit = CanvasBitmap.LoadAsync(device, stmbuffer, 96).AsTask().Result;
CanvasRenderTarget renderTarget = new CanvasRenderTarget(device, canbit.SizeInPixels.Width, canbit.SizeInPixels.Height, 96);
using (var ds = renderTarget.CreateDrawingSession())
{
ds.Clear(Colors.Transparent);
if (backgroundImageBuffer != null)
{
ds.DrawImage(canbit);
}
ds.DrawInk(strokes);
}
var stm = new InMemoryRandomAccessStream();
renderTarget.SaveAsync(stm, CanvasBitmapFileFormat.Png).AsTask().Wait();
var readfrom = stm.GetInputStreamAt(0).AsStreamForRead();
var ms = new MemoryStream();
readfrom.CopyTo(ms);
var outputBuffer = ms.ToArray();
return outputBuffer;
}
public async Task<BitmapSource> LoadImageAsync(Stream imageStream, Uri uri)
{
if (imageStream == null)
{
return null;
}
var stream = new InMemoryRandomAccessStream();
imageStream.CopyTo(stream.AsStreamForWrite());
stream.Seek(0);
BitmapImage bitmap = new BitmapImage();
await bitmap.SetSourceAsync(stream);
// convert to a writable bitmap so we can get the PixelBuffer back out later...
// in case we need to edit and/or re-encode the image.
WriteableBitmap bmp = new WriteableBitmap(bitmap.PixelHeight, bitmap.PixelWidth);
stream.Seek(0);
bmp.SetSource(stream);
List<Byte> allBytes = new List<byte>();
byte[] buffer = new byte[4000];
int bytesRead = 0;
while ((bytesRead = await imageStream.ReadAsync(buffer, 0, 4000)) > 0)
{
allBytes.AddRange(buffer.Take(bytesRead));
}
DataContainerHelper.Instance.WriteableBitmapToStorageFile(bmp, uri);
return bmp;
}
private async void Button_Click(object sender, RoutedEventArgs e)
{
var openPicker = new FileOpenPicker
{
ViewMode = PickerViewMode.Thumbnail,
SuggestedStartLocation = PickerLocationId.PicturesLibrary
};
openPicker.FileTypeFilter.Add(".jpg");
openPicker.FileTypeFilter.Add(".jpeg");
var file = await openPicker.PickSingleFileAsync();
if (file == null) return;
using (var fileStream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
// Display input image
var imageIn = new BitmapImage();
await imageIn.SetSourceAsync(fileStream);
InputImage.Source = imageIn;
// Rewind
fileStream.Seek(0);
// Decode
var jpegIn = new JpegDecoder(fileStream.AsStreamForRead()).Decode();
if (!ImageResizer.ResizeNeeded(jpegIn.Image, 320))
{
OutputImage.Source = null;
OutputText.Text = "No resize necessary.";
return;
}
// Resize
var jpegOut = new DecodedJpeg(
new ImageResizer(jpegIn.Image)
.ResizeToScale(320, ResamplingFilters.NearestNeighbor),
jpegIn.MetaHeaders); // Retain EXIF details
// Encode
using (var outStream = new InMemoryRandomAccessStream())
{
new JpegEncoder(jpegOut, 90, outStream.AsStreamForWrite()).Encode();
// Display
outStream.Seek(0);
var image = new BitmapImage();
await image.SetSourceAsync(outStream);
OutputImage.Source = image;
}
}
}
///<summary>
/// Creates a file parameter from an array of bytes.
///</summary>
///<param name="name">The parameter name to use in the request.</param>
///<param name="data">The data to use as the file's contents.</param>
///<param name="filename">The filename to use in the request.</param>
///<param name="contentType">The content type to use in the request.</param>
///<returns>The <see cref="FileParameter"/></returns>
public static FileParameter Create(string name, [ReadOnlyArray]byte[] data, string filename, string contentType)
{
var length = (long)data.Length;
var stream = new InMemoryRandomAccessStream();
stream.AsStreamForWrite().Write(data,0,data.Length);
return new FileParameter
{
Content = data,
FileName = filename,
ContentType = contentType,
ContentLength = length,
Name = name
};
}
public object Convert(object value, Type targetType, object parameter, string language)
{
// Get bytes and create new bitmap image
byte[] bytes = value as byte[];
BitmapImage image = new BitmapImage();
// Write bytes to stream
InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream();
stream.AsStreamForWrite().Write(bytes, 0, bytes.Length);
stream.Seek(0);
// Set stream as image source
image.SetSource(stream);
ImageSource source = image;
return image;
}
public object Convert(object value, Type targetType, object parameter, string culture)
{
try
{
Message message = value as Message;
byte[] imageBytes = (message.Attachments[0] as FileAttachment).ContentBytes;
BitmapImage image = new BitmapImage();
image.DecodePixelWidth = 300;
InMemoryRandomAccessStream ms = new InMemoryRandomAccessStream();
ms.AsStreamForWrite(imageBytes.Length).Write(imageBytes, 0, imageBytes.Length);
ms.Seek(0);
image.SetSource(ms);
return image;
}
catch (Exception ex)
{
throw ex;
}
}
protected async Task<WriteableBitmap> GetImage(string url)
{
try
{
IBuffer buffer = await BaseService.SendGetRequestAsBytes(url);
if (buffer != null)
{
BitmapImage bi = new BitmapImage();
WriteableBitmap wb = null; Stream stream2Write;
using (InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream())
{
stream2Write = stream.AsStreamForWrite();
await stream2Write.WriteAsync(buffer.ToArray(), 0, (int)buffer.Length);
await stream2Write.FlushAsync();
stream.Seek(0);
await bi.SetSourceAsync(stream);
wb = new WriteableBitmap(bi.PixelWidth, bi.PixelHeight);
stream.Seek(0);
await wb.SetSourceAsync(stream);
return wb;
}
}
else
{
return null;
}
}
catch
{
return null;
}
}
public async Task<IBitmap> Load(Stream sourceStream, float? desiredWidth, float? desiredHeight)
{
using (var rwStream = new InMemoryRandomAccessStream()) {
await sourceStream.CopyToAsync(rwStream.AsStreamForWrite());
var decoder = await BitmapDecoder.CreateAsync(rwStream);
var transform = new BitmapTransform();
if (desiredWidth != null) {
transform.ScaledWidth = (uint)desiredWidth;
transform.ScaledHeight = (uint)desiredHeight;
}
var pixelData = await decoder.GetPixelDataAsync(decoder.BitmapPixelFormat, decoder.BitmapAlphaMode, transform, ExifOrientationMode.RespectExifOrientation, ColorManagementMode.ColorManageToSRgb);
var pixels = pixelData.DetachPixelData();
WriteableBitmap bmp = new WriteableBitmap((int)decoder.OrientedPixelWidth, (int)decoder.OrientedPixelHeight);
using (var bmpStream = bmp.PixelBuffer.AsStream()) {
bmpStream.Seek(0, SeekOrigin.Begin);
bmpStream.Write(pixels, 0, (int)bmpStream.Length);
return (IBitmap) new WriteableBitmapImageBitmap(bmp);
}
}
}
/// <summary>
/// 向服务器发送请求 获取图片
/// </summary>
/// <param name="url"></param>
/// <returns></returns>
async public Task<WriteableBitmap> GetImageResponse(string url)
{
try
{
IBuffer buffer = await BaseService.SendGetRequestAsBytesAsync(url);
if (buffer != null)
{
BitmapImage bitmapImage = new BitmapImage();
using (var memoryStream = new InMemoryRandomAccessStream())
{
Stream streamWriter = memoryStream.AsStreamForWrite();
await streamWriter.WriteAsync(buffer.ToArray(), 0, (int)buffer.Length);
await streamWriter.FlushAsync();
memoryStream.Seek(0);
await bitmapImage.SetSourceAsync(memoryStream);
WriteableBitmap writeableBitmap = new WriteableBitmap(bitmapImage.PixelWidth, bitmapImage.PixelHeight);
memoryStream.Seek(0);
await writeableBitmap.SetSourceAsync(memoryStream);
return writeableBitmap;
}
}
return null;
}
catch (Exception)
{
return null;
}
}
/// <summary>
/// Used to service the given request. Once the image has been responded to the
/// function will continue with requests until the queue is empty
/// </summary>
/// <param name="startingRequestedContext">The request to start with</param>
/// <returns></returns>
private async Task ServiceRequest(ImageManagerRequestInternal startingRequestedContext)
{
ImageManagerRequestInternal currentRequest = startingRequestedContext;
while (currentRequest != null)
{
// Service the request in a try catch
try
{
string fileName = MakeFileNameFromUrl(currentRequest.Context.Url);
// First check if we have the file
if (m_baconMan.CacheMan.HasFileCached(fileName))
{
// If we have it cached pull it from there
}
else
{
// If not we have to get the image
IBuffer imgBuffer = await m_baconMan.NetworkMan.MakeRawGetRequest(currentRequest.Context.Url);
// Turn the stream into an image
InMemoryRandomAccessStream imageStream = new InMemoryRandomAccessStream();
Stream readStream = imgBuffer.AsStream();
Stream writeStream = imageStream.AsStreamForWrite();
// Copy the buffer
// #todo perf - THERE HAS TO BE A BTTER WAY TO DO THIS.
readStream.CopyTo(writeStream);
writeStream.Flush();
// Seek to the start.
imageStream.Seek(0);
// Create a response
ImageManagerResponseEventArgs response = new ImageManagerResponseEventArgs()
{
ImageStream = imageStream,
Request = currentRequest.Context,
Success = true
};
// Fire the callback
currentRequest.Context.m_onRequestComplete.Raise(currentRequest.Context, response);
}
}
catch (Exception e)
{
// Report the error
m_baconMan.MessageMan.DebugDia("Error getting image", e);
// Create a response
ImageManagerResponseEventArgs response = new ImageManagerResponseEventArgs()
{
Request = currentRequest.Context,
Success = false
};
// Send the response
currentRequest.Context.m_onRequestComplete.Raise(currentRequest.Context, response);
}
// Once we are done, check to see if there is another we should service.
lock (m_requestList)
{
// Remove the current request.
m_requestList.Remove(currentRequest);
// Kill the current request
currentRequest = null;
// Check if there is another request we should service now.
for (int i = 0; i < MAX_RUNNING_IMAGE_REQUESTS; i++)
{
if (m_requestList.Count > i && !m_requestList[i].isServicing)
{
currentRequest = m_requestList[i];
currentRequest.isServicing = true;
break;
}
}
}
}
}
public static async Task SendEmailWithLogsAsync(string recipient, string appName)
{
EmailRecipient emailRecipient = new EmailRecipient(recipient);
EmailMessage emailMsg = new EmailMessage { Subject = string.Format("Feedback from {0} with logs", appName) };
emailMsg.To.Add(emailRecipient);
//emailMsg.Body = await ReadAllLogsIntoStringAsync(); // LOLLO this only works with a short body...
string body = await ReadAllLogsIntoStringAsync();
using (var ms = new InMemoryRandomAccessStream())
{
using (var s4w = ms.AsStreamForWrite())
{
using (var sw = new StreamWriter(s4w, Encoding.UTF8))
{
await sw.WriteAsync(body);
await sw.FlushAsync();
// LOLLO NOTE the emails are broken with Outlook, they work with the mail app tho
// https://msdn.microsoft.com/en-us/library/windows/apps/xaml/mt269391.aspx
// the following brings up a preview with only the beginning of the body, at least with Outlook.
// it truncates the body if it is too long, like with mailto:
// emailMsg.SetBodyStream(EmailMessageBodyKind.PlainText, RandomAccessStreamReference.CreateFromStream(ms0));
// the following instead does not work at all, at least with Outlook: no attachments are attached; the email app works fine
emailMsg.Body = "I have attached the logs";
ms.Seek(0);
var att = new EmailAttachment("Logs.txt", RandomAccessStreamReference.CreateFromStream(ms)); //, "text/plain");
emailMsg.Attachments.Add(att);
//await s4w.FlushAsync();
//await ms.FlushAsync();
emailMsg.Attachments[0].EstimatedDownloadSizeInBytes = ms.Size;
await EmailManager.ShowComposeNewEmailAsync(emailMsg); //.AsTask().ConfigureAwait(false);
}
}
}
}
private async void SetAsLockScreen_Click(object sender, RoutedEventArgs e)
{
var item = flipView.SelectedItem as NatGeoImage;
// It's recommended to use both SetBitmap and SetStorageItems for sharing a single image
// since the target app may only support one or the other.
var client = new HttpClient();
var r = new HttpRequestMessage(
HttpMethod.Get, item.DownloadUrl ?? item.ImageUrl);
HttpResponseMessage response = await client.SendAsync(r,
HttpCompletionOption.ResponseHeadersRead);
var ims = new InMemoryRandomAccessStream();
var imsWriter = ims.AsStreamForWrite();
await response.Content.CopyToAsync(imsWriter);
await LockScreen.SetImageStreamAsync(ims);
ToashNotification("Lock screen set.");
}
async private Task LoadImage()
{
if (string.IsNullOrEmpty(ImageUrl) || !ImageUrl.ToLower().EndsWith(".gif"))
{
this.ProgressRing.Visibility = Visibility.Collapsed;
this.ErrorIcon.Visibility = Visibility.Visible;
return;
}
try
{
var speeds = new List<TimeSpan>();
using (var webClient = new HttpClient())
{
using (var response = await webClient.GetAsync(ImageUrl))
{
if (!response.IsSuccessStatusCode)
{
this.ProgressRing.Visibility = Visibility.Collapsed;
this.ErrorIcon.Visibility = Visibility.Visible;
return;
}
using (var imageStream = await response.Content.ReadAsStreamAsync())
{
BitmapDecoder imageDecoder;
using (var randomAccessStream = new InMemoryRandomAccessStream())
{
await imageStream.CopyToAsync(randomAccessStream.AsStreamForWrite());
imageDecoder =
await BitmapDecoder.CreateAsync(BitmapDecoder.GifDecoderId, randomAccessStream);
FrameCount = imageDecoder.FrameCount;
// Clear old bitmaps in case the control is being reused
bitmapFrames.Clear();
byte[] lastFrame = null;
var totalWidth = 0;
// Extract each frame and create a WriteableBitmap for each of these (store them in an internal list)
for (uint frameIndex = 0; frameIndex < FrameCount; frameIndex++)
{
var frame = await imageDecoder.GetFrameAsync(frameIndex);
var propertyDictionary =
await
frame.BitmapProperties.GetPropertiesAsync(
new List<string>
{
"/imgdesc/Width",
"/imgdesc/Height",
"/imgdesc/Left",
"/imgdesc/Top",
"/grctlext/Delay"
});
var test =
await
frame.BitmapProperties.GetPropertiesAsync(new List<string> { "/grctlext" });
var test2 =
await
(test["/grctlext"].Value as BitmapPropertiesView).GetPropertiesAsync(
new List<string>());
var list = test2.ToList();
speeds.Add(
TimeSpan.FromMilliseconds(
double.Parse(propertyDictionary["/grctlext/Delay"].Value.ToString()) * 10));
var top = int.Parse(propertyDictionary["/imgdesc/Top"].Value.ToString());
var left = int.Parse(propertyDictionary["/imgdesc/Left"].Value.ToString());
var width = int.Parse(propertyDictionary["/imgdesc/Width"].Value.ToString());
var height = int.Parse(propertyDictionary["/imgdesc/Height"].Value.ToString());
var writeableBitmap = new WriteableBitmap(
(int)imageDecoder.OrientedPixelWidth,
(int)imageDecoder.OrientedPixelHeight);
// Extract the pixel data and fill the WriteableBitmap with them
var bitmapTransform = new BitmapTransform();
var pixelDataProvider =
await
frame.GetPixelDataAsync(
BitmapPixelFormat.Bgra8,
imageDecoder.BitmapAlphaMode,
bitmapTransform,
ExifOrientationMode.IgnoreExifOrientation,
ColorManagementMode.DoNotColorManage);
var pixels = pixelDataProvider.DetachPixelData();
if (lastFrame != null)
{
for (var j = 0; j < height; j++)
{
for (var i = 0; i < width; i++)
{
var offset = (i + (j * width)) * 4;
if (pixels[offset + 3] == 0)
{
continue;
}
var overallOffset = (((top + j) * totalWidth) + i + left) * 4;
lastFrame[overallOffset] = pixels[offset];
lastFrame[overallOffset + 1] = pixels[offset + 1];
lastFrame[overallOffset + 2] = pixels[offset + 2];
lastFrame[overallOffset + 3] = pixels[offset + 3];
}
}
}
if (lastFrame == null)
{
lastFrame = pixels;
totalWidth = int.Parse(propertyDictionary["/imgdesc/Width"].Value.ToString());
}
using (var bitmapStream = writeableBitmap.PixelBuffer.AsStream())
{
bitmapStream.Write(lastFrame, 0, lastFrame.Length);
}
// Finally we have a frame (WriteableBitmap) that can internally be stored.
this.bitmapFrames.Add(writeableBitmap);
}
}
}
}
}
var speedToSet = speeds[0] != TimeSpan.Zero ? speeds[0] : TimeSpan.FromMilliseconds(100);
for (var i = 0; i < speeds.Count; i += 1)
{
if (speeds[i] == TimeSpan.Zero)
{
speeds[i] = speedToSet;
}
}
// Fill out the story board for the animation magic
BuildStoryBoard(speeds);
// Start the animation if needed and fire the event
if (PlayOnLoad)
{
storyboard.Begin();
if (ImageLoaded != null)
{
ImageLoaded(this, null);
}
}
}
catch (Exception ex)
{
this.ProgressRing.Visibility = Visibility.Collapsed;
this.ErrorIcon.Visibility = Visibility.Visible;
}
ProgressRing.Visibility = Visibility.Collapsed;
}
/// <summary>
/// 문자열 이미지 uri를 받아서 이미지를 로컬에 저장하고 BitmapImage로 반환한다.
/// </summary>
/// <param name="imageUri"></param>
/// <returns></returns>
public async Task<BitmapImage> UriImageSaveLocalAsync(string imageUri, bool retry = true)
{
if (string.IsNullOrEmpty(imageUri) == true) return null;
//폴더 초기화 될때까지 대기
while (files == null)
{
await TaskEx.Delay(500);
}
//Stream
var iuri = new Uri(imageUri, UriKind.Absolute);
string filename = System.IO.Path.GetFileName(iuri.LocalPath);
//메모리 내용확인
var mbi = GetImage(filename);
if (mbi != null)
{
return mbi;
}
Stream imageStream = null; //기본 스트림
//IRandomAccessStream
InMemoryRandomAccessStream ras = new InMemoryRandomAccessStream();
//create bitmap
BitmapImage bi = new BitmapImage();
//폴더에 파일 존재 확인
if (files.Any(p => p.Name == filename))
{
var localFile = files.First(p => p.Name == filename);
bi.UriSource = new Uri(Path.Combine(ApplicationData.Current.TemporaryFolder.Path, localFile.Name));
AddImage(filename, bi);
//try
//{
// imageStream = await localFile.OpenStreamForReadAsync();
//}
//catch (Exception)
//{
// //파일 열때 에러가 발생하면, 파일이 존재하지 않기 때문일 수 있는..
// UpdateFolder();
// bi.UriSource = new Uri(imageUri);
// if (imageStream != null) imageStream.Dispose();
// if (ras != null) ras.Dispose();
// return bi;
//}
//await imageStream.CopyToAsync(ras.AsStreamForWrite());
//if (ras.Size > 0)
//{
// ras.Seek(0);
// await bi.SetSourceAsync(ras);
// //메모리에 저장
// AddImage(filename, bi);
//}
//else
//{
// //파일 이상인듯
// await localFile.DeleteAsync();
// UpdateFolder();
// //재귀호출
// if (retry == false)
// {
// if (imageStream != null) imageStream.Dispose();
// if (ras != null) ras.Dispose();
// return await UriImageSaveLocalAsync(imageUri, true);
// }
// else
// {
// bi.UriSource = new Uri(imageUri);
// if (imageStream != null) imageStream.Dispose();
// if (ras != null) ras.Dispose();
// return bi;
// }
//}
}
else
{
using (HttpClient hc = new HttpClient())
{
try
{
imageStream = await hc.GetStreamAsync(imageUri);
}
catch (Exception)
{
//네트워크 상태가 끊어졌을 때
bi.UriSource = new Uri(imageUri);
if (imageStream != null) imageStream.Dispose();
if (ras != null) ras.Dispose();
return bi;
}
//Stream -> IRandomAccessStream
await imageStream.CopyToAsync(ras.AsStreamForWrite());
if (ras.Size > 0)
{
try
{
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(ras);
BitmapFrame frame = await decoder.GetFrameAsync(0);
//파일로 저장
var bitmap = new WriteableBitmap((int)frame.PixelWidth, (int)frame.PixelHeight);
ras.Seek(0);
await bitmap.SetSourceAsync(ras);
var saveImage = await bitmap.SaveToFile(ApplicationData.Current.TemporaryFolder, filename, CreationCollisionOption.OpenIfExists);
UpdateFolder();
//UriSource로 이미지 넣어주고
bi.UriSource = new Uri(Path.Combine(ApplicationData.Current.TemporaryFolder.Path, saveImage.Name));
//이미지로 변환
//ras.Seek(0);
//await bi.SetSourceAsync(ras);
//메모리에 저장
AddImage(filename, bi);
}
catch (Exception)
{
//이미지가 너무 커서 저장할 수 없을 경우 그냥 이미지 uri를 넣어서 던짐
bi.UriSource = new Uri(imageUri);
if (imageStream != null) imageStream.Dispose();
if (ras != null) ras.Dispose();
return bi;
}
}
else
{
//재귀호출
if (retry == false)
{
if (imageStream != null) imageStream.Dispose();
if (ras != null) ras.Dispose();
return await UriImageSaveLocalAsync(imageUri, true);
}
else
{
bi.UriSource = new Uri(imageUri);
if (imageStream != null) imageStream.Dispose();
if (ras != null) ras.Dispose();
return bi;
}
}
}
}
if(imageStream != null) imageStream.Dispose();
if(ras != null) ras.Dispose();
return bi;
}
private async void loadnew()
{
Assembly assembly = typeof(Clr_Pckr).GetTypeInfo().Assembly;
//Stream imgStream = assembly.GetManifestResourceStream("Color_Picker.Assets.c.png");
InMemoryRandomAccessStream res = new InMemoryRandomAccessStream();
using (var imgstream = assembly.GetManifestResourceStream("Dev.MartijnHoogendoorn.Inking.Behavior.Assets.c.png"))
{
await imgstream.CopyToAsync(res.AsStreamForWrite());
}
BitmapImage bmp = new BitmapImage();
using (IRandomAccessStream fileStream =res)// await( await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///Assets/c.png"))).OpenAsync(FileAccessMode.Read))
{
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(fileStream);
fileStream.Seek(0);
bmp.SetSource(fileStream);
ColorImg.Source = bmp;
BitmapTransform bt = new BitmapTransform();
bt.ScaledHeight = 100;
bt.ScaledWidth = 100;
PixelDataProvider pixelData = await decoder.GetPixelDataAsync(
BitmapPixelFormat.Bgra8,
BitmapAlphaMode.Straight,
bt,
ExifOrientationMode.IgnoreExifOrientation,
ColorManagementMode.DoNotColorManage);
bd = decoder;
//byte[] sourcePixels = pixelData.DetachPixelData();
tempBuffer = pixelData.DetachPixelData();
}
}
async void PlayAudio(object sender, GenericEventArgs<Stream> args)
{
await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async () =>
{
Stream str = args.EventData;
InMemoryRandomAccessStream ras = new InMemoryRandomAccessStream();
await str.CopyToAsync(ras.AsStreamForWrite());
Windows.Media.Playback.BackgroundMediaPlayer.Current.SetStreamSource(ras);
Windows.Media.Playback.BackgroundMediaPlayer.Current.MediaEnded += Current_MediaEnded;
});
}
private async void MyBooksSelectionChanged(object sender, RoutedEventArgs e)
{
var selected = flipMyBooks.SelectedItem as EbookViewModel;
if (selected == null)
{
return;
}
ProgressRingBooks.IsActive = true;
ObservableCollection<ImageSource> pdf = null;
if (gvImages.ItemsSource != null)
{
pdf = gvImages.ItemsSource as ObservableCollection<ImageSource>;
gvImages.SelectedIndex = 0;
pdf.Clear();
}
else
{
pdf = new ObservableCollection<ImageSource>();
gvImages.ItemsSource = pdf;
}
var query = new GetAllEbookPartsQuery();
await query.ExecuteAsync(OAuthSettings.AccessToken, selected.Id, selected.PartCount,
async (sourceStream) =>
{
var stream = new InMemoryRandomAccessStream();
await sourceStream.CopyToAsync(stream.AsStreamForWrite());
var doc = await PdfDocument.LoadFromStreamAsync(stream);
for (uint i = 0; i < doc.PageCount; ++i)
{
var bmpStream = new Windows.Storage.Streams.InMemoryRandomAccessStream();
await doc.GetPage(i).RenderToStreamAsync(bmpStream);
Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
var bmp = new BitmapImage();
bmp.SetSource(bmpStream);
pdf.Add(bmp);
});
}
});
ProgressRingBooks.IsActive = false;
}
