/// <summary>
/// This method is used to populate all the jobs from the file Jobs.xml.
/// It reads the xml file and serializes the data into a list of jobs.
/// </summary>
private async Task ReadXmlDataFromLocalStorageAsync()
{
try
{
//If job list already loaded from XML file, skip reloading it again.
if (_jobDataSource.AllJobs != null)
{
return;
}
var dataFolder = await Package.Current.InstalledLocation.GetFolderAsync(Constants.DataFilesFolder);
StorageFile sessionFile = await dataFolder.GetFileAsync(Constants.FieldEngineerFile);
using (
IRandomAccessStreamWithContentType sessionInputStream =
await sessionFile.OpenReadAsync())
{
var sessionSerializer = new DataContractSerializer(typeof(List <Job>));
var restoredData = sessionSerializer.ReadObject(sessionInputStream.AsStreamForRead());
_alljobs = (List <Job>)restoredData;
}
}
catch (Exception ex)
{
_alljobs = null;
}
}
public async Task <Stream> GetImageStreamAsync()
{
// Create and initialize the FileOpenPicker
FileOpenPicker openPicker = new FileOpenPicker
{
ViewMode = PickerViewMode.Thumbnail,
SuggestedStartLocation = PickerLocationId.PicturesLibrary,
};
openPicker.FileTypeFilter.Add(".jpg");
openPicker.FileTypeFilter.Add(".jpeg");
openPicker.FileTypeFilter.Add(".png");
// Get a file and return a Stream
StorageFile storageFile = await openPicker.PickSingleFileAsync();
if (storageFile == null)
{
return(null);
}
IRandomAccessStreamWithContentType raStream = await storageFile.OpenReadAsync();
return(raStream.AsStreamForRead());
}
protected override async Task <IEnumerable <TSchema> > GetDataAsync <TSchema>(LocalStorageDataConfig config, int pageSize, IParser <TSchema> parser)
{
ContinuationToken = "1";
IRandomAccessStreamWithContentType randomStream = await GetRandomStream(config);
using (StreamReader r = new StreamReader(randomStream.AsStreamForRead()))
{
var items = await parser.ParseAsync(await r.ReadToEndAsync());
if (items != null && items.Any())
{
_totalItems = items.ToList();
var totalAsTSchema = (_totalItems as IEnumerable <TSchema>);
_hasMoreItems = totalAsTSchema.Count() > pageSize;
ContinuationToken = GetContinuationToken(ContinuationToken);
var resultToReturn = totalAsTSchema.AsQueryable().OrderBy(config.OrderBy, config.OrderDirection).Take(pageSize).ToList();
return(resultToReturn);
}
_hasMoreItems = false;
return(new TSchema[0]);
}
}
public async Task FileReadStreamBasicTestAsync()
{
byte[] buffer = GetRandomBuffer(5 * 1024 * 1024);
CloudFileShare share = GetRandomShareReference();
try
{
await share.CreateAsync();
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1");
using (MemoryStream wholeFile = new MemoryStream(buffer))
{
await file.UploadFromStreamAsync(wholeFile.AsInputStream());
}
using (MemoryStream wholeFile = new MemoryStream(buffer))
{
IRandomAccessStreamWithContentType readStream = await file.OpenReadAsync();
using (Stream fileStream = readStream.AsStreamForRead())
{
TestHelper.AssertStreamsAreEqual(wholeFile, fileStream);
}
}
}
finally
{
share.DeleteIfExistsAsync().AsTask().Wait();
}
}
/// <summary>
/// 下面开始读取文件。为了把Windows运行库流转换为.NET流用于读取，
/// 可以使用扩展方法AsStreamForRead。
/// 这个方法是在程序集System.Runtime.WindowsRuntime
/// 的System.IO名称空间中定义（必须打开）。
/// 这个方法创建了一个新的stream对象，来管理IInputstreamo现在，
/// 可以使用它作为正常的.NET流。
/// </summary>
public async void OnOpenDotnet()
{
try
{
var picker = new FileOpenPicker()
{
SuggestedStartLocation = PickerLocationId.DocumentsLibrary
};
picker.FileTypeFilter.Add(".txt");
StorageFile file = await picker.PickSingleFileAsync();
if (file != null)
{
IRandomAccessStreamWithContentType wrtStream = await file.OpenReadAsync();
Stream stream = wrtStream.AsStreamForRead();
using (var reader = new StreamReader(stream))
{
myText.Text = await reader.ReadToEndAsync();
}
}
}
catch (Exception ex)
{
await new MessageDialog(ex.Message, "Error").ShowAsync();
}
}
public async void OnOpenDotnet()
{
try
{
FileOpenPicker picker = new()
{
ViewMode = PickerViewMode.Thumbnail,
SuggestedStartLocation = PickerLocationId.DocumentsLibrary
};
picker.FileTypeFilter.Add(".txt");
picker.FileTypeFilter.Add(".md");
InitializeActiveWindow(picker);
StorageFile file = await picker.PickSingleFileAsync();
if (file != null)
{
IRandomAccessStreamWithContentType wrtStream = await file.OpenReadAsync();
Stream stream = wrtStream.AsStreamForRead();
StreamReader reader = new(stream);
text1.Text = await reader.ReadToEndAsync();
}
}
catch (Exception ex)
{
MessageDialog dlg = new(ex.Message, "Error");
await dlg.ShowAsync();
}
}
public async Task FileReadLockToETagTestAsync()
{
byte[] outBuffer = new byte[1 * 1024 * 1024];
byte[] buffer = GetRandomBuffer(2 * outBuffer.Length);
CloudFileShare share = GetRandomShareReference();
try
{
await share.CreateAsync();
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1");
file.StreamMinimumReadSizeInBytes = outBuffer.Length;
using (MemoryStream wholeFile = new MemoryStream(buffer))
{
await file.UploadFromStreamAsync(wholeFile.AsInputStream());
}
OperationContext opContext = new OperationContext();
using (IRandomAccessStreamWithContentType fileStream = await file.OpenReadAsync(null, null, opContext))
{
Stream fileStreamForRead = fileStream.AsStreamForRead();
await fileStreamForRead.ReadAsync(outBuffer, 0, outBuffer.Length);
await file.SetMetadataAsync();
await ExpectedExceptionAsync(
async() => await fileStreamForRead.ReadAsync(outBuffer, 0, outBuffer.Length),
opContext,
"File read stream should fail if file is modified during read",
HttpStatusCode.PreconditionFailed);
}
opContext = new OperationContext();
using (IRandomAccessStreamWithContentType fileStream = await file.OpenReadAsync(null, null, opContext))
{
Stream fileStreamForRead = fileStream.AsStreamForRead();
long length = fileStreamForRead.Length;
await file.SetMetadataAsync();
await ExpectedExceptionAsync(
async() => await fileStreamForRead.ReadAsync(outBuffer, 0, outBuffer.Length),
opContext,
"File read stream should fail if file is modified during read",
HttpStatusCode.PreconditionFailed);
}
/*
* opContext = new OperationContext();
* AccessCondition accessCondition = AccessCondition.GenerateIfNotModifiedSinceCondition(DateTimeOffset.Now.Subtract(TimeSpan.FromHours(1)));
* await file.SetMetadataAsync();
* await TestHelper.ExpectedExceptionAsync(
* async () => await file.OpenReadAsync(accessCondition, null, opContext),
* opContext,
* "File read stream should fail if file is modified during read",
* HttpStatusCode.PreconditionFailed);
*/
}
finally
{
share.DeleteIfExistsAsync().AsTask().Wait();
}
}
public async Task PageBlobReadStreamBasicTestAsync()
{
byte[] buffer = GetRandomBuffer(5 * 1024 * 1024);
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
CloudPageBlob blob = container.GetPageBlobReference("blob1");
using (MemoryStream wholeBlob = new MemoryStream(buffer))
{
await blob.UploadFromStreamAsync(wholeBlob.AsInputStream());
}
using (MemoryStream wholeBlob = new MemoryStream(buffer))
{
wholeBlob.Seek(0, SeekOrigin.End);
IRandomAccessStreamWithContentType readStream = await blob.OpenReadAsync();
using (Stream blobStream = readStream.AsStreamForRead())
{
blobStream.Seek(0, SeekOrigin.End);
TestHelper.AssertStreamsAreEqual(wholeBlob, blobStream);
}
}
}
finally
{
container.DeleteIfExistsAsync().AsTask().Wait();
}
}
public async Task <IEnumerable <HtmlSchema> > Load()
{
try
{
StorageFile file = await StorageFile.GetFileFromApplicationUriAsync(_uri);
IRandomAccessStreamWithContentType randomStream = await file.OpenReadAsync();
using (StreamReader r = new StreamReader(randomStream.AsStreamForRead()))
{
string data = await r.ReadToEndAsync();
Collection <HtmlSchema> records = new Collection <HtmlSchema>();
records.Add(new HtmlSchema()
{
Content = data
});
return(records);
}
}
catch (Exception ex)
{
AppLogs.WriteError("ServiceDataProvider.Load", ex);
return(null);
}
}
public async Task <IEnumerable <TSchema> > GetDataByIdsAsync <TSchema>(LocalStorageDataConfig config, IEnumerable <string> ids, IParser <TSchema> parser) where TSchema : SchemaBase
{
#if UWP
IRandomAccessStreamWithContentType randomStream = await GetRandomStream(config);
using (StreamReader r = new StreamReader(randomStream.AsStreamForRead()))
{
var items = await parser.ParseAsync(await r.ReadToEndAsync());
if (items != null && items.Any())
{
var totalAsTSchema = (items.ToList() as IEnumerable <TSchema>);
var resultToReturn = totalAsTSchema.AsQueryable().Where(x => ids.Contains(x._id)).ToList();
return(resultToReturn);
}
return(new TSchema[0]);
}
#else
IFolder folder = FileSystem.Current.LocalStorage;
IFile file = await folder.GetFileAsync(config.FilePath);
var items = await parser.ParseAsync(await file.ReadAllTextAsync());
if (items != null && items.Any())
{
var totalAsTSchema = (items.ToList() as IEnumerable <TSchema>);
var resultToReturn = totalAsTSchema.AsQueryable().Where(x => ids.Contains(x._id)).ToList();
return(resultToReturn);
}
return(new TSchema[0]);
#endif
}
public async Task <Stream> GetStreamAsync()
{
ReleaseUnmanagedResources();
StorageFile file;
try {
StorageFolder LocalFolder = ApplicationData.Current.LocalFolder;
file = await LocalFolder.GetFileAsync("xamarin.appsettings.json");
}
catch {
var picker = new Windows.Storage.Pickers.FileOpenPicker();
picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.List;
picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.ComputerFolder;
picker.FileTypeFilter.Add(".json");
file = await picker.PickSingleFileAsync();
await file.CopyAsync(ApplicationData.Current.LocalFolder, "xamarin.appsettings.json", NameCollisionOption.ReplaceExisting);
}
_inputStream = await file.OpenReadAsync();
_readingStream = _inputStream.AsStreamForRead();
return(_readingStream);
}
private async void GenerateStream()
{
_accessStream = await _file.OpenReadAsync();
_classicStream = _accessStream.AsStreamForRead();
_streamReader = new StreamReader(_classicStream, _encoding);
}
protected async override void OnActivated(IActivatedEventArgs args)
{
base.OnActivated(args);
IContinuationActivatedEventArgs continuationArgs = args as IContinuationActivatedEventArgs;
if (continuationArgs != null &&
continuationArgs.Kind == ActivationKind.PickFileContinuation)
{
FileOpenPickerContinuationEventArgs pickerArgs = args as FileOpenPickerContinuationEventArgs;
if (pickerArgs.Files.Count > 0)
{
// Get the file and a Stream
StorageFile storageFile = pickerArgs.Files[0];
IRandomAccessStreamWithContentType raStream = await storageFile.OpenReadAsync();
Stream stream = raStream.AsStreamForRead();
// Set the completion of the Task
TaskCompletionSource.SetResult(stream);
}
else
{
TaskCompletionSource.SetResult(null);
}
}
}
private async void InitImage()
{
/// https://stackoverflow.com/questions/5346727/convert-memory-stream-to-bitmapimage
/// https://msdn.microsoft.com/zh-tw/library/windows/apps/xaml/hh973051.aspx?f=255&MSPPError=-2147217396
if (m_contact != null)
{
if (m_contact.Thumbnail != null)
{
IRandomAccessStreamWithContentType thumbnailStream = await m_contact.Thumbnail.OpenReadAsync();
Stream stream = thumbnailStream.AsStreamForRead();
BitmapImage thumbnailImage = new BitmapImage();
thumbnailImage.BeginInit();
thumbnailImage.StreamSource = stream;
thumbnailImage.CacheOption = BitmapCacheOption.OnLoad;
thumbnailImage.EndInit();
thumbnailImage.Freeze();
thumbnail.Source = thumbnailImage;
}
else if (m_contact.SourceDisplayPicture != null)
{
IRandomAccessStreamWithContentType thumbnailStream = await m_contact.SourceDisplayPicture.OpenReadAsync();
Stream stream = thumbnailStream.AsStreamForRead();
BitmapImage thumbnailImage = new BitmapImage();
thumbnailImage.BeginInit();
thumbnailImage.StreamSource = stream;
thumbnailImage.CacheOption = BitmapCacheOption.OnLoad;
thumbnailImage.EndInit();
thumbnailImage.Freeze();
thumbnail.Source = thumbnailImage;
}
}
}
// Loading data
public async Task <IEnumerable <DataGridDataItem> > GetDataAsync()
{
var uri = new Uri($"ms-appx:///Assets/mtns.csv");
StorageFile file = await StorageFile.GetFileFromApplicationUriAsync(uri);
IRandomAccessStreamWithContentType randomStream = await file.OpenReadAsync();
_items = new ObservableCollection <DataGridDataItem>();
using (StreamReader sr = new StreamReader(randomStream.AsStreamForRead()))
{
while (!sr.EndOfStream)
{
string line = sr.ReadLine();
string[] values = line.Split(',');
_items.Add(
new DataGridDataItem()
{
Rank = uint.Parse(values[0]),
Mountain = values[1],
Height_m = uint.Parse(values[2]),
Range = values[3],
Coordinates = values[4],
Prominence = uint.Parse(values[5]),
Parent_mountain = values[6],
First_ascent = uint.Parse(values[7]),
Ascents = values[8]
});
}
}
return(_items);
}
public static async Task <DataSet> LoadAsync(StorageFile file, int offset = 0, int count = 100)
{
using (IRandomAccessStreamWithContentType uwpStream = await file.OpenReadAsync())
{
using (Stream stream = uwpStream.AsStreamForRead())
{
var readerOptions = new ReaderOptions()
{
Offset = offset,
Count = count
};
var formatOptions = new ParquetOptions
{
TreatByteArrayAsString = true
};
try
{
return(ParquetReader.Read(stream, formatOptions, readerOptions));
}
catch (Exception ex)
{
var dialog = new MessageDialog(ex.Message, "Cannot open file");
await dialog.ShowAsync();
return(null);
}
}
}
}
public static async Task <String> Base64EncodeContent(this RandomAccessStreamReference streamReference)
{
using (IRandomAccessStreamWithContentType stream = await streamReference.OpenReadAsync())
{
var readStream = stream.AsStreamForRead();
var bytes = new byte[stream.Size];
readStream.Read(bytes, 0, (Int32)stream.Size);
var result = Convert.ToBase64String(bytes);
return(result);
}
}
static async Task StoreImage(string folderName, IRandomAccessStreamWithContentType stream, Guid id)
{
var folder =
await ApplicationData.Current.LocalFolder.CreateFolderAsync(folderName, CreationCollisionOption.OpenIfExists);
var file = await folder.CreateFileAsync(string.Format("{0}", id));
using (var newFileStream = await file.OpenStreamForWriteAsync())
{
stream.AsStreamForRead().CopyTo(newFileStream);
}
}
private static async Task <IEnumerable <ControlDataItem> > GetDevices()
{
var uri = new Uri("ms-appx:///Assets/FeaturedControls.json");
StorageFile file = await StorageFile.GetFileFromApplicationUriAsync(uri);
IRandomAccessStreamWithContentType randomStream = await file.OpenReadAsync();
using (StreamReader r = new StreamReader(randomStream.AsStreamForRead()))
{
return(Parse(await r.ReadToEndAsync()));
}
}
private async Task <Stream> GetStreamAsync(string file)
{
ReleaseUnmanagedResources();
var fileApp = await StorageFile.GetFileFromApplicationUriAsync(new Uri($@"ms-appx:///Assets//{file}"));
inputStream = await fileApp.OpenReadAsync();
readingStream = inputStream.AsStreamForRead();
return(readingStream);
}
public async Task <Stream> GetStreamAsync()
{
ReleaseUnmanagedResources();
var file = await StorageFile.GetFileFromApplicationUriAsync(new Uri(ConfigurationFilePath));
_inputStream = await file.OpenReadAsync();
_readingStream = _inputStream.AsStreamForRead();
return(_readingStream);
}
private static async Task <IEnumerable <PhotoDataItem> > GetPhotosAsync(bool online)
{
var prefix = online ? "Online" : string.Empty;
var uri = new Uri($"ms-appx:///Assets/Photos/{prefix}Photos.json");
StorageFile file = await StorageFile.GetFileFromApplicationUriAsync(uri);
IRandomAccessStreamWithContentType randomStream = await file.OpenReadAsync();
using (StreamReader r = new StreamReader(randomStream.AsStreamForRead()))
{
return(Parse(await r.ReadToEndAsync()));
}
}
public Stream OpenRead(string path)
{
try
{
StorageFile storageFile = NativeFile(path);
IRandomAccessStreamWithContentType streamWithContentType = storageFile.OpenReadAsync().Await();
return(streamWithContentType.AsStreamForRead());
}
catch
{
return(null);
}
}
protected override async Task <IEnumerable <TSchema> > GetDataAsync <TSchema>(LocalStorageDataConfig config, int maxRecords, IParser <TSchema> parser)
{
var uri = new Uri(string.Format("ms-appx://{0}", config.FilePath));
StorageFile file = await StorageFile.GetFileFromApplicationUriAsync(uri);
IRandomAccessStreamWithContentType randomStream = await file.OpenReadAsync();
using (StreamReader r = new StreamReader(randomStream.AsStreamForRead()))
{
return(parser.Parse(await r.ReadToEndAsync()));
}
}
private async Task <TouchDevelopSchema> GetLocalProject()
{
StorageFile file = await StorageFile.GetFileFromApplicationUriAsync(new Uri(string.Format("ms-appx://{0}", _config.LocalDataSource)));
IRandomAccessStreamWithContentType randomStream = await file.OpenReadAsync();
using (StreamReader r = new StreamReader(randomStream.AsStreamForRead()))
{
string data = await r.ReadToEndAsync();
return(JsonConvert.DeserializeObject <TouchDevelopSerialized>(data).Items.FirstOrDefault());
}
}
public static async Task <string> ReadAssetFile(string fileName)
{
var uri = new Uri(string.Format("ms-appx://{0}", fileName));
StorageFile file = await StorageFile.GetFileFromApplicationUriAsync(uri);
IRandomAccessStreamWithContentType randomStream = await file.OpenReadAsync();
using (StreamReader r = new StreamReader(randomStream.AsStreamForRead()))
{
return(await r.ReadToEndAsync());
}
}
public override async Task <IEnumerable <T> > LoadDataAsync()
{
var uri = new Uri(string.Format("ms-appx://{0}", _config.FilePath));
StorageFile file = await StorageFile.GetFileFromApplicationUriAsync(uri);
IRandomAccessStreamWithContentType randomStream = await file.OpenReadAsync();
using (StreamReader r = new StreamReader(randomStream.AsStreamForRead()))
{
return(_parser.Parse(await r.ReadToEndAsync()));
}
}
// https://docs.microsoft.com/en-us/xamarin/xamarin-forms/app-fundamentals/dependency-service/photo-picker
public async Task <FileChooserResult> GetFileAsync(bool imagesOnly = false) // TODO: image chooser result?
{
try
{
// Create and initialize the FileOpenPicker
FileOpenPicker openPicker = new FileOpenPicker
{
ViewMode = PickerViewMode.Thumbnail
};
if (imagesOnly)
{
foreach (var imageType in Core.StaticVariables.ImageFormats)
{
openPicker.FileTypeFilter.Add(imageType.Extension);
}
openPicker.SuggestedStartLocation = PickerLocationId.PicturesLibrary;
}
else
{
openPicker.FileTypeFilter.Add("*");
openPicker.SuggestedStartLocation = PickerLocationId.ComputerFolder;
}
// Get a file and return a Stream
StorageFile storageFile = await openPicker.PickSingleFileAsync();
if (storageFile == null)
{
return(null);
}
IRandomAccessStreamWithContentType raStream = await storageFile.OpenReadAsync();
return(new FileChooserResult()
{
FileName = storageFile.Path,
Stream = raStream.AsStreamForRead(),
NativeRepresentation = storageFile,
CarrierImageFormat = new ImageFormat(storageFile.Path)
});
}
catch (Exception ex)
{
return(new FileChooserResult()
{
ErrorMessage = ex.Message
});
}
}
public override Stream OpenRead(string path)
{
try
{
StorageFile storageFile = StorageFileFromRelativePath(path);
IRandomAccessStreamWithContentType streamWithContentType = storageFile.OpenReadAsync().Await();
return(streamWithContentType.AsStreamForRead());
}
catch (Exception ex)
{
logger.Error(ex);
return(null);
}
}
private async static Task <Frame> OpenAsync(IRandomAccessStreamWithContentType uwpStream)
{
using (Stream stream = uwpStream.AsStreamForRead())
{
var readerOptions = new ReaderOptions()
{
Count = new ParquetUwpFunctions().SampleSize,
Offset = 0
};
return(Frame.Read.Parquet(stream, new ParquetOptions {
TreatByteArrayAsString = true
}, new ReaderOptions {
Offset = 0, Count = 100
}));
}
}
