| public GetInputStreamAt ( [ position ) : IInputStream | ||
| position | [ | |
| return | IInputStream | |
public IInputStream GetInputStreamAt(ulong position)
{
System.Diagnostics.Debug.WriteLine("GetInputStreamAt: " + position.ToString());
if (internalStream.Size > position)
{
return(internalStream.GetInputStreamAt(position));
}
return(null);
}
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;
}
private static async Task<IInputStream> GetStreamForByteArray(string content2)
{
var ras = new InMemoryRandomAccessStream();
var datawriter = new DataWriter(ras);
datawriter.WriteString(content2);
//datawriter.WriteBytes(content2);
await datawriter.StoreAsync();
await datawriter.FlushAsync();
return ras.GetInputStreamAt(0);
}
public async Task<string> Decrypt(IBuffer buffProtected, BinaryStringEncoding encoding)
{
try
{
// Create a DataProtectionProvider object.
DataProtectionProvider Provider = new DataProtectionProvider();
// Create a random access stream to contain the encrypted message.
InMemoryRandomAccessStream inputData = new InMemoryRandomAccessStream();
// Create a random access stream to contain the decrypted data.
InMemoryRandomAccessStream unprotectedData = new InMemoryRandomAccessStream();
// Retrieve an IOutputStream object and fill it with the input (encrypted) data.
IOutputStream outputStream = inputData.GetOutputStreamAt(0);
DataWriter writer = new DataWriter(outputStream);
writer.WriteBuffer(buffProtected);
await writer.StoreAsync();
await outputStream.FlushAsync();
// Retrieve an IInputStream object from which you can read the input (encrypted) data.
IInputStream source = inputData.GetInputStreamAt(0);
// Retrieve an IOutputStream object and fill it with decrypted data.
IOutputStream dest = unprotectedData.GetOutputStreamAt(0);
await Provider.UnprotectStreamAsync(source, dest);
await dest.FlushAsync();
// Write the decrypted data to an IBuffer object.
DataReader reader2 = new DataReader(unprotectedData.GetInputStreamAt(0));
await reader2.LoadAsync((uint)unprotectedData.Size);
IBuffer buffUnprotectedData = reader2.ReadBuffer((uint)unprotectedData.Size);
// Convert the IBuffer object to a string using the same encoding that was
// used previously to conver the plaintext string (before encryption) to an
// IBuffer object.
String strUnprotected = CryptographicBuffer.ConvertBinaryToString(encoding, buffUnprotectedData);
// Return the decrypted data.
return strUnprotected;
}
catch (Exception ex)
{
App.Telemetry.TrackException(ex);
return "";
}
}
public async Task<IBuffer> Encrypt(string descriptor, string strMsg, BinaryStringEncoding encoding)
{
// Create a DataProtectionProvider object for the specified descriptor.
DataProtectionProvider Provider = new DataProtectionProvider(descriptor);
// Convert the input string to a buffer.
IBuffer buffMsg = CryptographicBuffer.ConvertStringToBinary(strMsg, encoding);
// Create a random access stream to contain the plaintext message.
InMemoryRandomAccessStream inputData = new InMemoryRandomAccessStream();
// Create a random access stream to contain the encrypted message.
InMemoryRandomAccessStream protectedData = new InMemoryRandomAccessStream();
// Retrieve an IOutputStream object and fill it with the input (plaintext) data.
IOutputStream outputStream = inputData.GetOutputStreamAt(0);
DataWriter writer = new DataWriter(outputStream);
writer.WriteBuffer(buffMsg);
await writer.StoreAsync();
await outputStream.FlushAsync();
// Retrieve an IInputStream object from which you can read the input data.
IInputStream source = inputData.GetInputStreamAt(0);
// Retrieve an IOutputStream object and fill it with encrypted data.
IOutputStream dest = protectedData.GetOutputStreamAt(0);
await Provider.ProtectStreamAsync(source, dest);
await dest.FlushAsync();
//Verify that the protected data does not match the original
DataReader reader1 = new DataReader(inputData.GetInputStreamAt(0));
DataReader reader2 = new DataReader(protectedData.GetInputStreamAt(0));
await reader1.LoadAsync((uint)inputData.Size);
await reader2.LoadAsync((uint)protectedData.Size);
IBuffer buffOriginalData = reader1.ReadBuffer((uint)inputData.Size);
IBuffer buffProtectedData = reader2.ReadBuffer((uint)protectedData.Size);
if (CryptographicBuffer.Compare(buffOriginalData, buffProtectedData))
{
throw new Exception("ProtectStreamAsync returned unprotected data");
}
// Return the encrypted data.
return buffProtectedData;
}
private static async Task<bool> DownloadArtistPictureFromDeezer(MusicLibraryViewModel.ArtistItem artist)
{
var deezerClient = new DeezerClient();
var deezerArtist = await deezerClient.GetArtistInfo(artist.Name);
if (deezerArtist == null) return false;
if (deezerArtist.Images == null) return false;
try
{
var clientPic = new HttpClient();
HttpResponseMessage responsePic = await clientPic.GetAsync(deezerArtist.Images.LastOrDefault().Url);
string uri = responsePic.RequestMessage.RequestUri.AbsoluteUri;
// A cheap hack to avoid using Deezers default image for bands.
if (uri.Equals("http://cdn-images.deezer.com/images/artist//400x400-000000-80-0-0.jpg"))
{
return false;
}
byte[] img = await responsePic.Content.ReadAsByteArrayAsync();
InMemoryRandomAccessStream streamWeb = new InMemoryRandomAccessStream();
DataWriter writer = new DataWriter(streamWeb.GetOutputStreamAt(0));
writer.WriteBytes(img);
await writer.StoreAsync();
StorageFolder artistPic = await ApplicationData.Current.LocalFolder.CreateFolderAsync("artistPic",
CreationCollisionOption.OpenIfExists);
string fileName = artist.Name + "_" + "dPi";
var file = await artistPic.CreateFileAsync(fileName + ".jpg", CreationCollisionOption.OpenIfExists);
var raStream = await file.OpenAsync(FileAccessMode.ReadWrite);
using (var thumbnailStream = streamWeb.GetInputStreamAt(0))
{
using (var stream = raStream.GetOutputStreamAt(0))
{
await RandomAccessStream.CopyAsync(thumbnailStream, stream);
}
}
StorageFolder appDataFolder = ApplicationData.Current.LocalFolder;
string supposedPictureUriLocal = appDataFolder.Path + "\\artistPic\\" + artist.Name + "_" + "dPi" + ".jpg";
await DispatchHelper.InvokeAsync(() => artist.Picture = supposedPictureUriLocal);
return true;
}
catch (Exception)
{
Debug.WriteLine("Error getting or saving art from deezer.");
return false;
}
}
public byte[] DrawStrokeOnSolidColorBackground(IReadOnlyList<InkStroke> strokes, int width, int height, Color color )
{
CanvasDevice device = CanvasDevice.GetSharedDevice();
CanvasRenderTarget renderTarget = new CanvasRenderTarget(device, width, height, 96);
using (var ds = renderTarget.CreateDrawingSession())
{
ds.Clear(color);
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<bool> downloadImage(string url, string filename)
{
Uri uri = new Uri(url);
//string fname = member_id + ".png";
var bitmapImage = new BitmapImage();
var httpClient = new HttpClient();
var httpResponse = await httpClient.GetAsync(uri);
byte[] b = await httpResponse.Content.ReadAsByteArrayAsync();
try
{
// create a new in memory stream and datawriter
using (var stream = new InMemoryRandomAccessStream())
{
using (DataWriter dw = new DataWriter(stream))
{
// write the raw bytes and store
dw.WriteBytes(b);
await dw.StoreAsync();
// set the image source
stream.Seek(0);
bitmapImage.SetSource(stream);
var storageFile = await ApplicationData.Current.LocalFolder.CreateFileAsync(
filename,
CreationCollisionOption.OpenIfExists);
using (var storageStream = await storageFile.OpenAsync(FileAccessMode.ReadWrite))
{
await RandomAccessStream.CopyAndCloseAsync(stream.GetInputStreamAt(0), storageStream.GetOutputStreamAt(0));
}
}
}
}
catch (Exception ex)
{
Debug.WriteLine("Exception in downloading image : " + ex);
return false;
}
return true;
}
public static async Task<byte[]> CropImage(byte[] stream, Crop crop)
{
byte[] byteArray = null;
var imageStream = new MemoryStream(stream);
var fileStream = imageStream.AsRandomAccessStream();
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(fileStream);
InMemoryRandomAccessStream ras = new InMemoryRandomAccessStream();
BitmapEncoder enc = await BitmapEncoder.CreateForTranscodingAsync(ras, decoder);
BitmapBounds bounds = new BitmapBounds();
bounds.Height = (uint)crop.Height;
bounds.Width = (uint)crop.Width;
bounds.X = (uint)crop.X;
bounds.Y = (uint)crop.Y;
enc.BitmapTransform.Bounds = bounds;
enc.BitmapTransform.InterpolationMode = BitmapInterpolationMode.Linear;
enc.IsThumbnailGenerated = false;
try
{
await enc.FlushAsync();
}
catch (Exception ex)
{
Debug.WriteLine("Error croping image", ex);
}
byteArray = new byte[ras.Size];
DataReader dataReader = new DataReader(ras.GetInputStreamAt(0));
await dataReader.LoadAsync((uint)ras.Size);
dataReader.ReadBytes(byteArray);
return byteArray;
}
private async void UnprotectAsyncBuffer_Click(object sender, RoutedEventArgs e)
{
string outputStr = "";
if (m_protectedStream != null)
{
IInputStream source = m_protectedStream.GetInputStreamAt(0);
m_unprotectedStream = new InMemoryRandomAccessStream();
await DataProtectionManager.UnprotectStreamAsync(source,
m_unprotectedStream
);
var unprotectedReader = new DataReader(m_unprotectedStream.GetInputStreamAt(0));
await unprotectedReader.LoadAsync((uint)m_unprotectedStream.Size);
IBuffer unprotectedStreamBuffer = unprotectedReader.ReadBuffer((uint)m_unprotectedStream.Size);
outputStr += "\n UnProtected Stream buffer:" +
CryptographicBuffer.EncodeToHexString(unprotectedStreamBuffer);
rootPage.NotifyUser(outputStr, NotifyType.StatusMessage);
}
else
{
rootPage.NotifyUser("Please protect a stream to unprotect", NotifyType.ErrorMessage);
}
}
/// <summary>
/// This is the click handler for the 'RunSample' button. It is responsible for executing the sample code.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void RunSample_Click(object sender, RoutedEventArgs e)
{
Certificate selectedCertificate = null;
string verifyselection = VerifyCert.SelectionBoxItem.ToString();
//get the selected certificate
if (CertificateList.SelectedIndex >= 0 && CertificateList.SelectedIndex < certList.Count)
{
selectedCertificate = certList[CertificateList.SelectedIndex];
}
if (selectedCertificate == null)
{
ViewCertText.Text = "Please select a certificate first.";
return;
}
// a certificate was selected, do the desired operation
if (verifyselection.Equals("Verify Certificate"))
{
//Build the chain
var chain = await selectedCertificate.BuildChainAsync(null, null);
//Validate the chain
var result = chain.Validate();
verifytext = "\n Verification Result :" + result.ToString();
}
else if (verifyselection.Equals("Sign/Verify using certificate key"))
{
// get private key
CryptographicKey keyPair = await PersistedKeyProvider.OpenKeyPairFromCertificateAsync(selectedCertificate, HashAlgorithmNames.Sha1, CryptographicPadding.RsaPkcs1V15);
String cookie = "Some Data to sign";
IBuffer Data = CryptographicBuffer.ConvertStringToBinary(cookie, BinaryStringEncoding.Utf16BE);
try
{
//sign the data by using the key
IBuffer Signed = CryptographicEngine.Sign(keyPair, Data);
bool bresult = CryptographicEngine.VerifySignature(keyPair, Data, Signed);
if (bresult == true)
{
verifytext = "\n Verification Result : Successfully signed and verified signature";
}
else
{
verifytext = "\n Verification Result : Verify Signature Failed";
}
}
catch (Exception exp)
{
verifytext = "\n Verification Failed. Exception Occurred :" + exp.Message;
}
}
else if (verifyselection.Equals("Sign/Verify using CMS based format"))
{
IInputStream pdfInputstream;
InMemoryRandomAccessStream originalData = new InMemoryRandomAccessStream();
//Populate the new memory stream
pdfInputstream = originalData.GetInputStreamAt(0);
CmsSignerInfo signer = new CmsSignerInfo();
signer.Certificate = selectedCertificate;
signer.HashAlgorithmName = HashAlgorithmNames.Sha1;
IList<CmsSignerInfo> signers = new List<CmsSignerInfo>();
signers.Add(signer);
try
{
IBuffer signature = await CmsDetachedSignature.GenerateSignatureAsync(pdfInputstream, signers, null);
CmsDetachedSignature cmsSignedData = new CmsDetachedSignature(signature);
pdfInputstream = originalData.GetInputStreamAt(0);
SignatureValidationResult validationResult = await cmsSignedData.VerifySignatureAsync(pdfInputstream);
if (SignatureValidationResult.Success == validationResult)
{
verifytext = "\n Verification Result : Successfully signed and verified Signature";
}
else
{
verifytext = "\n Verification Result : Verify Signature using CMS based format Failed";
}
}
catch (Exception exp)
{
verifytext = "\n Verification Failed. Exception Occurred :" + exp.Message;
}
}
else if(verifyselection.Equals("Get certificate and show details"))
{
DisplayCertificate(selectedCertificate);
}
ViewCertText.Text += verifytext;
verifytext = string.Empty;
}
public async Task UsingDataWriter()
{
var inMem = new InMemoryRandomAccessStream();
var datawriter = new DataWriter(inMem);
var starterBytes = CryptographicBuffer.GenerateRandom(32).AsBytes();
var mStream = CryptographicBuffer.GenerateRandom(1024 * 1024).AsBytes();
MemoryStream outStream = new System.IO.MemoryStream();
var tinyStream = ConfigureStream(outStream, PwCompressionAlgorithm.GZip, true);
await tinyStream.WriteAsync(starterBytes, 0, starterBytes.Length);
await tinyStream.WriteAsync(mStream, 0, mStream.Length);
tinyStream.Dispose();
byte[] bb = outStream.ToArray();
var source = bb.AsBuffer();
var aesKey = CryptographicBuffer.GenerateRandom(32);
var iv = CryptographicBuffer.GenerateRandom(16);
var encrypted = EncryptDatabase(source, aesKey, iv);
CollectionAssert.AreNotEqual(mStream, encrypted.AsBytes());
datawriter.WriteBuffer(encrypted);
await datawriter.StoreAsync();
datawriter.DetachStream();
datawriter.Dispose();
var i = inMem.GetInputStreamAt(0);
var datareader = new DataReader(i);
datareader.ByteOrder = ByteOrder.LittleEndian;
await datareader.LoadAsync((uint)inMem.Size);
var fromStrea = datareader.ReadBuffer(datareader.UnconsumedBufferLength);
var decryped = DecryptDatabase(fromStrea, aesKey, iv);
Stream bigStream = ConfigureStream(new MemoryStream(decryped.AsBytes()), PwCompressionAlgorithm.GZip, false);
System.IO.MemoryStream bigStreamOut = new System.IO.MemoryStream();
bigStream.CopyTo(bigStreamOut);
var buffer1 = CryptographicBuffer.CreateFromByteArray(bigStreamOut.ToArray());
var reader = DataReader.FromBuffer(buffer1);
var x = reader.ReadBuffer(32).AsBytes();
CollectionAssert.AreEqual(starterBytes, x);
}
private static async Task<ReceivedShareItem> FetchDataFromPackageViewAsync(DataPackageView packageView)
{
var rval = new ReceivedShareItem()
{
Title = packageView.Properties.Title,
Description = packageView.Properties.Description,
PackageFamilyName = packageView.Properties.PackageFamilyName,
ContentSourceWebLink = packageView.Properties.ContentSourceWebLink,
ContentSourceApplicationLink = packageView.Properties.ContentSourceApplicationLink,
LogoBackgroundColor = packageView.Properties.LogoBackgroundColor,
};
if (packageView.Properties.Square30x30Logo != null)
{
using (var logoStream = await packageView.Properties.Square30x30Logo.OpenReadAsync())
{
var logo = new MemoryStream();
await logoStream.AsStreamForRead().CopyToAsync(logo);
logo.Position = 0;
var str = Convert.ToBase64String(logo.ToArray());
//rval.Square30x30LogoBase64 = Convert.ToBase64String(logo.ToArray());
rval.Square30x30Logo = new Models.MemoryStreamBase64Item { Base64String = str };
}
}
if (packageView.Properties.Thumbnail != null)
{
using (var thumbnailStream = await packageView.Properties.Thumbnail.OpenReadAsync())
{
var thumbnail = new MemoryStream();
await thumbnailStream.AsStreamForRead().CopyToAsync(thumbnail);
thumbnail.Position = 0;
var str = Convert.ToBase64String(thumbnail.ToArray());
rval.Thumbnail = new Models.MemoryStreamBase64Item { Base64String = str };
}
}
if (packageView.Contains(StandardDataFormats.WebLink))
{
try
{
var link = new WebLinkShareItem
{
WebLink = await packageView.GetWebLinkAsync()
};
rval.AvialableShareItems.Add(link);
}
catch (Exception ex)
{
//NotifyUserBackgroundThread("Failed GetWebLinkAsync - " + ex.Message, NotifyType.ErrorMessage);
}
}
if (packageView.Contains(StandardDataFormats.ApplicationLink))
{
try
{
var sharedApplicationLink = new ApplicationLinkShareItem
{
ApplicationLink = await packageView.GetApplicationLinkAsync()
};
rval.AvialableShareItems.Add(sharedApplicationLink);
}
catch (Exception ex)
{
//NotifyUserBackgroundThread("Failed GetApplicationLinkAsync - " + ex.Message, NotifyType.ErrorMessage);
}
}
if (packageView.Contains(StandardDataFormats.Text))
{
try
{
var sharedText = new TextShareItem { Text = await packageView.GetTextAsync() };
rval.AvialableShareItems.Add(sharedText);
rval.Text = await packageView.GetTextAsync();
//rval.GetValueContainer(x => x.Text)
// .GetNullObservable()
// .Subscribe(e => sharedText.Text = rval.Text)
// .DisposeWith(rval);
sharedText.GetValueContainer(x => x.Text)
.GetNullObservable()
.Subscribe(e => rval.Text = sharedText.Text)
.DisposeWith(rval);
}
catch (Exception ex)
{
//NotifyUserBackgroundThread("Failed GetTextAsync - " + ex.Message, NotifyType.ErrorMessage);
}
}
if (packageView.Contains(StandardDataFormats.StorageItems))
{
try
{
var files = await packageView.GetStorageItemsAsync();
var sharedStorageItem = new FilesShareItem
{
StorageFiles = new ObservableCollection<FileItem>()
//StorageItems =
};
foreach (StorageFile sf in files)
{
var guidString = Guid.NewGuid().ToString();
StorageApplicationPermissions.FutureAccessList.AddOrReplace(guidString, sf, sf.Name);
var ts = await sf.GetScaledImageAsThumbnailAsync(Windows.Storage.FileProperties.ThumbnailMode.VideosView);
var tmbs = new MemoryStream();
await ts.AsStreamForRead().CopyToAsync(tmbs);
var file = new FileItem
{
AccessToken = guidString,
ContentType = sf.ContentType,
FileName = sf.DisplayName,
PossiblePath = sf.Path,
Thumbnail = new Models.MemoryStreamBase64Item(tmbs.ToArray())
};
sharedStorageItem.StorageFiles.Add(file);
}
//StorageApplicationPermissions.FutureAccessList.AddOrReplace()
rval.AvialableShareItems.Add(sharedStorageItem);
}
catch (Exception ex)
{
//NotifyUserBackgroundThread("Failed GetStorageItemsAsync - " + ex.Message, NotifyType.ErrorMessage);
}
}
//if (packageView.Contains(dataFormatName))
//{
// try
// {
// this.sharedCustomData = await packageView.GetTextAsync(dataFormatName);
// }
// catch (Exception ex)
// {
// //NotifyUserBackgroundThread("Failed GetTextAsync(" + dataFormatName + ") - " + ex.Message, NotifyType.ErrorMessage);
// }
//}
if (packageView.Contains(StandardDataFormats.Html))
{
var sharedHtmlFormatItem = new HtmlShareItem();
var sharedHtmlFormat = string.Empty;
try
{
sharedHtmlFormat = await packageView.GetHtmlFormatAsync();
//sharedHtmlFormatItem.HtmlFormat = sharedHtmlFormat;
sharedHtmlFormatItem.HtmlFragment = HtmlFormatHelper.GetStaticFragment(sharedHtmlFormat);
}
catch (Exception ex)
{
//NotifyUserBackgroundThread("Failed GetHtmlFormatAsync - " + ex.Message, NotifyType.ErrorMessage);
}
//try
//{
// var sharedResourceMap = await packageView.GetResourceMapAsync();
//}
//catch (Exception ex)
//{
// //NotifyUserBackgroundThread("Failed GetResourceMapAsync - " + ex.Message, NotifyType.ErrorMessage);
//}
//if (packageView.Contains(StandardDataFormats.WebLink))
//{
// try
// {
// sharedHtmlFormatItem.WebLink = await packageView.GetWebLinkAsync();
// }
// catch (Exception ex)
// {
// //NotifyUserBackgroundThread("Failed GetWebLinkAsync - " + ex.Message, NotifyType.ErrorMessage);
// }
//}
rval.AvialableShareItems.Add(sharedHtmlFormatItem);
}
if (packageView.Contains(StandardDataFormats.Bitmap))
{
try
{
var fi = await packageView.GetBitmapAsync();
using (var imgFileStream = await fi.OpenReadAsync())
{
var saveTargetStream = new InMemoryRandomAccessStream();
var bitmapSourceStream = imgFileStream;
await ServiceLocator
.Instance
.Resolve<IImageConvertService>()
.ConverterBitmapToTargetStreamAsync(bitmapSourceStream, saveTargetStream);
saveTargetStream.Seek(0);
var sr = saveTargetStream.GetInputStreamAt(0);
var source = sr.AsStreamForRead();
var ms = new MemoryStream();
await source.CopyToAsync(ms);
var sharedBitmapStreamRef = new DelayRenderedImageShareItem
{
SelectedImage = new Models.MemoryStreamBase64Item(ms.ToArray())
};
rval.AvialableShareItems.Add(sharedBitmapStreamRef);
}
}
catch (Exception ex)
{
//NotifyUserBackgroundThread("Failed GetBitmapAsync - " + ex.Message, NotifyType.ErrorMessage);
}
}
//foreach (var item in rval.AvialableShareItems)
//{
// //item.ContentSourceApplicationLink = rval.ContentSourceApplicationLink;
// //item.ContentSourceWebLink = rval.ContentSourceWebLink;
// //item.DefaultFailedDisplayText = rval.DefaultFailedDisplayText;
// //item.Description = rval.Description;
// //item.Title = rval.Title;
//}
return rval;
}
async void CaptureImage_Click(object sender, RoutedEventArgs e)
{
// hide capture button
this.cameraButton.Visibility = Visibility.Collapsed;
// show progress bar
this.processing.IsActive = true;
//mediaCapture.SetRecordRotation(VideoRotation.None);
ImageEncodingProperties imgFormat = ImageEncodingProperties.CreateJpeg();
// find the time and date now
DateTime dt = System.DateTime.Now;
String date = dt.ToString("dd_MM_yyyy_H_mm_ss");
// create storage file in local app storage, and name file according to date
StorageFile file = await ApplicationData.Current.LocalFolder.CreateFileAsync(
"RiverWatchImage_"+date+".jpg",
CreationCollisionOption.ReplaceExisting);
// take photo
await mediaCapture.CapturePhotoToStorageFileAsync(imgFormat, file);
// Get photo as a BitmapImage
Uri imageURI = new Uri(file.Path);
//rotate image back to correct orientation if required
if (currentAngle != 90) {
IRandomAccessStream originalImage = await file.OpenAsync(FileAccessMode.ReadWrite);
BitmapDecoder imageDecoder = await BitmapDecoder.CreateAsync(originalImage);
var imageStream = new InMemoryRandomAccessStream();
BitmapEncoder imageEncoder = await BitmapEncoder.CreateForTranscodingAsync(imageStream, imageDecoder);
//set rotation angle
switch (currentAngle) {
case 0:
imageEncoder.BitmapTransform.Rotation = BitmapRotation.Clockwise90Degrees;
break;
case 180:
imageEncoder.BitmapTransform.Rotation = BitmapRotation.Clockwise270Degrees;
break;
case 270:
imageEncoder.BitmapTransform.Rotation = BitmapRotation.Clockwise180Degrees;
break;
}
await imageEncoder.FlushAsync();
BitmapImage bitmapImage = new BitmapImage();
await bitmapImage.SetSourceAsync(imageStream);
using (var outputStream = originalImage.GetOutputStreamAt(0)) {
using (var inputStream = imageStream.GetInputStreamAt(0)) {
IBuffer storageFileBuffer = new byte[imageStream.Size].AsBuffer();
await inputStream.ReadAsync(storageFileBuffer, storageFileBuffer.Length, InputStreamOptions.None);
await outputStream.WriteAsync(storageFileBuffer);
}
}
}
// once finished, hide progress bar
this.processing.IsActive = false;
Frame.Navigate(typeof(PollutionReportPage),file);
}
private async Task<bool> SaveImage(int id, String folderName, byte[] img)
{
String fileName = String.Format("{0}.jpg", id);
try
{
using (var streamWeb = new InMemoryRandomAccessStream())
{
using (var writer = new DataWriter(streamWeb.GetOutputStreamAt(0)))
{
writer.WriteBytes(img);
await writer.StoreAsync();
var albumPic = await ApplicationData.Current.LocalFolder.CreateFolderAsync(folderName, CreationCollisionOption.OpenIfExists);
var file = await albumPic.CreateFileAsync(fileName, CreationCollisionOption.OpenIfExists);
Debug.WriteLine("Writing file " + folderName + " " + id);
using (var raStream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
using (var thumbnailStream = streamWeb.GetInputStreamAt(0))
{
using (var stream = raStream.GetOutputStreamAt(0))
{
await RandomAccessStream.CopyAsync(thumbnailStream, stream);
await stream.FlushAsync();
}
}
await raStream.FlushAsync();
}
await writer.FlushAsync();
}
await streamWeb.FlushAsync();
}
return true;
}
catch (Exception e)
{
Debug.WriteLine("Error saving album art: " + e);
return false;
}
}
public IAsyncOperationWithProgress<IInputStream, ulong> ReadAsInputStreamAsync()
{
return AsyncInfo.Run<IInputStream, ulong>(async (cancellationToken, progress) =>
{
InMemoryRandomAccessStream randomAccessStream = new InMemoryRandomAccessStream();
DataWriter writer = new DataWriter(randomAccessStream);
writer.WriteString(jsonValue.Stringify());
uint bytesStored = await writer.StoreAsync().AsTask(cancellationToken);
// Make sure that the DataWriter destructor does not close the stream.
writer.DetachStream();
// Report progress.
progress.Report(randomAccessStream.Size);
return randomAccessStream.GetInputStreamAt(0);
});
}
private async void BtnDownloadImage_OnClick(object sender, RoutedEventArgs e)
{
var ms = new InMemoryRandomAccessStream();
await _thisWebView.CapturePreviewToStreamAsync(ms);
// Launch file picker
var picker = new FileSavePicker();
picker.SuggestedStartLocation = PickerLocationId.PicturesLibrary;
picker.FileTypeChoices.Add("JPeg", new List<string> {".jpg", ".jpeg"});
StorageFile file = await picker.PickSaveFileAsync();
if (file == null)
return;
using (IRandomAccessStream fileStream1 = await file.OpenAsync(FileAccessMode.ReadWrite))
{
await RandomAccessStream.CopyAndCloseAsync(ms.GetInputStreamAt(0), fileStream1.GetOutputStreamAt(0));
DisplayTextToast("Файлът е записан успешно.");
}
}
private async Task <string> ExecuteCommandLineString(string CommandString)
{
const string CommandLineProcesserExe = "c:\\windows\\system32\\cmd.exe";
const uint CommandStringResponseBufferSize = 8192;
string currentDirectory = "C:\\";
StringBuilder textOutput = new StringBuilder((int)CommandStringResponseBufferSize);
uint bytesLoaded = 0;
if (string.IsNullOrWhiteSpace(CommandString))
{
return("");
}
var commandLineText = CommandString.Trim();
var standardOutput = new Windows.Storage.Streams.InMemoryRandomAccessStream();
var standardError = new Windows.Storage.Streams.InMemoryRandomAccessStream();
var options = new Windows.System.ProcessLauncherOptions {
StandardOutput = standardOutput,
StandardError = standardError
};
try {
var args = "/C \"cd \"" + currentDirectory + "\" & " + commandLineText + "\"";
var result = await Windows.System.ProcessLauncher.RunToCompletionAsync(CommandLineProcesserExe, args, options);
//First write std out
using (var outStreamRedirect = standardOutput.GetInputStreamAt(0)) {
using (var dataReader = new Windows.Storage.Streams.DataReader(outStreamRedirect)) {
while ((bytesLoaded = await dataReader.LoadAsync(CommandStringResponseBufferSize)) > 0)
{
textOutput.Append(dataReader.ReadString(bytesLoaded));
}
new System.Threading.ManualResetEvent(false).WaitOne(10);
if ((bytesLoaded = await dataReader.LoadAsync(CommandStringResponseBufferSize)) > 0)
{
textOutput.Append(dataReader.ReadString(bytesLoaded));
}
}
}
//Then write std err
using (var errStreamRedirect = standardError.GetInputStreamAt(0)) {
using (var dataReader = new Windows.Storage.Streams.DataReader(errStreamRedirect)) {
while ((bytesLoaded = await dataReader.LoadAsync(CommandStringResponseBufferSize)) > 0)
{
textOutput.Append(dataReader.ReadString(bytesLoaded));
}
new System.Threading.ManualResetEvent(false).WaitOne(10);
if ((bytesLoaded = await dataReader.LoadAsync(CommandStringResponseBufferSize)) > 0)
{
textOutput.Append(dataReader.ReadString(bytesLoaded));
}
}
}
return(textOutput.ToString());
} catch (UnauthorizedAccessException uex) {
return("ERROR - " + uex.Message + "\n\nCmdNotEnabled");
} catch (Exception ex) {
return("ERROR - " + ex.Message + "\n");
}
}
async void cropImage(IRandomAccessStream inputStream, uint bw, uint bh, uint w, uint h, string fname, StorageFolder folder)
{
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(inputStream);
InMemoryRandomAccessStream ras = new InMemoryRandomAccessStream();
BitmapEncoder enc = await BitmapEncoder.CreateForTranscodingAsync(ras, decoder);
BitmapBounds bounds = new BitmapBounds();
bounds.Height = h;
bounds.Width = w;
bounds.X = bw;
bounds.Y = bh;
enc.BitmapTransform.Bounds = bounds;
// write out to the stream
try
{
await enc.FlushAsync();
}
catch (Exception ex)
{
string s = ex.ToString();
}
ras.Seek(0);
// render the stream to the screen
BitmapImage bImg = new BitmapImage();
bImg.SetSource(ras);
imgHidden.Source = bImg; // image element in xaml
if (folder != null)
{
StorageFile file1 = await folder.CreateFileAsync(fname + "."+imgFormat, CreationCollisionOption.ReplaceExisting);
using (var fileStream1 = await file1.OpenAsync(FileAccessMode.ReadWrite))
{
await RandomAccessStream.CopyAndCloseAsync(ras.GetInputStreamAt(0), fileStream1.GetOutputStreamAt(0));
}
}
}
private async Task WriteImageToFile(InMemoryRandomAccessStream stream, string fileName, bool isLockScreen)
{
StorageFolder localFolder = await GetImageCacheFolder(isLockScreen);
StorageFile file = await localFolder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting);
using (var fileStream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
await RandomAccessStream.CopyAndCloseAsync(stream.GetInputStreamAt(0), fileStream.GetOutputStreamAt(0));
}
}
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);
}
public async void SampleDataProtectionStream(String descriptor)
{
EncryptDecryptText.Text += "*** Sample Stream Data Protection for " + descriptor + " ***\n";
IBuffer data = CryptographicBuffer.GenerateRandom(10000);
DataReader reader1, reader2;
IBuffer buff1, buff2;
DataProtectionProvider Provider = new DataProtectionProvider(descriptor);
InMemoryRandomAccessStream originalData = new InMemoryRandomAccessStream();
//Populate the new memory stream
IOutputStream outputStream = originalData.GetOutputStreamAt(0);
DataWriter writer = new DataWriter(outputStream);
writer.WriteBuffer(data);
await writer.StoreAsync();
await outputStream.FlushAsync();
//open new memory stream for read
IInputStream source = originalData.GetInputStreamAt(0);
//Open the output memory stream
InMemoryRandomAccessStream protectedData = new InMemoryRandomAccessStream();
IOutputStream dest = protectedData.GetOutputStreamAt(0);
// Protect
await Provider.ProtectStreamAsync(source, dest);
//Flush the output
if (await dest.FlushAsync())
EncryptDecryptText.Text += " Protected output was successfully flushed\n";
//Verify the protected data does not match the original
reader1 = new DataReader(originalData.GetInputStreamAt(0));
reader2 = new DataReader(protectedData.GetInputStreamAt(0));
await reader1.LoadAsync((uint)originalData.Size);
await reader2.LoadAsync((uint)protectedData.Size);
EncryptDecryptText.Text += " Size of original stream: " + originalData.Size + "\n";
EncryptDecryptText.Text += " Size of protected stream: " + protectedData.Size + "\n";
if (originalData.Size == protectedData.Size)
{
buff1 = reader1.ReadBuffer((uint)originalData.Size);
buff2 = reader2.ReadBuffer((uint)protectedData.Size);
if (CryptographicBuffer.Compare(buff1, buff2))
{
EncryptDecryptText.Text += "ProtectStreamAsync returned unprotected data";
return;
}
}
EncryptDecryptText.Text += " Stream Compare completed. Streams did not match.\n";
source = protectedData.GetInputStreamAt(0);
InMemoryRandomAccessStream unprotectedData = new InMemoryRandomAccessStream();
dest = unprotectedData.GetOutputStreamAt(0);
// Unprotect
DataProtectionProvider Provider2 = new DataProtectionProvider();
await Provider2.UnprotectStreamAsync(source, dest);
if (await dest.FlushAsync())
EncryptDecryptText.Text += " Unprotected output was successfully flushed\n";
//Verify the unprotected data does match the original
reader1 = new DataReader(originalData.GetInputStreamAt(0));
reader2 = new DataReader(unprotectedData.GetInputStreamAt(0));
await reader1.LoadAsync((uint)originalData.Size);
await reader2.LoadAsync((uint)unprotectedData.Size);
EncryptDecryptText.Text += " Size of original stream: " + originalData.Size + "\n";
EncryptDecryptText.Text += " Size of unprotected stream: " + unprotectedData.Size + "\n";
buff1 = reader1.ReadBuffer((uint)originalData.Size);
buff2 = reader2.ReadBuffer((uint)unprotectedData.Size);
if (!CryptographicBuffer.Compare(buff1, buff2))
{
EncryptDecryptText.Text += "UnrotectStreamAsync did not return expected data";
return;
}
EncryptDecryptText.Text += "*** Done!\n";
}
private static async Task<bool> DownloadArtistPictureFromLastFm(MusicLibraryViewModel.ArtistItem artist)
{
var lastFmClient = new LastFmClient();
var lastFmArtist = await lastFmClient.GetArtistInfo(artist.Name);
if (lastFmArtist == null) return false;
try
{
var clientPic = new HttpClient();
var imageElement = lastFmArtist.Images.LastOrDefault(node => !string.IsNullOrEmpty(node.Url));
if (imageElement == null) return false;
HttpResponseMessage responsePic = await clientPic.GetAsync(imageElement.Url);
byte[] img = await responsePic.Content.ReadAsByteArrayAsync();
InMemoryRandomAccessStream streamWeb = new InMemoryRandomAccessStream();
DataWriter writer = new DataWriter(streamWeb.GetOutputStreamAt(0));
writer.WriteBytes(img);
await writer.StoreAsync();
StorageFolder artistPic = await ApplicationData.Current.LocalFolder.CreateFolderAsync("artistPic",
CreationCollisionOption.OpenIfExists);
string fileName = artist.Name + "_" + "dPi";
var file = await artistPic.CreateFileAsync(fileName + ".jpg", CreationCollisionOption.OpenIfExists);
var raStream = await file.OpenAsync(FileAccessMode.ReadWrite);
using (var thumbnailStream = streamWeb.GetInputStreamAt(0))
{
using (var stream = raStream.GetOutputStreamAt(0))
{
await RandomAccessStream.CopyAsync(thumbnailStream, stream);
}
}
StorageFolder appDataFolder = ApplicationData.Current.LocalFolder;
string supposedPictureUriLocal = appDataFolder.Path + "\\artistPic\\" + artist.Name + "_" + "dPi" + ".jpg";
DispatchHelper.InvokeAsync(() => artist.Picture = supposedPictureUriLocal);
return true;
}
catch (Exception)
{
Debug.WriteLine("Error getting or saving art from LastFm.");
return false;
}
}
/// <summary>
/// Helper that produces the contents corresponding to a Uri.
/// Uses the C# await pattern to coordinate async operations.
/// </summary>
/// <param name="uri"></param>
/// <returns></returns>
private async Task<IInputStream> GetContentAsync(Uri uri)
{
string path = uri.AbsolutePath;
string contents;
switch (path)
{
case "/default.html":
contents = await MainPage.LoadStringFromPackageFileAsync("stream_example.html");
contents = contents.Replace("%", Windows.ApplicationModel.Package.Current.Id.Name);
break;
case "/stream.css":
contents = "p { color: blue; }";
break;
default:
throw new Exception($"Could not resolve URI \"{uri}\"");
}
// Convert the string to a stream.
IBuffer buffer = CryptographicBuffer.ConvertStringToBinary(contents, BinaryStringEncoding.Utf8);
var stream = new InMemoryRandomAccessStream();
await stream.WriteAsync(buffer);
return stream.GetInputStreamAt(0);
}
private async Task WriteImageToFile(InMemoryRandomAccessStream stream, UpdateTypes type)
{
StorageFolder localFolder = await GetImageCacheFolder(type);
StorageFile file = await localFolder.CreateFileAsync("cachedImage.jpg", CreationCollisionOption.GenerateUniqueName);
using (var fileStream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
await RandomAccessStream.CopyAndCloseAsync(stream.GetInputStreamAt(0), fileStream.GetOutputStreamAt(0));
}
}