public async System.Threading.Tasks.Task ReadFile(StorageFile file)
{
byte[] fileBytes = null;
Pithline.FMS.BusinessLogic.Portable.TIModels.ImageCapture imageCapture;
using (IRandomAccessStreamWithContentType stream = await file.OpenReadAsync())
{
fileBytes = new byte[stream.Size];
using (DataReader reader = new DataReader(stream))
{
await reader.LoadAsync((uint)stream.Size);
reader.ReadBytes(fileBytes);
var bitmap = new BitmapImage();
stream.Seek(0);
await bitmap.SetSourceAsync(stream);
imageCapture = new Pithline.FMS.BusinessLogic.Portable.TIModels.ImageCapture
{
ImageBitmap = bitmap,
ImageData = Convert.ToBase64String(fileBytes),
guid = Guid.NewGuid(),
RepairId = 0,
Component = ""
};
}
}
EventAggregator.GetEvent <ImageCaptureTranEvent>().Publish(imageCapture);
}
public async System.Threading.Tasks.Task ReadFile(StorageFile file, ServiceSchedulingDetail serviceSchedulingDetail)
{
byte[] fileBytes = null;
using (IRandomAccessStreamWithContentType stream = await file.OpenReadAsync())
{
fileBytes = new byte[stream.Size];
using (DataReader reader = new DataReader(stream))
{
await reader.LoadAsync((uint)stream.Size);
reader.ReadBytes(fileBytes);
var bitmap = new BitmapImage();
stream.Seek(0);
await bitmap.SetSourceAsync(stream);
if (serviceSchedulingDetail == null)
{
serviceSchedulingDetail = new ServiceSchedulingDetail();
}
serviceSchedulingDetail.OdoReadingImageCapture = new ImageCapture
{
ImageBitmap = bitmap,
ImageBinary = Convert.ToBase64String(fileBytes),
};
serviceSchedulingDetail.ODOReadingSnapshot = Convert.ToBase64String(fileBytes);
}
}
EventAggregator.GetEvent <ServiceSchedulingDetailEvent>().Publish(serviceSchedulingDetail);
}
// For picture
public async void ContinueFileOpenPicker(FileOpenPickerContinuationEventArgs args)
{
if ((args.ContinuationData["EntityImage"] as string) == "EntityImage" && args.Files != null && args.Files.Count > 0)
{
// Check if the entity has entityimage anyway.
var imageField = fields.Where(x => x.FieldMetadata.LogicalName == "entityimage").FirstOrDefault();
if (imageField != null)
{
StorageFile file = args.Files[0];
IRandomAccessStreamWithContentType fileStream = await file.OpenReadAsync();
BitmapImage im = new BitmapImage();
im.SetSource(fileStream);
fileStream.Seek(0);
byte[] fileBytes = null;
fileBytes = new byte[fileStream.Size];
using (DataReader reader = new DataReader(fileStream))
{
await reader.LoadAsync((uint)fileStream.Size);
reader.ReadBytes(fileBytes);
}
imageField.FieldData = fileBytes;
((this.CRMRecordModify.lvFields.Items.First() as Grid).Children[1] as EntityImageControl).ImageBytes = fileBytes;
}
return;
}
}
public async System.Threading.Tasks.Task ShowImage(StorageFile file)
{
var bitmap = new BitmapImage();
using (IRandomAccessStreamWithContentType stream = await file.OpenReadAsync())
{
stream.Seek(0);
await bitmap.SetSourceAsync(stream);
this.img.Source = bitmap;
this.img.Name = file.DisplayName;
}
}
/// <summary>
/// Loads the byte data from a StorageFile
/// </summary>
/// <param name="file">The file to read</param>
public async Task <byte[]> ReadFile(StorageFile file)
{
using (IRandomAccessStreamWithContentType stream = await file.OpenReadAsync())
{
stream.Seek((ulong)0);
byte[] fileBytes = new byte[stream.Size];
var buffer = CryptographicBuffer.CreateFromByteArray(fileBytes);
IBuffer rd = await stream.ReadAsync(buffer, (uint)fileBytes.Length, InputStreamOptions.None);
rd.CopyTo(fileBytes);
return(fileBytes);
}
}
private void SeekDownload_Click(object sender, RoutedEventArgs e)
{
// Cancel the ongoing read operation (if any).
if (readOperation != null)
{
readCancellationTokenSource.Cancel();
// Re-create the CancellationTokenSource for future reads.
readCancellationTokenSource = new CancellationTokenSource();
}
if (randomAccessStream != null)
{
// Update the stream's seek position to the user-selected one.
// The new seek position will take effect on the next ReadAsync operation.
var seekPositionInMegaBytes = (ulong)seekSlider.Value;
ulong seekPositionInBytes = seekPositionInMegaBytes * BytesPerMegaByte;
randomAccessStream.Seek(seekPositionInBytes);
}
}
private async void OpenImageFile(string fileName)
{
StorageFolder installFolder = Windows.ApplicationModel.Package.Current.InstalledLocation;
StorageFolder subFolder = await installFolder.GetFolderAsync("Assets");
subFolder = await subFolder.GetFolderAsync("Pickers");
StorageFile file = await subFolder.GetFileAsync(fileName);
using (IRandomAccessStreamWithContentType reader = await file.OpenReadAsync())
{
// There has to be a better way to do this.
BitmapImage image = new BitmapImage();
await image.SetSourceAsync(reader);
WriteableBitmap imageBitmap = new WriteableBitmap(image.PixelWidth, image.PixelHeight);
reader.Seek(0);
await imageBitmap.SetSourceAsync(reader);
m_imagePixelArray = imageBitmap.PixelBuffer.ToArray();
m_imageHeight = imageBitmap.PixelHeight;
m_imageWidth = imageBitmap.PixelWidth;
}
}
private static async Task<int> FileReadStreamSeekTestAsync(IRandomAccessStreamWithContentType fileStream, long streamReadSize, byte[] bufferToCompare)
{
int attempts = 1;
ulong position = 0;
Assert.AreEqual(position, fileStream.Position);
position += await FileReadStreamSeekAndCompareAsync(fileStream, bufferToCompare, position, 1024, 1024);
attempts++;
Assert.AreEqual(position, fileStream.Position);
position += await FileReadStreamSeekAndCompareAsync(fileStream, bufferToCompare, position, 512, 512);
Assert.AreEqual(position, fileStream.Position);
position = (ulong)(bufferToCompare.Length - 128);
fileStream.Seek(position);
Assert.AreEqual(position, fileStream.Position);
position += await FileReadStreamSeekAndCompareAsync(fileStream, bufferToCompare, position, 1024, 128);
attempts++;
Assert.AreEqual(position, fileStream.Position);
position = 4096;
fileStream.Seek(position);
Assert.AreEqual(position, fileStream.Position);
position += await FileReadStreamSeekAndCompareAsync(fileStream, bufferToCompare, position, 1024, 1024);
attempts++;
Assert.AreEqual(position, fileStream.Position);
position += 4096;
fileStream.Seek(position);
Assert.AreEqual(position, fileStream.Position);
position += await FileReadStreamSeekAndCompareAsync(fileStream, bufferToCompare, position, 1024, 1024);
Assert.AreEqual(position, fileStream.Position);
position -= 4096;
fileStream.Seek(position);
Assert.AreEqual(position, fileStream.Position);
position += await FileReadStreamSeekAndCompareAsync(fileStream, bufferToCompare, position, 128, 128);
Assert.AreEqual(position, fileStream.Position);
position = (ulong)(streamReadSize + 4096 - 512);
fileStream.Seek(position);
Assert.AreEqual(position, fileStream.Position);
position += await FileReadStreamSeekAndCompareAsync(fileStream, bufferToCompare, position, 1024, 1024);
attempts++;
Assert.AreEqual(position, fileStream.Position);
position += await FileReadStreamSeekAndCompareAsync(fileStream, bufferToCompare, position, 1024, 1024);
Assert.AreEqual(position, fileStream.Position);
position -= 1024;
fileStream.Seek(position);
Assert.AreEqual(position, fileStream.Position);
position += await FileReadStreamSeekAndCompareAsync(fileStream, bufferToCompare, position, 2048, 2048);
Assert.AreEqual(position, fileStream.Position);
position = (ulong)(bufferToCompare.Length - 128);
fileStream.Seek(position);
Assert.AreEqual(position, fileStream.Position);
position += await FileReadStreamSeekAndCompareAsync(fileStream, bufferToCompare, position, 1024, 128);
Assert.AreEqual(position, fileStream.Position);
return attempts;
}
private async Task StartDownloadAndReadContentsAsync()
{
try
{
// Retrieve a random access stream from the download operation. Every OpenReadAsync() operation returns
// a new stream instance that is independent of previous ones (i.e., the seek position of one stream
// isn't affected by calls on another stream).
//
// This sample demonstrates the direct usage of a DownloadOperation's random access stream and its
// effects on the ongoing transfer. However, bear in mind that there are a variety of operations
// that can manage the stream on the app's behalf for specific scenarios. For instance, a
// DownloadOperation pointing to a video URL can be consumed by the MediaPlayer class in four easy
// steps:
//
// var randomAccessStreamReference = download.GetResultRandomAccessStreamReference();
// stream = await randomAccessStreamReference.OpenReadAsync();
// var mediaPlayer = new Windows.Media.Playback.MediaPlayer();
// mediaPlayer.Source = Windows.Media.Core.MediaSource.CreateFromStream(stream, stream.ContentType);
var randomAccessStreamReference = download.GetResultRandomAccessStreamReference();
randomAccessStream = await randomAccessStreamReference.OpenReadAsync();
// Start the download. If the server doesn't support random access, the download will fail
// with WebErrorStatus.InsufficientRangeSupport or WebErrorStatus.MissingContentLengthSupport.
IAsyncOperationWithProgress <DownloadOperation, DownloadOperation> downloadOperation = download.StartAsync();
downloadOperation.Progress += OnDownloadProgress;
Task downloadTask = downloadOperation.AsTask();
startDownloadButton.IsEnabled = false;
pauseDownloadButton.IsEnabled = true;
// Read data while the download is still ongoing. Use a 1 MB read buffer for that purpose.
var readBuffer = new Windows.Storage.Streams.Buffer(BytesPerMegaByte);
while (!downloadTask.IsCompleted)
{
ulong readOffsetInBytes = randomAccessStream.Position;
PreviousReadText.Text = CurrentReadText.Text;
CurrentReadText.Text = $"Reading from offset {readOffsetInBytes:n0}";
readOperation = randomAccessStream.ReadAsync(
readBuffer,
readBuffer.Capacity,
InputStreamOptions.None).
AsTask(readCancellationTokenSource.Token);
// Update the UI to show the current read's position.
currentPositionSlider.Value = readOffsetInBytes / BytesPerMegaByte;
try
{
// Wait for the read to complete.
IBuffer bytesRead = await readOperation;
CurrentReadText.Text += $", completed with {bytesRead.Length:n0} bytes";
// At this point, a real app would process the 'bytesRead' data to do something interesting
// with it (e.g., display video and/or play audio).
if (randomAccessStream.Position >= randomAccessStream.Size)
{
// We have reached EOF. Wrap around to the beginning while we wait for the download to complete.
randomAccessStream.Seek(0);
}
}
catch (OperationCanceledException)
{
// The ongoing read was canceled by SeekDownload_Click(...) in order for a new download
// position to take effect immediately.
CurrentReadText.Text += ", cancelled.";
}
}
// Wait for the download to complete.
await downloadTask;
rootPage.NotifyUser("Download completed successfully", NotifyType.StatusMessage);
}
catch (Exception ex) when(IsWebException("Execution error", ex))
{
// Abandon the operation if a web exception occurs.
}
finally
{
download = null;
randomAccessStream = null;
readOperation = null;
startDownloadButton.IsEnabled = true;
pauseDownloadButton.IsEnabled = false;
resumeDownloadButton.IsEnabled = false;
}
}
private static async Task <int> BlobReadStreamSeekTestAsync(IRandomAccessStreamWithContentType blobStream, long streamReadSize, byte[] bufferToCompare)
{
int attempts = 1;
ulong position = 0;
Assert.AreEqual(position, blobStream.Position);
position += await BlobReadStreamSeekAndCompareAsync(blobStream, bufferToCompare, position, 1024, 1024);
attempts++;
Assert.AreEqual(position, blobStream.Position);
position += await BlobReadStreamSeekAndCompareAsync(blobStream, bufferToCompare, position, 512, 512);
Assert.AreEqual(position, blobStream.Position);
position = (ulong)(bufferToCompare.Length - 128);
blobStream.Seek(position);
Assert.AreEqual(position, blobStream.Position);
position += await BlobReadStreamSeekAndCompareAsync(blobStream, bufferToCompare, position, 1024, 128);
attempts++;
Assert.AreEqual(position, blobStream.Position);
position = 4096;
blobStream.Seek(position);
Assert.AreEqual(position, blobStream.Position);
position += await BlobReadStreamSeekAndCompareAsync(blobStream, bufferToCompare, position, 1024, 1024);
attempts++;
Assert.AreEqual(position, blobStream.Position);
position += 4096;
blobStream.Seek(position);
Assert.AreEqual(position, blobStream.Position);
position += await BlobReadStreamSeekAndCompareAsync(blobStream, bufferToCompare, position, 1024, 1024);
Assert.AreEqual(position, blobStream.Position);
position -= 4096;
blobStream.Seek(position);
Assert.AreEqual(position, blobStream.Position);
position += await BlobReadStreamSeekAndCompareAsync(blobStream, bufferToCompare, position, 128, 128);
Assert.AreEqual(position, blobStream.Position);
position = (ulong)(streamReadSize + 4096 - 512);
blobStream.Seek(position);
Assert.AreEqual(position, blobStream.Position);
position += await BlobReadStreamSeekAndCompareAsync(blobStream, bufferToCompare, position, 1024, 1024);
attempts++;
Assert.AreEqual(position, blobStream.Position);
position += await BlobReadStreamSeekAndCompareAsync(blobStream, bufferToCompare, position, 1024, 1024);
Assert.AreEqual(position, blobStream.Position);
position -= 1024;
blobStream.Seek(position);
Assert.AreEqual(position, blobStream.Position);
position += await BlobReadStreamSeekAndCompareAsync(blobStream, bufferToCompare, position, 2048, 2048);
Assert.AreEqual(position, blobStream.Position);
position = (ulong)(bufferToCompare.Length - 128);
blobStream.Seek(position);
Assert.AreEqual(position, blobStream.Position);
position += await BlobReadStreamSeekAndCompareAsync(blobStream, bufferToCompare, position, 1024, 128);
Assert.AreEqual(position, blobStream.Position);
return(attempts);
}
private static async Task <int> BlobReadStreamSeekTestAsync(IRandomAccessStreamWithContentType blobStream, long streamReadSize, byte[] bufferToCompare)
#endif
{
int attempts = 1;
ulong position = 0;
Assert.AreEqual(position, blobStream.Position);
position += await BlobReadStreamSeekAndCompareAsync(blobStream, bufferToCompare, position, 1024, 1024);
attempts++;
Assert.AreEqual(position, blobStream.Position);
position += await BlobReadStreamSeekAndCompareAsync(blobStream, bufferToCompare, position, 512, 512);
Assert.AreEqual(position, blobStream.Position);
position = (ulong)(bufferToCompare.Length - 128);
blobStream.Seek(position);
Assert.AreEqual(position, blobStream.Position);
position += await BlobReadStreamSeekAndCompareAsync(blobStream, bufferToCompare, position, 1024, 128);
attempts++;
Assert.AreEqual(position, blobStream.Position);
position = 4096;
blobStream.Seek(position);
Assert.AreEqual(position, blobStream.Position);
position += await BlobReadStreamSeekAndCompareAsync(blobStream, bufferToCompare, position, 1024, 1024);
attempts++;
Assert.AreEqual(position, blobStream.Position);
position += 4096;
blobStream.Seek(position);
Assert.AreEqual(position, blobStream.Position);
position += await BlobReadStreamSeekAndCompareAsync(blobStream, bufferToCompare, position, 1024, 1024);
Assert.AreEqual(position, blobStream.Position);
position -= 4096;
blobStream.Seek(position);
Assert.AreEqual(position, blobStream.Position);
position += await BlobReadStreamSeekAndCompareAsync(blobStream, bufferToCompare, position, 128, 128);
Assert.AreEqual(position, blobStream.Position);
position = (ulong)(streamReadSize + 4096 - 512);
blobStream.Seek(position);
#if ASPNET_K
//don't know why adding these two line will pass, but this this the same as the desktop test
Assert.AreEqual(position, blobStream.Position);
position += await BlobReadStreamSeekAndCompareAsync(blobStream, bufferToCompare, position, 1024, 512);
#endif
Assert.AreEqual(position, blobStream.Position);
position += await BlobReadStreamSeekAndCompareAsync(blobStream, bufferToCompare, position, 1024, 1024);
attempts++;
Assert.AreEqual(position, blobStream.Position);
position += await BlobReadStreamSeekAndCompareAsync(blobStream, bufferToCompare, position, 1024, 1024);
Assert.AreEqual(position, blobStream.Position);
position -= 1024;
blobStream.Seek(position);
Assert.AreEqual(position, blobStream.Position);
position += await BlobReadStreamSeekAndCompareAsync(blobStream, bufferToCompare, position, 2048, 2048);
Assert.AreEqual(position, blobStream.Position);
position = (ulong)(bufferToCompare.Length - 128);
blobStream.Seek(position);
Assert.AreEqual(position, blobStream.Position);
position += await BlobReadStreamSeekAndCompareAsync(blobStream, bufferToCompare, position, 1024, 128);
Assert.AreEqual(position, blobStream.Position);
return(attempts);
}
private static async Task<int> FileReadStreamSeekTestAsync(IRandomAccessStreamWithContentType fileStream, long streamReadSize, byte[] bufferToCompare)
#endif
{
int attempts = 1;
ulong position = 0;
Assert.AreEqual(position, fileStream.Position);
position += await FileReadStreamSeekAndCompareAsync(fileStream, bufferToCompare, position, 1024, 1024);
attempts++;
Assert.AreEqual(position, fileStream.Position);
position += await FileReadStreamSeekAndCompareAsync(fileStream, bufferToCompare, position, 512, 512);
Assert.AreEqual(position, fileStream.Position);
position = (ulong)(bufferToCompare.Length - 128);
fileStream.Seek(position);
Assert.AreEqual(position, fileStream.Position);
position += await FileReadStreamSeekAndCompareAsync(fileStream, bufferToCompare, position, 1024, 128);
attempts++;
Assert.AreEqual(position, fileStream.Position);
position = 4096;
fileStream.Seek(position);
Assert.AreEqual(position, fileStream.Position);
position += await FileReadStreamSeekAndCompareAsync(fileStream, bufferToCompare, position, 1024, 1024);
attempts++;
Assert.AreEqual(position, fileStream.Position);
position += 4096;
fileStream.Seek(position);
Assert.AreEqual(position, fileStream.Position);
position += await FileReadStreamSeekAndCompareAsync(fileStream, bufferToCompare, position, 1024, 1024);
Assert.AreEqual(position, fileStream.Position);
position -= 4096;
fileStream.Seek(position);
Assert.AreEqual(position, fileStream.Position);
position += await FileReadStreamSeekAndCompareAsync(fileStream, bufferToCompare, position, 128, 128);
Assert.AreEqual(position, fileStream.Position);
position = (ulong)(streamReadSize + 4096 - 512);
fileStream.Seek(position);
#if ASPNET_K
//don't know why adding these two line will pass, but this this the same as the desktop test
Assert.AreEqual(position, fileStream.Position);
position += await FileReadStreamSeekAndCompareAsync(fileStream, bufferToCompare, position, 1024, 512);
#endif
Assert.AreEqual(position, fileStream.Position);
position += await FileReadStreamSeekAndCompareAsync(fileStream, bufferToCompare, position, 1024, 1024);
attempts++;
Assert.AreEqual(position, fileStream.Position);
position += await FileReadStreamSeekAndCompareAsync(fileStream, bufferToCompare, position, 1024, 1024);
Assert.AreEqual(position, fileStream.Position);
position -= 1024;
fileStream.Seek(position);
Assert.AreEqual(position, fileStream.Position);
position += await FileReadStreamSeekAndCompareAsync(fileStream, bufferToCompare, position, 2048, 2048);
Assert.AreEqual(position, fileStream.Position);
position = (ulong)(bufferToCompare.Length - 128);
fileStream.Seek(position);
Assert.AreEqual(position, fileStream.Position);
position += await FileReadStreamSeekAndCompareAsync(fileStream, bufferToCompare, position, 1024, 128);
Assert.AreEqual(position, fileStream.Position);
return attempts;
}
