private async void DisplayRecord(string hexInput)
{
try
{
InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream();
using (DataWriter writer = new DataWriter(stream.GetOutputStreamAt(0)))
{
writer.WriteBytes(HexStringToByteArray(hexInput));
await writer.StoreAsync();
var iSC = new InkStrokeContainer();
await SampleInkCanvas.InkPresenter.StrokeContainer.LoadAsync(stream);
SampleInkCanvas.Width = SampleInkCanvas.InkPresenter.StrokeContainer.BoundingRect.Right;
SampleInkCanvas.Height = SampleInkCanvas.InkPresenter.StrokeContainer.BoundingRect.Bottom;
StrokeTextBlock.Text = "Number of Strokes: " + SampleInkCanvas.InkPresenter.StrokeContainer.GetStrokes().Count.ToString();
}
stream.Dispose();
}
catch (Exception ex)
{
ErrorDisplay.ShowErrorMessage(ex.Message);
}
}
/// <summary>
/// Convierte un array de bytes en BitmapImage.
/// El array de bytes debe ser una imagen.
/// </summary>
/// <param name="imagenEnBytes">El array de bytes que contiene los datos de una imagen.</param>
/// <returns>El Task que contendrá el BitmapImage. Si el array dado no es una imagen, devolverá null.</returns>
public async Task <BitmapImage> ArrayBytesToBitmapImage(byte[] imagenEnBytes)
{
//Crea un nuevo stream de salida de acceso aleatorio.
using (InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream())
{
//Crea un nuevo writer a partir del stream anterior.
using (DataWriter writer = new DataWriter(stream.GetOutputStreamAt(0)))
{
//Escribe el aray de bytes en el stream con el writer.
writer.WriteBytes(imagenEnBytes);
//Confirma los datos y los almacena en el stream.
await writer.StoreAsync();
}
//Crea el objeto BitmapImage que se devolverá.
var image = new BitmapImage();
//Establece la imagen a partir de la fuente de datos, que será el stream definido anteriormente y cargado con el array de bytes.
try
{
await image.SetSourceAsync(stream);
}
catch (Exception) //Puede saltar excepción cuando el array de bytes dado no se puede convertir en imagen, en tal caso, el método devolverá un null para indicar que no se realizó correctamente la conversión.
{
image = null;
}
return(image);
}
}
public static async Task <BitmapImage> ByteArrayToBitmapImageAsync(byte[] bytes)
{
bool voidArray = true;
for (int i = 0; i < bytes.Length && voidArray; i++)
{
if (bytes[i] != 0)
{
voidArray = false;
}
}
if (voidArray)
{
return(null);
}
else
{
using (InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream())
{
using (DataWriter writer = new DataWriter(stream.GetOutputStreamAt(0)))
{
writer.WriteBytes(bytes);
await writer.StoreAsync();
}
BitmapImage img = new BitmapImage();
await img.SetSourceAsync(stream);
return(img);
}
}
}
private async Task <IInputStream> GetInputStreamFromIOStream(Stream stream, long fileSize)
{
try
{
using (BinaryReader binReader = new BinaryReader(stream))
{
byte[] byteArr = binReader.ReadBytes((int)fileSize);
using (var iMS = new InMemoryRandomAccessStream())
{
var imsOutputStream = iMS.GetOutputStreamAt(0);
using (DataWriter dataWriter = new DataWriter(imsOutputStream))
{
dataWriter.WriteBytes(byteArr);
await dataWriter.StoreAsync();
await imsOutputStream.FlushAsync();
return(iMS.GetInputStreamAt(0));
}
}
}
}
catch (Exception ex)
{
PlatformAdapter.SendToCustomLogger(ex, LoggingLevel.Error);
return(null);
}
}
/// <summary>
/// Convert the given MemoryStream to a stream that allows random access
/// </summary>
/// <param name="memoryStream">The MemoryStream to convert</param>
/// <returns>Stream that allows random access</returns>
public static async Task <IRandomAccessStream> ConvertToRandomAccessStream(MemoryStream memoryStream)
{
InMemoryRandomAccessStream randomAccessStream = new InMemoryRandomAccessStream();
MemoryStream contentStream = new MemoryStream();
memoryStream.CopyTo(contentStream);
using (IOutputStream outputStream = randomAccessStream.GetOutputStreamAt(0))
{
using (DataWriter dw = new DataWriter(outputStream))
{
Task task = new Task(() => dw.WriteBytes(contentStream.ToArray()));
task.Start();
await task;
await dw.StoreAsync();
await outputStream.FlushAsync();
await dw.FlushAsync();
outputStream.Dispose();
dw.DetachStream();
dw.Dispose();
}
}
return(randomAccessStream);
}
private async void Update()
{
var writer1 = new BarcodeWriter
{
Format = BarcodeFormat.QR_CODE,
Options = new ZXing.Common.EncodingOptions
{
Height = 200,
Width = 200
},
};
var image = writer1.Write(Text);//Write(text);
using (InMemoryRandomAccessStream ms = new InMemoryRandomAccessStream())
{
using (DataWriter writer = new DataWriter(ms.GetOutputStreamAt(0)))
{
writer.WriteBytes(image);
await writer.StoreAsync();
}
var output = new BitmapImage();
await output.SetSourceAsync(ms);
ImageSource = output;
}
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
if (e.Parameter != null)
{
// Editando
Empleado_Actual = (Empleado)e.Parameter;
if (Empleado_Actual.Photo != null)
{
using (InMemoryRandomAccessStream ms = new InMemoryRandomAccessStream())
{
// Writes the image byte array in an InMemoryRandomAccessStream
// that is needed to set the source of BitmapImage.
using (DataWriter writer = new DataWriter(ms.GetOutputStreamAt(0)))
{
writer.WriteBytes((byte[])Empleado_Actual.Photo);
// The GetResults here forces to wait until the operation completes
// (i.e., it is executed synchronously), so this call can block the UI.
writer.StoreAsync().GetResults();
}
var image = new BitmapImage();
image.SetSource(ms);
Img_Empleado.Source = image;
}
// Viejo
//MemoryStream streamEnMemoria = new MemoryStream(Empleado_Actual.Photo);
//streamEnMemoria.Seek(0,SeekOrigin.Begin);
//BitmapImage imagen = new BitmapImage();
//streamEnMemoria.WriteTo(imagen);
//using (var stream = await file.OpenReadAsync())
//{
// await bitmap.SetSourceAsync(stream);
// Stream stream2 = await file.OpenStreamForReadAsync();
// stream2.CopyTo(memoryStream);
// Empleado_Actual.Photo = memoryStream.ToArray();
//}
}
else
{
// Cargamos una imagen "vacía"
Img_Empleado.Source = new BitmapImage(new Uri("ms-appx:///Assets/SplashScreen.scale-200.png"));
}
}
else
{
// Alta
Empleado_Actual = new Empleado();
}
base.OnNavigatedTo(e);
}
private async void UWPSyncTileLayer_BitmapRequested(CustomMapTileDataSource sender, MapTileBitmapRequestedEventArgs args)
{
var deferral = args.Request.GetDeferral();
try
{
var data = await _makeTileUri(args.X, args.Y, args.ZoomLevel);
if (data != null)
{
MemoryStream stream = new MemoryStream();
stream.Write(data, 0, data.Length);
stream.Position = 0;
var decoder = await Windows.Graphics.Imaging.BitmapDecoder.CreateAsync(stream.AsRandomAccessStream());
var pixelProvider = await decoder.GetPixelDataAsync(Windows.Graphics.Imaging.BitmapPixelFormat.Rgba8, Windows.Graphics.Imaging.BitmapAlphaMode.Straight, new Windows.Graphics.Imaging.BitmapTransform(), Windows.Graphics.Imaging.ExifOrientationMode.RespectExifOrientation, Windows.Graphics.Imaging.ColorManagementMode.ColorManageToSRgb);
var pixelData = pixelProvider.DetachPixelData();
InMemoryRandomAccessStream randomAccessStream = new InMemoryRandomAccessStream();
IOutputStream outputStream = randomAccessStream.GetOutputStreamAt(0);
DataWriter writer = new DataWriter(outputStream);
writer.WriteBytes(pixelData);
await writer.StoreAsync();
await writer.FlushAsync();
args.Request.PixelData = RandomAccessStreamReference.CreateFromStream(randomAccessStream);
}
deferral.Complete();
}
catch (Exception ex)
{
deferral.Complete();
}
}
/// <summary>
/// Returns a IRandomAccessStream object based on the download result.
/// If the content is downloaded into a file, returns the file stream.
/// If the contnent is downloaded into an IInputStream, convert the stream to IRandomAccessStream.
/// </summary>
public async Task <IRandomAccessStream> GetRandomAccessStreamAsync()
{
IRandomAccessStream ras = null;
if (this.File != null)
{
ras = await this.File.OpenAsync(FileAccessMode.Read);
}
else if (this.Stream != null)
{
ras = new InMemoryRandomAccessStream();
var dw = new DataWriter(ras.GetOutputStreamAt(0));
using (var dr = new DataReader(this.Stream))
{
uint bytesRead = 0;
do
{
bytesRead = await dr.LoadAsync(LiveDownloadOperationResult.BufferSize);
if (bytesRead > 0)
{
var buffer = new byte[bytesRead];
dr.ReadBytes(buffer);
dw.WriteBytes(buffer);
}
} while (bytesRead > 0);
}
await dw.StoreAsync();
}
return(ras);
}
/**
* Flushes any pending data and closes output file.
* If writing to an OutputStream, the stream is not
* closed.
*/
public async Task <InMemoryRandomAccessStream> Finish()
{
InMemoryRandomAccessStream memoryStream = null;
if (!started)
{
return(null);
}
started = false;
try
{
fs.WriteByte(0x3b); // gif trailer
fs.Flush();
byte[] bytes = (fs as MemoryStream).ToArray();
memoryStream = new InMemoryRandomAccessStream();
DataWriter datawriter = new DataWriter(memoryStream.GetOutputStreamAt(0));
datawriter.WriteBytes(bytes);
await datawriter.StoreAsync();
}
catch (IOException e)
{
return(null);
}
// reset for subsequent use
transIndex = 0;
fs = null;
pixels = null;
indexedPixels = null;
colorTab = null;
closeStream = false;
firstFrame = true;
return(memoryStream);
}
public static async Task <WriteableBitmap> GenerateQRCodeAsync(string content, MyColor darkColor, MyColor lightColor = null)
{
if (darkColor == null)
{
throw new ArgumentNullException(nameof(darkColor));
}
var payload = new PayloadGenerator.Url(content ?? string.Empty);
byte[] GetRGB(MyColor c) => new[] { c.R, c.G, c.B };
using (var generator = new QRCodeGenerator())
using (var data = generator.CreateQrCode(payload.ToString(), ECCLevel.Q))
using (var code = new BitmapByteQRCode(data))
using (var stream = new InMemoryRandomAccessStream())
using (var writer = new DataWriter(stream.GetOutputStreamAt(0)))
{
var darkRGB = GetRGB(darkColor);
var lightRGB = lightColor == null ?
new[] { Byte.MaxValue, Byte.MaxValue, Byte.MaxValue, }
: GetRGB(lightColor);
writer.WriteBytes(code.GetGraphic(20, darkRGB, lightRGB));
await writer.StoreAsync();
var bitmap = new WriteableBitmap(1024, 1024);
await bitmap.SetSourceAsync(stream);
return(bitmap);
}
}
public async Task <byte[]> Decrypt(byte[] encryptedBytes)
{
var provider = new DataProtectionProvider();
var encryptedContentBuffer = CryptographicBuffer.CreateFromByteArray(encryptedBytes);
var contentInputStream = new InMemoryRandomAccessStream();
var unprotectedContentStream = new InMemoryRandomAccessStream();
IOutputStream outputStream = contentInputStream.GetOutputStreamAt(0);
var dataWriter = new DataWriter(outputStream);
dataWriter.WriteBuffer(encryptedContentBuffer);
await dataWriter.StoreAsync();
await dataWriter.FlushAsync();
IInputStream decodingInputStream = contentInputStream.GetInputStreamAt(0);
IOutputStream protectedOutputStream = unprotectedContentStream.GetOutputStreamAt(0);
await provider.UnprotectStreamAsync(decodingInputStream, protectedOutputStream);
await protectedOutputStream.FlushAsync();
DataReader reader2 = new DataReader(unprotectedContentStream.GetInputStreamAt(0));
await reader2.LoadAsync((uint)unprotectedContentStream.Size);
IBuffer unprotectedBuffer = reader2.ReadBuffer((uint)unprotectedContentStream.Size);
return(unprotectedBuffer.ToArray());
}
public async Task SendAsync(ILogView log)
{
Copy(log);
var message = new EmailMessage
{
Body = s_resources.GetString("MessageBody"),
Subject = string.Format(s_resources.GetString("MessageSubject"), log.Id, File.ReadAllText("version.txt").Trim())
};
message.To.Add(new EmailRecipient(s_resources.GetString("MessageTo"), s_resources.GetString("MessageToName")));
using (var ms = new InMemoryRandomAccessStream())
{
using (var writer = new DataWriter(ms.GetOutputStreamAt(0)))
{
writer.WriteString(log.Log);
await writer.StoreAsync();
await writer.FlushAsync();
var data = RandomAccessStreamReference.CreateFromStream(ms);
var attachment = new EmailAttachment($"{log.Id}.log", data);
message.Attachments.Add(attachment);
await EmailManager.ShowComposeNewEmailAsync(message);
}
}
}
private async void button_Click(object sender, RoutedEventArgs e)
{
if (comboBoxECC.SelectedItem != null)
{
string level = comboBoxECC.SelectedItem.ToString();
QRCodeGenerator.ECCLevel eccLevel = (QRCodeGenerator.ECCLevel)(level == "L" ? 0 : level == "M" ? 1 : level == "Q" ? 2 : 3);
QRCodeGenerator qrGenerator = new QRCodeGenerator();
QRCodeData qrCodeData = qrGenerator.CreateQrCode("The text which should be encoded.", eccLevel);
BitmapByteQRCode qrCode = new BitmapByteQRCode(qrCodeData);
byte[] qrCodeImage = qrCode.GetGraphic(20);
using (InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream())
{
using (DataWriter writer = new DataWriter(stream.GetOutputStreamAt(0)))
{
writer.WriteBytes(qrCodeImage);
await writer.StoreAsync();
}
var image = new BitmapImage();
await image.SetSourceAsync(stream);
imageViewer.Source = image;
}
}
}
public async void LoadImages()
{
string username = readSetting("userName");
FirebaseResponse response = await client.GetTaskAsync("Image/" + username + "/");
//ObservableCollection<Image_Model> imgs = response.ResultAs<ObservableCollection<Image_Model>>();
Image_Model img = response.ResultAs <Image_Model>();
//foreach (Image_Model img in imgs)
//{
byte[] bytes = Convert.FromBase64String(img.Img);
Debug.WriteLine(bytes.Length);
BitmapImage image = new BitmapImage();
using (InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream())
{
using (DataWriter writer = new DataWriter(stream.GetOutputStreamAt(0)))
{
writer.WriteBytes(bytes);
await writer.StoreAsync();
}
await image.SetSourceAsync(stream);
}
lst.Add(new MovieData {
Title = img.Title, ImageData = image
});
//}
}
public async Task <string> UnprotectStringAsync(string protectedString)
{
var provider = this.GetDataProtectionProvider();
IBuffer buffUnprotectedData;
using (InMemoryRandomAccessStream unprotectedData = new InMemoryRandomAccessStream())
using (InMemoryRandomAccessStream inputData = new InMemoryRandomAccessStream())
{
IOutputStream outputStream = inputData.GetOutputStreamAt(0);
using (DataWriter writer = new DataWriter(outputStream))
{
writer.WriteBuffer(Convert.FromBase64String(protectedString).AsBuffer());
await writer.StoreAsync();
await outputStream.FlushAsync();
}
IInputStream source = inputData.GetInputStreamAt(0);
IOutputStream dest = unprotectedData.GetOutputStreamAt(0);
await provider.UnprotectStreamAsync(source, dest);
await dest.FlushAsync();
using (DataReader reader = new DataReader(unprotectedData.GetInputStreamAt(0)))
{
await reader.LoadAsync((uint)unprotectedData.Size);
buffUnprotectedData = reader.ReadBuffer((uint)unprotectedData.Size);
}
}
return(CryptographicBuffer.ConvertBinaryToString(Encoding, buffUnprotectedData));
}
protected async override void OnNavigatedTo(NavigationEventArgs e)
{
StorageFolder folder = await Methods.GetMyFolderAsync();
foreach (var file in await folder.GetFilesAsync())
{
try
{
var thumbnail = await file.GetThumbnailAsync(Windows.Storage.FileProperties.ThumbnailMode.PicturesView);
Stream stream = thumbnail.AsStreamForRead();
var randomAccessStream = new InMemoryRandomAccessStream();
var outputStream = randomAccessStream.GetOutputStreamAt(0);
BitmapImage bmp = new BitmapImage();
await RandomAccessStream.CopyAsync(stream.AsInputStream(), outputStream);
await bmp.SetSourceAsync(randomAccessStream);
list.Items.Add(new LocalPic
{
Thumbnail = bmp,
ID = file.DisplayName.Split('_')[1],
File = file,
});
}
catch { }
}
}
private async Task CreateQR(int index)
{
this.tb2.Text = "PDU-ID: " + index;
var url = string.Format(UrlTextBox.Text, index);
var qrGenerator = new QRCodeGenerator();
var payload = new PayloadGenerator.Url(url);
var dark = new[] { byte.MinValue, byte.MinValue, byte.MinValue };
var light = new[] { byte.MaxValue, byte.MaxValue, byte.MaxValue };
var qrCodeData = qrGenerator.CreateQrCode(payload, QRCodeGenerator.ECCLevel.Q);
var qrCode = new BitmapByteQRCode(qrCodeData);
var qrCodeImage = qrCode.GetGraphic(20, dark, light);
using (var stream = new InMemoryRandomAccessStream())
{
using (var writer = new DataWriter(stream.GetOutputStreamAt(0)))
{
writer.WriteBytes(qrCodeImage);
await writer.StoreAsync();
}
var image = new BitmapImage();
await image.SetSourceAsync(stream);
QRImage.Source = image;
}
}
public static async void ReadCustomizedCBG()
{
try
{
StorageFolder localFolder = ApplicationData.Current.LocalFolder;
StorageFile sampleFile = await localFolder.GetFileAsync("CustomizedCBG.txt");
byte[] result;
using (Stream stream = await sampleFile.OpenStreamForReadAsync())
{
using (var memoryStream = new MemoryStream())
{
stream.CopyTo(memoryStream);
result = memoryStream.ToArray();
}
}
using (InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream())
{
using (DataWriter writer = new DataWriter(stream.GetOutputStreamAt(0)))
{
writer.WriteBytes(result);
await writer.StoreAsync();
}
BitmapImage image = new BitmapImage();
image.SetSource(stream);
bitmapCBG = image;
}
}
catch (Exception)
{
}
}
public object Convert(object value, Type targetType, object parameter, string language)
{
if (value != null && value is byte[])
{
//WriteableBitmap bitmap = new WriteableBitmap(100, 100);
//System.IO.Stream bitmapStream = null;
//bitmapStream = bitmap.PixelBuffer.AsStream();
//bitmapStream.Position = 0;
//bitmapStream.Write(value as byte[], 0, (value as byte[]).Length);
//bitmapStream.Flush();
InMemoryRandomAccessStream randomAccessStream = new InMemoryRandomAccessStream();
DataWriter writer = new DataWriter(randomAccessStream.GetOutputStreamAt(0));
writer.WriteBytes(value as byte[]);
var x = writer.StoreAsync().AsTask().Result;
BitmapImage image = new BitmapImage();
image.SetSource(randomAccessStream);
return(image);
}
return(null);
}
public static async Task <IRandomAccessStream> GetImageStream(string url)
{
try
{
if (url == null || url == "")
{
return(null);
}
using (HttpClient hc = new HttpClient())
{
hc.DefaultRequestHeaders.Add("user-agent", "Mozilla/5.0 (Linux; Android 5.0; SM-N9100 Build/LRX21V) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/37.0.0.0 Mobile Safari/537.36 MicroMessenger/6.0.2.56_r958800.520 NetType/WIFI");
hc.DefaultRequestHeaders.Add("Referer", "http://www.dmzj.com/");
HttpResponseMessage hr = await hc.GetAsync(new Uri(url));
hr.EnsureSuccessStatusCode();
IBuffer info = await hr.Content.ReadAsBufferAsync();
//BitmapImage bmp = new BitmapImage();
InMemoryRandomAccessStream inStream = new InMemoryRandomAccessStream();
DataWriter datawriter = new DataWriter(inStream.GetOutputStreamAt(0));
datawriter.WriteBuffer(info, 0, info.Length);
await datawriter.StoreAsync();
//IRandomAccessStream readStream = info.
//bmp.SetSource(inStream);
return(inStream);
}
}
catch (Exception ex)
{
return(null);
}
}
public static async Task <IRandomAccessStream> ProtectPDFStream(IRandomAccessStream source)
{
// Create a DataProtectionProvider object for the specified descriptor.
DataProtectionProvider Provider = new DataProtectionProvider("LOCAL=user");
InMemoryRandomAccessStream protectedData = new InMemoryRandomAccessStream();
IOutputStream dest = protectedData.GetOutputStreamAt(0);
await Provider.ProtectStreamAsync(source.GetInputStreamAt(0), dest);
await dest.FlushAsync();
//Verify that the protected data does not match the original
//DataReader reader1 = new DataReader(source.GetInputStreamAt(0));
//DataReader reader2 = new DataReader(protectedData.GetInputStreamAt(0));
//var size1 = await reader1.LoadAsync((uint)(source.Size < 10000 ? source.Size : 10000));
//var size2 = await reader2.LoadAsync((uint)(protectedData.Size < 10000 ? protectedData.Size : 10000));
//IBuffer buffOriginalData = reader1.ReadBuffer((uint)size1);
//IBuffer buffProtectedData = reader2.ReadBuffer((uint)size2);
//if (CryptographicBuffer.Compare(buffOriginalData, buffProtectedData))
//{
// throw new Exception("ProtectPDFStream returned unprotected data");
//}
//protectedData.Seek(0);
//await protectedData.FlushAsync();
// Return the encrypted data.
return(protectedData);
}
public object Convert(object value, Type targetType, object parameter, string language)
{
if (value == null)
{
return(null);
}
var bitmapImage = new BitmapImage
{
DecodePixelHeight = 200
};
using (var stream = new InMemoryRandomAccessStream())
{
using (DataWriter writer = new DataWriter(stream.GetOutputStreamAt(0)))
{
writer.WriteBytes((byte[])value);
writer.StoreAsync().GetResults();
bitmapImage.SetSource(stream);
return(bitmapImage);
}
}
}
private async void ProtectStreamAsync_Click(object sender, RoutedEventArgs e)
{
string outputStr = "";
Byte[] byteStream = { 1, 2, 3, 4, 5 };
InMemoryRandomAccessStream randomAccessStream = new InMemoryRandomAccessStream();
IOutputStream outputStream = randomAccessStream.GetOutputStreamAt(0);
var writer = new DataWriter(outputStream);
writer.WriteBytes(byteStream);
await writer.StoreAsync();
IInputStream source = randomAccessStream.GetInputStreamAt(0);
m_protectedStream = new InMemoryRandomAccessStream();
IOutputStream destination = m_protectedStream.GetOutputStreamAt(0);
await DataProtectionManager.ProtectStreamAsync(source, Scenario1.m_enterpriseId, destination);
var reader = new DataReader(m_protectedStream.GetInputStreamAt(0));
await reader.LoadAsync((uint)m_protectedStream.Size);
IBuffer protectedStreamBuffer = reader.ReadBuffer((uint)m_protectedStream.Size);
outputStr += "\n Protected Stream buffer:" + CryptographicBuffer.EncodeToHexString(protectedStreamBuffer);
rootPage.NotifyUser(outputStr, NotifyType.StatusMessage);
}
private async Task UpdateSourceAsync()
{
_gifPresenter?.StopAnimation();
_initializationCancellationTokenSource?.Cancel();
GifImage.Source = null;
_gifPresenter = null;
if (UriSource != null)
{
var uriSource = UriSource;
var cancellationTokenSource = new CancellationTokenSource();
_initializationCancellationTokenSource = cancellationTokenSource;
try
{
var streamReference = RandomAccessStreamReference.CreateFromUri(uriSource);
var inMemoryStream = new InMemoryRandomAccessStream();
using (inMemoryStream)
{
var readStream = await streamReference.OpenReadAsync().AsTask(cancellationTokenSource.Token);
if (readStream.ContentType.ToLowerInvariant() != "image/gif")
{
throw new ArgumentException("Unsupported content type: " + readStream.ContentType);
}
var copyAction = RandomAccessStream.CopyAndCloseAsync(
readStream.GetInputStreamAt(0L),
inMemoryStream.GetOutputStreamAt(0L)
);
await copyAction.AsTask(cancellationTokenSource.Token);
if (uriSource.Equals(UriSource))
{
var gifPresenter = new GifPresenter();
GifImage.Source = await gifPresenter.InitializeAsync(inMemoryStream);
_gifPresenter = gifPresenter;
if (_isLoaded)
{
_gifPresenter.StartAnimation();
}
}
}
}
catch (TaskCanceledException)
{
// Just keep the empty image source.
}
catch (FileNotFoundException)
{
// Just keep the empty image source.
}
}
}
/// <summary>
/// Convert ICollection of VisitorPicture to image.
/// </summary>
/// <param name="value">ICollection of VisitorPicture</param>
/// <param name="targetType"></param>
/// <param name="parameter"></param>
/// <param name="language"> </param>
/// <returns></returns>
public object Convert(object value, Type targetType, object parameter, string language)
{
if (value == null)
{
return(NOIMAGE_PATH);
}
using (var ms = new InMemoryRandomAccessStream())
{
var val = (ICollection <VisitorPicture>)value;
if (val.Any())
{
byte[] bImage = val.First().Content;
using (var writer = new DataWriter(ms.GetOutputStreamAt(0)))
{
writer.WriteBytes(bImage);
writer.StoreAsync().GetResults();
}
var image = new BitmapImage();
image.SetSource(ms);
return(image);
}
return(NOIMAGE_PATH);
}
}
public async void AddImage()
{
FileOpenPicker picker = new FileOpenPicker();
picker.FileTypeFilter.Add(".bmp");
picker.FileTypeFilter.Add(".png");
picker.FileTypeFilter.Add(".jpg");
StorageFile file = await picker.PickSingleFileAsync();
using (var inputStream = await file.OpenSequentialReadAsync())
{
var readStream = inputStream.AsStreamForRead();
buffer = new byte[readStream.Length];
await readStream.ReadAsync(buffer, 0, buffer.Length);
}
using (InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream())
{
using (DataWriter writer = new DataWriter(stream.GetOutputStreamAt(0)))
{
writer.WriteBytes(buffer);
await writer.StoreAsync();
}
Image = buffer;
}
}
public async static Task <BitmapSource> Base64StringToBitmap(string data)
{
if (string.IsNullOrEmpty(data))
{
return(null);
}
byte[] imageBytes = Convert.FromBase64String(data);
ims = new InMemoryRandomAccessStream();
DataWriter dataWriter = new DataWriter(ims.GetOutputStreamAt(0));
dataWriter.WriteBytes(imageBytes);
await dataWriter.StoreAsync();
ims.Seek(0);
imgs = new BitmapImage();
await imgs.SetSourceAsync(ims);
bmp = new WriteableBitmap(imgs.PixelHeight, imgs.PixelWidth);
bmp.Invalidate();
ims.Seek(0);
bmp.SetSource(ims);
return(bmp);
}
private async void Button_Click(object sender, RoutedEventArgs e)
{
var contact = _message.Content as MessageContact;
if (contact == null)
{
return;
}
try
{
var stream = new InMemoryRandomAccessStream();
var writer = new DataWriter(stream.GetOutputStreamAt(0));
var reference = RandomAccessStreamReference.CreateFromStream(stream);
writer.WriteString(contact.Contact.Vcard);
await writer.StoreAsync();
var system = await Windows.ApplicationModel.Contacts.ContactManager.ConvertVCardToContactAsync(reference);
var transform = this.TransformToVisual(Window.Current.Content as UIElement);
var point = transform.TransformPoint(new Point());
Windows.ApplicationModel.Contacts.ContactManager.ShowContactCard(system, new Rect(point.X, point.Y, ActualWidth, ActualHeight));
}
catch { }
}
private async Task DisplayDecryptedResultForData(object oResult)
{
if (oResult.GetType() == typeof(Tuple <bool, byte[]>))
{
Tuple <bool, byte[]> res = oResult as Tuple <bool, byte[]>;
bool isValid = res.Item1;
byte[] bData = res.Item2;
if (isValid)
{
if (bData != null)
{
using (InMemoryRandomAccessStream ms = new InMemoryRandomAccessStream())
{
ms.Seek(0);
using (DataWriter writer = new DataWriter(ms.GetOutputStreamAt(0)))
{
writer.WriteBytes((byte[])bData);
writer.StoreAsync().GetResults();
}
var image = new BitmapImage();
image.SetSource(ms);
imgNew.Source = image;
}
}
}
else
{
await new MessageDialog("Unable to decrypt.").ShowAsync();
}
}
}
