public MusicProperties(StorageFile file)
{
this.File = file;
this.Path = this.File.Path;
this.DateCreated = this.File.DateCreated;
var properties = Task.Run(async () => await file.Properties.RetrievePropertiesAsync(new String[]
{
"System.Music.AlbumTitle",
"System.Music.AlbumArtist",
"System.Music.Artist",
"System.Media.Duration",
"System.Music.Genre",
"System.DRM.IsProtected",
"System.Rating",
"System.Title",
"System.Music.TrackNumber"
})).Result;
object property;
this.Album = (properties.TryGetValue("System.Music.AlbumTitle", out property) ? (string)property : (string)null) ?? "";
this.Artist = (properties.TryGetValue("System.Music.Artist", out property) ? ((string[])property)[0] : (string)null) ?? "Unknown Artist";
this.AlbumArtist = (properties.TryGetValue("System.Music.AlbumArtist", out property) ? (string)property : (string)null) ?? this.Artist;
this.Duration = properties.TryGetValue("System.Media.Duration", out property) ? new TimeSpan((long)(ulong)property) : TimeSpan.Zero;
this.Genre = (properties.TryGetValue("System.Music.Genre", out property) ? ((string[])property)[0] : (string)null) ?? "";
this.IsProtected = properties.TryGetValue("System.DRM.IsProtected", out property) ? (bool)property : false;
this.Rating = properties.TryGetValue("System.Rating", out property) ? (int)(uint)property : 0;
this.Title = (properties.TryGetValue("System.Title", out property) ? (string)property : (string)null) ?? "";
this.TrackNumber = properties.TryGetValue("System.Music.TrackNumber", out property) ? (int)(uint)property : 0;
}
private async void PerformFaceAnalysis(StorageFile file)
{
var imageInfo = await FileHelper.GetImageInfoForRendering(file.Path);
NewImageSizeWidth = 300;
NewImageSizeHeight = NewImageSizeWidth*imageInfo.Item2/imageInfo.Item1;
var newSourceFile = await FileHelper.CreateCopyOfSelectedImage(file);
var uriSource = new Uri(newSourceFile.Path);
SelectedFileBitmapImage = new BitmapImage(uriSource);
// start face api detection
var faceApi = new FaceApiHelper();
DetectedFaces = await faceApi.StartFaceDetection(newSourceFile.Path, newSourceFile, imageInfo, "4c138b4d82b947beb2e2926c92d1e514");
// draw rectangles
var color = Color.FromArgb(125, 255, 0, 0);
var bg = new SolidColorBrush(color);
DetectedFacesCanvas = new ObservableCollection<Canvas>();
foreach (var detectedFace in DetectedFaces)
{
var margin = new Thickness(detectedFace.RectLeft, detectedFace.RectTop, 0, 0);
var canvas = new Canvas()
{
Background = bg,
HorizontalAlignment = HorizontalAlignment.Left,
VerticalAlignment = VerticalAlignment.Top,
Height = detectedFace.RectHeight,
Width = detectedFace.RectWidth,
Margin = margin
};
DetectedFacesCanvas.Add(canvas);
}
}
/// <summary>
/// Saves the specified bitmap to the specified location.
/// </summary>
/// <param name="source">The source bitmap image.</param>
/// <param name="destination">The destination storage file for the image. JPEG, PNG, GIF, BMP and TIFF formats are supported.</param>
/// <param name="width">The width of the image file.</param>
/// <param name="height">The height of the image file.</param>
/// <returns>True if the bitmap file was successfully saved. False otherwise.</returns>
public async Task<bool> Save(WriteableBitmap source, StorageFile destination, int width, int height)
{
if (source == null || destination == null) return false;
try
{
Guid encoderID = GetEncoderId(destination);
using (IRandomAccessStream stream = await destination.OpenAsync(FileAccessMode.ReadWrite))
{
Stream pixelStream = source.PixelBuffer.AsStream();
byte[] pixels = new byte[pixelStream.Length];
await pixelStream.ReadAsync(pixels, 0, pixels.Length);
BitmapEncoder encoder = await BitmapEncoder.CreateAsync(encoderID, stream);
encoder.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore, (uint)source.PixelWidth, (uint)source.PixelHeight, Constants.DPI, Constants.DPI, pixels);
if (source.PixelWidth != width || source.PixelHeight != height)
{
encoder.BitmapTransform.ScaledWidth = (uint)width;
encoder.BitmapTransform.ScaledHeight = (uint)height;
}
await encoder.FlushAsync();
}
return true;
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
return false;
}
private async void PhoneApplicationPage_Loaded(object sender, RoutedEventArgs e)
{
string video_name = null;
if (NavigationContext.QueryString.TryGetValue("Video", out video_name))
{
StorageFolder videosFolder = KnownFolders.VideosLibrary;
IReadOnlyList<StorageFile> fileList = await videosFolder.GetFilesAsync();
IReadOnlyList<StorageFolder> folderList = await videosFolder.GetFoldersAsync();
var count = fileList.Count + folderList.Count;
foreach (StorageFile file in fileList)
{
if (file.Name == video_name)
{
try {
path.Text = file.Path;
videoPlayer.Source = new Uri(file.Path, UriKind.Absolute);
video = file;
x = await video.Properties.GetVideoPropertiesAsync();
videoPlayer.Play();
//pbVideo.Maximum = (int)videoPlayer.NaturalDuration.TimeSpan.TotalSeconds;
changeProgressBar();
}
catch(Exception e1)
{
MessageBox.Show(e1.ToString());
}
}
}
}
}
//-------------------------------------------------------------------------------
#region +OpenCheckList チェックリストを開く
//-------------------------------------------------------------------------------
//
public async Task<bool> OpenCheckList(StorageFile file, Func<char, Task<int>> dayToDayIndexFunc, Func<int, Task<ComiketCircleAndLayout>> updateIdToCircle)
{
string enc_str = null;
using (var str = await file.OpenReadAsync())
using (StreamReader sr = new StreamReader(str.AsStreamForRead())) {
string line = sr.ReadLine();
enc_str = CheckList.CheckEncode(line);
if (enc_str == null) { return false; }
int comiketNo = CheckList.CheckComiketNo(line);
if (comiketNo != _comiketNo) { return false; }
}
Encoding enc = Encoding.GetEncoding(enc_str);
bool res;
using (var str = await file.OpenReadAsync())
using (StreamReader sr = new StreamReader(str.AsStreamForRead(), enc)) {
var lines = CheckList.FileReadLine(sr);
res = await this.ReadCSV(lines, dayToDayIndexFunc, updateIdToCircle);
}
if (res) {
await this.ReadTimeFile();
}
return res;
}
public HttpPostFile(string name, StorageFile file)
{
Name = name;
Filename = file.Name;
File = file;
CloseStream = true;
}
private async void previewElement_Tapped(object sender, TappedRoutedEventArgs e)
{
// Block multiple taps.
if (!IsCaptureInProgress)
{
IsCaptureInProgress = true;
// Create the temporary storage file.
media = await ApplicationData.Current.LocalFolder
.CreateFileAsync("capture_file.jpg", CreationCollisionOption.ReplaceExisting);
// Take the picture and store it locally as a JPEG.
await cameraCapture.CapturePhotoToStorageFileAsync(
ImageEncodingProperties.CreateJpeg(), media);
captureButtons.Visibility = Visibility.Visible;
// Use the stored image as the preview source.
BitmapImage tempBitmap = new BitmapImage(new Uri(media.Path));
imagePreview.Source = tempBitmap;
imagePreview.Visibility = Visibility.Visible;
previewElement.Visibility = Visibility.Collapsed;
IsCaptureInProgress = false;
}
}
public static async Task UnzipFromStorage(StorageFile pSource, StorageFolder pDestinationFolder, IEnumerable<string> pIgnore)
{
using (var stream = await pSource.OpenStreamForReadAsync())
{
await UnzipFromStream(stream, pDestinationFolder,pIgnore.ToList());
}
}
/// <summary>
/// Loads the WriteableBitmap asynchronously given the storage file and the dimensions.
/// </summary>
/// <param name="storageFile">The storage file.</param>
/// <param name="decodePixelWidth">Width in pixels of the decoded bitmap.</param>
/// <param name="decodePixelHeight">Height in pixels of the decoded bitmap.</param>
/// <returns></returns>
public static async Task<WriteableBitmap> LoadAsync(
StorageFile storageFile,
uint decodePixelWidth,
uint decodePixelHeight)
{
return await new WriteableBitmap(1, 1).LoadAsync(storageFile, decodePixelWidth, decodePixelHeight);
}
public async Task Save(StorageFile file)
{
var image = GetImage();
// Measure the extent of the image (which may be cropped).
Rect imageBounds;
using (var commandList = new CanvasCommandList(sourceBitmap.Device))
using (var drawingSession = commandList.CreateDrawingSession())
{
imageBounds = image.GetBounds(drawingSession);
}
// Rasterize the image into a rendertarget.
using (var renderTarget = new CanvasRenderTarget(sourceBitmap.Device, (float)imageBounds.Width, (float)imageBounds.Height, 96))
{
using (var drawingSession = renderTarget.CreateDrawingSession())
{
drawingSession.Blend = CanvasBlend.Copy;
drawingSession.DrawImage(image, -(float)imageBounds.X, -(float)imageBounds.Y);
}
// Save it out.
var format = file.FileType.Equals(".png", StringComparison.OrdinalIgnoreCase) ? CanvasBitmapFileFormat.Png : CanvasBitmapFileFormat.Jpeg;
using (var stream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
stream.Size = 0;
await renderTarget.SaveAsync(stream, format);
}
}
}
public async void LoadData(IEnumerable<XElement> sprites, StorageFile spriteSheetFile, string appExtensionId)
{
var bitmapImage = new BitmapImage();
using (var stream = await spriteSheetFile.OpenReadAsync()) {
await bitmapImage.SetSourceAsync(stream);
}
//xaml
List<ImageListItem> listOfImages = new List<ImageListItem>();
foreach (var sprite in sprites) {
var row = int.Parse(sprite.Attributes("Row").First().Value);
var col = int.Parse(sprite.Attributes("Column").First().Value);
var brush = new ImageBrush();
brush.ImageSource = bitmapImage;
brush.Stretch = Stretch.UniformToFill;
brush.AlignmentX = AlignmentX.Left;
brush.AlignmentY = AlignmentY.Top;
brush.Transform = new CompositeTransform() { ScaleX = 2.35, ScaleY = 2.35, TranslateX = col * (-140), TranslateY = row * (-87) };
listOfImages.Add(new ImageListItem() {
Title = sprite.Attributes("Title").First().Value,
SpriteSheetBrush = brush,
File = sprite.Attributes("File").First().Value,
AppExtensionId = appExtensionId
});
}
lbPictures.ItemsSource = listOfImages;
}
public async static Task<BitmapImage> GetImageAsync(StorageFile storageFile)
{
BitmapImage bitmapImage = new BitmapImage();
FileRandomAccessStream stream = (FileRandomAccessStream)await storageFile.OpenAsync(FileAccessMode.Read);
bitmapImage.SetSource(stream);
return bitmapImage;
}
public async void ProccesImage(StorageFile imageFile)
{
var data = await FileIO.ReadBufferAsync(imageFile);
// create a stream from the file
var ms = new InMemoryRandomAccessStream();
var dw = new DataWriter(ms);
dw.WriteBuffer(data);
await dw.StoreAsync();
ms.Seek(0);
// find out how big the image is, don't need this if you already know
var bm = new BitmapImage();
await bm.SetSourceAsync(ms);
// create a writable bitmap of the right size
var wb = new WriteableBitmap(bm.PixelWidth, bm.PixelHeight);
ms.Seek(0);
// load the writable bitpamp from the stream
await wb.SetSourceAsync(ms);
Bitmap bmp = (Bitmap)wb;
//var filter1 = Grayscale.CommonAlgorithms.BT709;
//bmp = filter1.Apply(bmp);
wb = (WriteableBitmap)bmp;
var file = await this.WriteableBitmapToStorageFile(wb, FileFormat.Jpeg);
}
private async void seleccionarImagen(object sender, RoutedEventArgs e)
{
FileOpenPicker picker = new FileOpenPicker();
picker.SuggestedStartLocation = PickerLocationId.PicturesLibrary;
picker.FileTypeFilter.Add(".png");
file = await picker.PickSingleFileAsync();
BitmapImage image = new BitmapImage();
try
{
using (var stream = await file.OpenAsync(FileAccessMode.Read))
{
await image.SetSourceAsync(stream);
}
ImageBrush brush = new ImageBrush();
brush.Stretch = Stretch.UniformToFill;
brush.ImageSource = image;
imagen.Fill = brush;
}
catch (Exception exception)
{
}
}
public async Task<RecipeBox> GetData()
{
if (await DoesFileExistAsync(FileName))
{
file = await ApplicationData.Current.LocalFolder.CreateFileAsync(FileName, CreationCollisionOption.OpenIfExists);
IInputStream sessionInputStream = await file.OpenReadAsync();
//Using DataContractSerializer , look at the cat-class
// var sessionSerializer = new DataContractSerializer(typeof(List<object>), new Type[] { typeof(T) });
//_data = (List<object>)sessionSerializer.ReadObject(sessionInputStream.AsStreamForRead());
var serializer = new XmlSerializer(typeof(RecipeBox));
var rb =(RecipeBox)serializer.Deserialize(sessionInputStream.AsStreamForRead());
sessionInputStream.Dispose();
return rb;
}
else
{
var rb = generateDefault();
return rb;
}
}
public static async Task<Color> GetDominantColorFromFile(StorageFile file)
{
//get the file
using (var stream = await file.OpenAsync(FileAccessMode.Read))
{
//Create a decoder for the image
var decoder = await BitmapDecoder.CreateAsync(stream);
//Create a transform to get a 1x1 image
var myTransform = new BitmapTransform { ScaledHeight = 1, ScaledWidth = 1 };
//Get the pixel provider
var pixels = await decoder.GetPixelDataAsync(
BitmapPixelFormat.Rgba8,
BitmapAlphaMode.Ignore,
myTransform,
ExifOrientationMode.IgnoreExifOrientation,
ColorManagementMode.DoNotColorManage);
//Get the bytes of the 1x1 scaled image
var bytes = pixels.DetachPixelData();
//read the color
var myDominantColor = Color.FromArgb(255, bytes[0], bytes[1], bytes[2]);
return myDominantColor;
}
}
private async Task DisplayStorageFileAsync(StorageFile storageFile)
{
var bitmapImage = new BitmapImage();
bitmapImage.SetSource(await _storageFile.OpenAsync(FileAccessMode.Read));
ImagePhoto.Source = bitmapImage;
}
private async void CreateFileClicked(object sender, Windows.UI.Xaml.RoutedEventArgs e)
{
StorageFolder storageFolder = ApplicationData.Current.LocalFolder;
this.sampleFile = await storageFolder.CreateFileAsync(
MainPage.fileName, CreationCollisionOption.ReplaceExisting);
StatusTextBlock.Text = "The file '" + sampleFile.Name + "' was created.";
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
PageData data = PageData.Instance();
if (data.MainPageStorageFile != null)
{
fileToEmbed = data.MainPageStorageFile;
fileNameTextBlock.Text = "Picked photo: " + fileToEmbed.Name;
}
int corner = data.MainPageRadioBox;
switch (corner)
{
case 1:
topRightButton.IsChecked = true;
break;
case 2:
bottomLeftButton.IsChecked = true;
break;
case 3:
bottomRightButton.IsChecked = true;
break;
case 4:
bottomLeftButton.IsChecked = true;
break;
}
AlignElements();
}
private async Task<BitmapImage> LoadImage(StorageFile file)
{
var image = new BitmapImage();
FileRandomAccessStream stream = (FileRandomAccessStream)await file.OpenAsync(FileAccessMode.Read);
image.SetSource(stream);
return image;
}
public static IFlightRawDataExtractor CreateFlightRawDataExtractor(StorageFile file, FlightParameters parameters)
{
if (file == null)
return null;
var readStreamTask = file.OpenStreamForReadAsync();
readStreamTask.Wait();
MemoryStream stream = new MemoryStream(102400);
byte[] bytes = new byte[readStreamTask.Result.Length];
readStreamTask.Result.Read(bytes, 0, Convert.ToInt32(readStreamTask.Result.Length));
stream.Write(bytes, 0, Convert.ToInt32(readStreamTask.Result.Length));
//Task temp1 = readStreamTask.AsTask();
//temp1.Wait();
//var temp2 = readStreamTask.GetResults();
BinaryReader reader = new BinaryReader(stream); //temp2.AsStreamForRead(1024000)); //readStreamTask.Result);
var handler = new FlightDataReadingHandler(reader);
//if (parameters != null)
//{
// handler.Definition = CreateDefinition(handler.Definition, parameters);
//}
return handler;
}
/// <summary>
/// Populates the page with content passed during navigation. Any saved state is also
/// provided when recreating a page from a prior session.
/// </summary>
/// <param name="navigationParameter">The parameter value passed to
/// <see cref="Frame.Navigate(Type, Object)"/> when this page was initially requested.
/// </param>
/// <param name="pageState">A dictionary of state preserved by this page during an earlier
/// session. This will be null the first time a page is visited.</param>
protected override async void LoadState(Object navigationParameter, Dictionary<String, Object> pageState)
{
IsEdit = false;
try
{
var item = (JournalItem)navigationParameter;
iTitle.Text = item.Title;
iDesc.Text = item.Description;
iGroupName.Text = item.Groups;
iBabyImage.Source = new BitmapImage(item.ImageUri);
IsEdit = true;
LastRecord = new JournalItem
{
ImageUri = item.ImageUri,
Title = item.Title,
Description = item.Description,
Groups = item.Groups,
};
string path = item.ImageUri.AbsolutePath;
ImageFile = await ApplicationData.Current.LocalFolder.CreateFileAsync(path.Substring(path.LastIndexOf("/") + 1), CreationCollisionOption.OpenIfExists);
LastImageFile = ImageFile;
}
catch (Exception) { }
}
private async void onClickSiguiente(object sender, RoutedEventArgs e)
{
this.nombre = nombrePlan.Text;
this.descripcion = descripcionPlan.Text;
this.fecha = fechaPlan.Date.Day + "/" + fechaPlan.Date.Month + "/" + fechaPlan.Date.Year;
this.hora = configurarHora(horaPlan.Time.Hours, horaPlan.Time.Minutes);
if (nombre.Equals("") && descripcion.Equals(""))
{
var dialog = new Windows.UI.Popups.MessageDialog("Por favor llene los campos");
dialog.Commands.Add(new Windows.UI.Popups.UICommand("OK") { Id = 0 });
var result = await dialog.ShowAsync();
}
else
{
if (photo == null)
{
var packageLocation = Windows.ApplicationModel.Package.Current.InstalledLocation;
var assetsFolder = await packageLocation.GetFolderAsync("Assets");
photo = await assetsFolder.GetFileAsync("fotoplan.jpg");
}
Plan plan = new Plan()
{
NombrePlan = nombre,
DescripcionPlan = descripcion,
FechaPlan = fecha,
HoraPlan = hora,
ImagenPlan = photo
};
Frame rootFrame = Window.Current.Content as Frame;
rootFrame.Navigate(typeof(AddMapa), plan);
}
}
public static async Task<List<ROI>> Load(StorageFile file)
{
// read content
var lines = await Windows.Storage.FileIO.ReadLinesAsync(file);
// Read in all the lines
//string[] lines = System.IO.File.ReadAllLines(_fullPath);
List<ROI> regionsOfInterest = new List<ROI>();
foreach (var line in lines)
{
var fields = line.Split('\t');
ROI roi = new ROI()
{
Index = Int32.Parse(fields[0]),
Name = fields[1],
Ident = Int32.Parse(fields[2]),
X = Double.Parse(fields[6]),
Y = Double.Parse(fields[7]),
Z = Double.Parse(fields[8]),
TX = Double.Parse(fields[10]),
TY = Double.Parse(fields[11]),
TZ = Double.Parse(fields[12]),
};
regionsOfInterest.Add(roi);
}
return regionsOfInterest;
}
public static async Task SaveToFile(
this WriteableBitmap writeableBitmap,
StorageFile outputFile,
Guid encoderId)
{
try
{
Stream stream = writeableBitmap.PixelBuffer.AsStream();
byte[] pixels = new byte[(uint)stream.Length];
await stream.ReadAsync(pixels, 0, pixels.Length);
using (var writeStream = await outputFile.OpenAsync(FileAccessMode.ReadWrite))
{
var encoder = await BitmapEncoder.CreateAsync(encoderId, writeStream);
encoder.SetPixelData(
BitmapPixelFormat.Bgra8,
BitmapAlphaMode.Premultiplied,
(uint)writeableBitmap.PixelWidth,
(uint)writeableBitmap.PixelHeight,
96,
96,
pixels);
await encoder.FlushAsync();
using (var outputStream = writeStream.GetOutputStreamAt(0))
{
await outputStream.FlushAsync();
}
}
}
catch (Exception ex)
{
string s = ex.ToString();
}
}
// Fetches all the data for the specified file
public async static Task<FileItem> fromStorageFile(StorageFile f, CancellationToken ct)
{
FileItem item = new FileItem();
item.Filename = f.DisplayName;
// Block to make sure we only have one request outstanding
await gettingFileProperties.WaitAsync();
BasicProperties bp = null;
try
{
bp = await f.GetBasicPropertiesAsync().AsTask(ct);
}
catch (Exception) { }
finally
{
gettingFileProperties.Release();
}
ct.ThrowIfCancellationRequested();
item.Size = (int)bp.Size;
item.Key = f.FolderRelativeId;
StorageItemThumbnail thumb = await f.GetThumbnailAsync(ThumbnailMode.SingleItem).AsTask(ct);
ct.ThrowIfCancellationRequested();
BitmapImage img = new BitmapImage();
await img.SetSourceAsync(thumb).AsTask(ct);
item.ImageData = img;
return item;
}
private async Task<Uri> SaveToFile(StorageFile file)
{
Uri uri = null;
if (inkCanvas.InkPresenter.StrokeContainer.GetStrokes().Count > 0)
{
try
{
using (IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
await inkCanvas.InkPresenter.StrokeContainer.SaveAsync(stream);
uri = new Uri("ms-appdata:///local/" + file.Name);
}
}
catch (Exception ex)
{
if (Debugger.IsAttached)
{
Debugger.Break();
}
}
}
return uri;
}
public PictureCropControl(StorageFile file, AspectRatio aspect = AspectRatio.Custom, CropSelectionSize cropsize = CropSelectionSize.Half)
{
this.InitializeComponent();
this.file = file;
this.aspect = aspect;
this.cropsize = cropsize;
}
public static async Task<WaveFile> Create(StorageFile file)
{
WaveFile w = new WaveFile();
await w.Initialize(file);
w.SmoothSamples(200);
return w;
}
async void ProcessPhotoAsync()
{
#if !UNITY_EDITOR
Windows.Storage.StorageFolder storageFolder = Windows.Storage.KnownFolders.CameraRoll;
Windows.Storage.StorageFile file = await storageFolder.GetFileAsync("terminator_analysis.jpg");
if (file != null)
{
Debug.Log("File exists!!");
}
else
{
Debug.Log("File does not exists!!");
}
//convert filestream to byte array
byte[] fileBytes;
using (var fileStream = await file.OpenStreamForReadAsync())
{
var binaryReader = new BinaryReader(fileStream);
fileBytes = binaryReader.ReadBytes((int)fileStream.Length);
}
HttpClient client = new HttpClient();
//Ip Address of the server running face recognition service
client.BaseAddress = new Uri("http://192.168.137.1:5000/");
MultipartFormDataContent form = new MultipartFormDataContent();
HttpContent content = new StringContent("file");
form.Add(content, "file");
var stream = await file.OpenStreamForReadAsync();
content = new StreamContent(stream);
content.Headers.ContentDisposition = new ContentDispositionHeaderValue("form-data")
{
Name = "file",
FileName = file.Name
};
form.Add(content);
String face = null;
try
{
var response = await client.PostAsync("facerec", form);
face = response.Content.ReadAsStringAsync().Result;
Debug.Log(response.Content.ReadAsStringAsync().Result);
Hello.text = response.Content.ReadAsStringAsync().Result;
}
catch (Exception e) {
Debug.Log(e);
}
//Hello.text = face;
#endif
}
public static async Task SendToBlobAsyncStream(Windows.Storage.StorageFile Photofile, Stream Source)
{
try
{
CreateClient();
await deviceClient.UploadToBlobAsync(Photofile.Name, Source);
}
catch (Exception ex)
{
var Exce = ex.Message;
}
}
public static async System.Threading.Tasks.Task <string> CacheFileAsync(string sourceFilePath)
{
string fileName = Path.GetFileName(sourceFilePath);
Windows.Storage.StorageFile sourceStorageFile = Crosstales.FB.FileBrowserWSAImpl.LastOpenFile;
Windows.Storage.StorageFolder cacheStorageFolder = Windows.Storage.ApplicationData.Current.LocalCacheFolder;
var cacheStorageFile =
await sourceStorageFile.CopyAsync(cacheStorageFolder, fileName, Windows.Storage.NameCollisionOption.ReplaceExisting);
string cacheFilePath = cacheStorageFile.Path;
return(cacheFilePath);
}
private async System.Threading.Tasks.Task <string> SaveImageFileAsync(string imageFileName, byte[] btImageContent, bool openIt)
{
Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
Windows.Storage.StorageFile imageFile = await storageFolder.CreateFileAsync(imageFileName,
Windows.Storage.CreationCollisionOption.ReplaceExisting);
await Windows.Storage.FileIO.WriteBytesAsync(imageFile, btImageContent);
if (openIt)
{
await Windows.System.Launcher.LaunchFileAsync(imageFile);
}
return(imageFile.Path);
}
private async Task <IReadOnlyList <StorageFile> > OpenDir()
{
FolderPicker p = new FolderPicker();
p.FileTypeFilter.Add(".jpg");
p.FileTypeFilter.Add(".png");
StorageFolder folder = await p.PickSingleFolderAsync();
_folder = folder;
Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
Windows.Storage.StorageFile sampleFile = await folder.CreateFileAsync("sample.txt", Windows.Storage.CreationCollisionOption.ReplaceExisting);
IReadOnlyList <StorageFile> fileList = await folder.GetFilesAsync();
return(fileList);
}
private async void CopyFile_OnClick(object sender, RoutedEventArgs e)
{
if (listBox.SelectedItem == null)
{
return;
}
ListBoxItem item = (ListBoxItem)listBox.SelectedItem;
if (item.Tag is Windows.Storage.StorageFile)
{
Windows.Storage.StorageFile file = (Windows.Storage.StorageFile)item.Tag;
await file.CopyAsync(currentFolder, fileName.Text);
}
ScanDir(currentFolder);
}
private async void Menu_Open_Click(object sender, RoutedEventArgs e)
{
var picker = new Windows.Storage.Pickers.FileOpenPicker();
picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.List;
picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.Desktop;
picker.FileTypeFilter.Add(".txt");
Windows.Storage.StorageFile file = await picker.PickSingleFileAsync();
if (file != null)
{
strBackup = null;
TextBox1.Text = await Windows.Storage.FileIO.ReadTextAsync(file);
}
}
private async void LoadText(object sender, RoutedEventArgs e)
{
// Create sample file; replace if exists.
Windows.Storage.StorageFolder storageFolder =
Windows.Storage.ApplicationData.Current.LocalFolder;
Windows.Storage.StorageFile sampleFile =
await storageFolder.CreateFileAsync("sample.Params",
Windows.Storage.CreationCollisionOption.ReplaceExisting);
await Windows.Storage.FileIO.WriteTextAsync(sampleFile, "Swift as a shadow");
var file = storageFolder.GetFileAsync("sample.Params");
string text = await Windows.Storage.FileIO.ReadTextAsync(sampleFile);
Debug.Write(file.Id);
}
/* This method is used for getting existing images from phone.
* It works like a charm, ofcourse it is asynchronous because there can
* be a load time and we don't want to freeze the rest of the application
*/
public static async Task <StorageFile> ExistingPhotosLibrary()
{
var picker = new Windows.Storage.Pickers.FileOpenPicker
{
ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail,
SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.PicturesLibrary
};
picker.FileTypeFilter.Add(".jpg");
picker.FileTypeFilter.Add(".jpeg");
picker.FileTypeFilter.Add(".png");
Windows.Storage.StorageFile file = await picker.PickSingleFileAsync();
return(file);
}
private async void button_Click(object sender, RoutedEventArgs e)
{
var picker = new Windows.Storage.Pickers.FileOpenPicker();
picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail;
picker.SuggestedStartLocation =
Windows.Storage.Pickers.PickerLocationId.PicturesLibrary;
picker.FileTypeFilter.Add("*");
Windows.Storage.StorageFile file = await picker.PickSingleFileAsync();
if (file != null)
{
Uri uri = new Uri(uploadURL);
UploadSingleFile(uri, file);
}
}
//https://docs.microsoft.com/en-us/windows/uwp/files/quickstart-reading-and-writing-files
private async void Save_Button_Tapped(object sender, TappedRoutedEventArgs e)
{
// Create sample file; replace if exists.
Windows.Storage.StorageFolder storageFolder =
Windows.Storage.ApplicationData.Current.LocalFolder;
Windows.Storage.StorageFile my_Saved_File = await storageFolder.CreateFileAsync("Song.txt", Windows.Storage.CreationCollisionOption.ReplaceExisting);
using (IRandomAccessStream iRandomAccessStream = await my_Saved_File.OpenAsync(FileAccessMode.ReadWrite))
{
using (DataWriter writer = new DataWriter(iRandomAccessStream))
{
writer.WriteString(Song_Name.Text);
await writer.StoreAsync();
}
}
}
public async Task <StorageFile> LoadFileAsync()
{
var picker = new Windows.Storage.Pickers.FileOpenPicker
{
ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail,
SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.PicturesLibrary
};
picker.FileTypeFilter.Add(".rtf");
picker.FileTypeFilter.Add(".txt");
Windows.Storage.StorageFile file = await picker.PickSingleFileAsync();
fileFromLastOperation = file;
return(file);
}
private async Task createFile()
{
// Create sample file; replace if exists.
FolderPicker p = new FolderPicker();
p.FileTypeFilter.Add(".jpg");
p.FileTypeFilter.Add(".png");
StorageFolder folder = await p.PickSingleFolderAsync();
_folder = folder;
Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
Windows.Storage.StorageFile sampleFile = await folder.CreateFileAsync("sample.txt", Windows.Storage.CreationCollisionOption.ReplaceExisting);
Debug.Write("" + storageFolder.Path);
}
public async void LogExceptions(string exception)
{
try
{
string msg = exception + Environment.NewLine;
// msg = Environment.NewLine + msg + Environment.NewLine;
string filename = "Exceptionlogs.txt";
var localFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
Windows.Storage.StorageFile pinfofile = await localFolder.CreateFileAsync(filename, CreationCollisionOption.OpenIfExists);
// await Windows.Storage.FileIO.AppendTextAsync(pinfofile, msg, Windows.Storage.Streams.UnicodeEncoding.Utf8);
await Windows.Storage.FileIO.WriteTextAsync(pinfofile, msg, Windows.Storage.Streams.UnicodeEncoding.Utf8);
}
catch (Exception)
{ }
}
private async void Load_Settings()
{
try
{
Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
Windows.Storage.StorageFile sampleFile = await storageFolder.GetFileAsync("settings.xml");
string text = await Windows.Storage.FileIO.ReadTextAsync(sampleFile);
text = text.Substring(text.IndexOf("UserToken:") + 10);
user_token = text.Substring(0, text.IndexOf(";"));
}catch (Exception)
{
user_token = "400000000";
}
}
private async void AppBarButton_Click(object sender, RoutedEventArgs e)
{
//Inicializamos la cámara.
CameraCaptureUI cameraUI = new CameraCaptureUI();
//Hacemos una foto a través del botón
Windows.Storage.StorageFile capturedMedia =
await cameraUI.CaptureFileAsync(CameraCaptureUIMode.Photo);
//Si se ha realizado una foto, la colocamos contiguamente del icono de la cámara.
if (capturedMedia != null)
{
string rutaFoto = capturedMedia.Path;
foto.Source = new BitmapImage(new Uri(rutaFoto));
}
}
async void PlayFile(Windows.Storage.StorageFile MediaFile)
{
await _dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async() =>
{
try
{
Windows.Storage.Streams.IRandomAccessStream stream = await MediaFile.OpenAsync(FileAccessMode.Read);
OutputVideo.SetSource(stream, MediaFile.ContentType);
OutputVideo.Play();
}
catch (Exception exception)
{
TranscodeError(exception.Message);
}
});
}
public async Task GetWebPages()
{
Windows.Storage.StorageFile pdfFile = await Windows.Storage.ApplicationData.Current.LocalFolder.GetFileAsync("windows-pdf.pdf");
_pdfDocument = await PdfDocument.LoadFromFileAsync(pdfFile);
var _Pages = new List <FrameworkElement>();
if (_pdfDocument != null && _pdfDocument.PageCount > 0)
{
for (uint pageNum = 0; pageNum < _pdfDocument.PageCount; pageNum++)
{
var pdfPage = _pdfDocument.GetPage(pageNum);
Grid _Page = new Grid();
var image = new Image
{
Height = pdfPage.Size.Height,
Width = pdfPage.Size.Width,
Stretch = Stretch.Fill,
HorizontalAlignment = HorizontalAlignment.Center,
VerticalAlignment = VerticalAlignment.Center
};
_Page.Children.Add(image);
if (pdfPage != null)
{
StorageFolder tempFolder = ApplicationData.Current.TemporaryFolder;
StorageFile imgFile = await tempFolder.CreateFileAsync(Guid.NewGuid().ToString() + ".png", CreationCollisionOption.ReplaceExisting);
if (imgFile != null)
{
using (IRandomAccessStream randomStream = await imgFile.OpenAsync(FileAccessMode.ReadWrite))
{
await pdfPage.RenderToStreamAsync(randomStream);
await randomStream.FlushAsync();
BitmapImage src = new BitmapImage();
src.SetSource(randomStream);
image.Source = src;
}
_Pages.Add(_Page);
}
}
}
}
Pages = _Pages;
}
private async void SaveNewRekviziti5_Click(object sender, RoutedEventArgs e)
{
var savePicker4 = new Windows.Storage.Pickers.FileSavePicker();
savePicker4.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.DocumentsLibrary;
// Поле выбора типа файла в диалоге
savePicker4.FileTypeChoices.Add("Документ", new List <string>()
{
".rekv"
});
// Default file name if the user does not type one in or select a file to replace
savePicker4.SuggestedFileName = "Реквизиты новой организации";
//
Windows.Storage.StorageFile Myfile4 = await savePicker4.PickSaveFileAsync();
if (Myfile4 != null)
{
// Prevent updates to the remote version of the file until
// we finish making changes and call CompleteUpdatesAsync.
Windows.Storage.CachedFileManager.DeferUpdates(Myfile4);
// write to file
//await Windows.Storage.FileIO.WriteTextAsync(file, file.Name); //запись в файл имени
await FileIO.WriteTextAsync(Myfile4, TextBoxFullNameKontr5.Text + ";" + TextBoxSokrNameKontr5.Text + ";" + TextBoxINN5.Text + ";" + TextBoxKPP5.Text + ";" + TextBoxOGRN5.Text + ";" + TextBoxBankRekv5.Text + ";" + TextBoxDolzhnostDirector5.Text + ";" +
TextBoxVlice5.Text + ";" + TextBoxRukSokr5.Text + ";" + TextBoxUrAddr5.Text + ";" + TextBoxFactAddr5.Text + ";" + TextBoxPhone5.Text + ";" + TextBoxMobile5.Text + ";" + TextBoxEmail5.Text + ";" + TextBoxSajt5.Text + ";");
// Let Windows know that we're finished changing the file so
// the other app can update the remote version of the file.
// Completing updates may require Windows to ask for user input.
Windows.Storage.Provider.FileUpdateStatus status =
await Windows.Storage.CachedFileManager.CompleteUpdatesAsync(Myfile4);
if (status == Windows.Storage.Provider.FileUpdateStatus.Complete)
{
this.TextBlockStatusFile5.Text = "Файл реквизитов " + Myfile4.Name + " успешно сохранен.";
}
else
{
this.TextBlockStatusFile5.Text = "Не удалось сохранить файл реквизитов " + Myfile4.Name + ".";
}
}
else
{
this.TextBlockStatusFile5.Text = "Операция записи файла реквизитов была прервана.";
}
}
private async void SaveChartToPngFile(object sender, RoutedEventArgs e)
{
RenderTargetBitmap rtb = new RenderTargetBitmap();
await rtb.RenderAsync(LineChart);
var pixelBuffer = await rtb.GetPixelsAsync();
var pixels = pixelBuffer.ToArray();
var displayInformation = DisplayInformation.GetForCurrentView();
var savePicker = new Windows.Storage.Pickers.FileSavePicker();
savePicker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.DocumentsLibrary;
savePicker.FileTypeChoices.Add("PNG Bitmap", new List <string>()
{
".png"
});
Windows.Storage.StorageFile file = await savePicker.PickSaveFileAsync();
if (file != null)
{
Windows.Storage.CachedFileManager.DeferUpdates(file);
await Windows.Storage.FileIO.WriteTextAsync(file, file.Name);
Windows.Storage.Provider.FileUpdateStatus status = await Windows.Storage.CachedFileManager.CompleteUpdatesAsync(file);
if (status == Windows.Storage.Provider.FileUpdateStatus.Complete)
{
using (var stream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
var encoder = await Windows.Graphics.Imaging.BitmapEncoder.CreateAsync(Windows.Graphics.Imaging.BitmapEncoder.PngEncoderId, stream);
encoder.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied, (uint)rtb.PixelWidth, (uint)rtb.PixelHeight, displayInformation.RawDpiX, displayInformation.RawDpiY, pixels);
await encoder.FlushAsync();
}
this.viewModel2.Status = "Wykres zapisano";
}
else
{
this.viewModel2.Status = "Wykres niezapisano";
}
}
else
{
return;
}
}
async void MakeGif()
{
List <IImageProvider> imageSourceList = new List <IImageProvider>();
// add image sources to define sequence of GIF frames
for (int i = 0; i < this.bitmapFrames.Length; ++i)
{
SoftwareBitmap softwareBitmap = this.bitmapFrames[i];
if (softwareBitmap != null)
{
SoftwareBitmapImageSource imageSource = new SoftwareBitmapImageSource(softwareBitmap);
imageSourceList.Add(imageSource);
}
}
// use lumia imaging SDK component to create animated GIF image
GifRenderer gifRenderer = new GifRenderer(imageSourceList);
gifRenderer.Duration = 100; // time for each frame in ms
gifRenderer.NumberOfAnimationLoops = 200; // loop continuosly
gifRenderer.ApplyDithering = false;
Windows.Storage.Streams.IBuffer gifBuffer = await gifRenderer.RenderAsync();
// show animated gif in xaml preview area
BitmapImage animBitmap = new BitmapImage();
await animBitmap.SetSourceAsync(gifBuffer.AsStream().AsRandomAccessStream());
// set preview animated gif
this.imageAnimPreview.Source = animBitmap;
bool saveImage = true;
if (saveImage)
{
// write animated gif image to file
string timeString = DateTime.Now.ToString("yyyyMMdd-HHmm_ss");
string filename = $"PhotoBooth_{timeString}.gif";
Windows.Storage.StorageFile storageFile = await Windows.Storage.KnownFolders.SavedPictures.CreateFileAsync(filename, Windows.Storage.CreationCollisionOption.ReplaceExisting);
using (var stream = await storageFile.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite))
{
await stream.WriteAsync(gifBuffer);
}
}
}
private async Task <FaceRectangle> UploadAndDetectFaces(String imageFilePath)
{
try
{
Windows.Storage.StorageFolder storageFolder = await StorageFolder.GetFolderFromPathAsync(System.IO.Path.GetDirectoryName(imageFilePath));
Windows.Storage.StorageFile sampleFile = await storageFolder.GetFileAsync(System.IO.Path.GetFileName(imageFilePath));
var inputStream = await sampleFile.OpenReadAsync();
Stream stream = inputStream.AsStreamForRead();
var faces = await faceServiceClient.DetectAsync(stream);
var faceRects = faces.Select(face => face.FaceRectangle);
var faceIds = faces.Select(face => face.FaceId).ToArray();
var results = await faceServiceClient.IdentifyAsync(personGroupId, faceIds);
for (int j = 0; j < results.Length; j++)
{
Debug.WriteLine("Result of face: {0}", results[j].FaceId);
if (results[j].Candidates.Length == 0)
{
Debug.WriteLine("No one identified");
}
else
{
var candidateId = results[j].Candidates[0].PersonId;
var person = await faceServiceClient.GetPersonAsync(personGroupId, candidateId);
Debug.WriteLine("Identified as {0}", person.Name);
if (person.Name == "person1")
{
FaceRectangle rectID;
return(rectID = faces[j].FaceRectangle);
}
}
}
}
catch (Microsoft.ProjectOxford.Face.FaceAPIException exc)
{
Debug.WriteLine(exc.ErrorCode);
}
return(null);
}
/// <summary>
/// Outputs the changes to online db.
/// </summary>
/// <returns></returns>
public static async Task OutputChanges()
{
MySqlConnection dbConnection = DbConnection.getConnection();
Windows.Storage.StorageFolder storageFolder =
Windows.Storage.ApplicationData.Current.LocalFolder;
Windows.Storage.StorageFile file =
await storageFolder.GetFileAsync("Changelog.txt");
IList <string> data = await FileIO.ReadLinesAsync(file);
List <string> queries = data.ToList();
foreach (var queryItem in queries)
{
using (dbConnection)
{
try
{
dbConnection.Open();
var query = dbConnection.CreateCommand();
query.CommandText = queryItem;
query.ExecuteReader();
dbConnection.Close();
}
catch (MySqlException)
{
break;
}
}
}
using (dbConnection)
{
try
{
dbConnection.Open();
await file.DeleteAsync(StorageDeleteOption.Default);
DataAccess.InitializeDatabase();
dbConnection.Close();
}
catch (Exception)
{
}
}
}
public static async Task <StorageFile> CreateMediaFile(string filename)
{
var savePicker = new Windows.Storage.Pickers.FileSavePicker();
savePicker.SuggestedStartLocation =
Windows.Storage.Pickers.PickerLocationId.DocumentsLibrary;
// Dropdown of file types the user can save the file as
savePicker.FileTypeChoices.Add("Photo", new List <string>()
{
".jpg"
});
// Default file name if the user does not type one in or select a file to replace
savePicker.SuggestedFileName = filename;
Windows.Storage.StorageFile file = await savePicker.PickSaveFileAsync();
if (file != null)
{
return(file);
//// Prevent updates to the remote version of the file until
//// we finish making changes and call CompleteUpdatesAsync.
//Windows.Storage.CachedFileManager.DeferUpdates(file);
//// write to file
//await Windows.Storage.FileIO.WriteTextAsync(file, file.Name);
//// Let Windows know that we're finished changing the file so
//// the other app can update the remote version of the file.
//// Completing updates may require Windows to ask for user input.
//Windows.Storage.Provider.FileUpdateStatus status =
// await Windows.Storage.CachedFileManager.CompleteUpdatesAsync(file);
//if (status == Windows.Storage.Provider.FileUpdateStatus.Complete)
//{
// this.textBlock.Text = "File " + file.Name + " was saved.";
//}
//else
//{
// this.textBlock.Text = "File " + file.Name + " couldn't be saved.";
//}
}
else
{
return(null);
//this.textBlock.Text = "Operation cancelled.";
}
//StorageFolder _mediaFolder = KnownFolders.PicturesLibrary;
//return await _mediaFolder.CreateFileAsync(filename);
}
//Enrollment audio requirements
//https://westus.dev.cognitive.microsoft.com/docs/services/563309b6778daf02acc0a508/operations/5645c3271984551c84ec6797
private async void enrollBtn_Click(object sender, RoutedEventArgs e)
{
var picker = new Windows.Storage.Pickers.FileOpenPicker();
picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail;
picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.Downloads;
picker.FileTypeFilter.Add(".wav");
Windows.Storage.StorageFile file = await picker.PickSingleFileAsync();
if (file != null)
{
// Application now has read/write access to the picked file
txtBoxOutput.Text = "Picked: " + file.Name;
}
else
{
//User has cancelled operation
return;
}
//Convert to stream
var audioStream = await file.OpenStreamForReadAsync();
Guid speakerId = new Guid(txtBoxGuid.Text.ToString());
try
{
Enrollment response = await voiceServiceClient.EnrollAsync(audioStream, speakerId);
if (response.EnrollmentStatus == Microsoft.ProjectOxford.SpeakerRecognition.Contract.EnrollmentStatus.Enrolled)
{
// enrollment successful
LogMessage($"Enrolled.");
}
if (response.EnrollmentStatus == Microsoft.ProjectOxford.SpeakerRecognition.Contract.EnrollmentStatus.Enrolling)
{
// enrollment successful
LogMessage($"Enrolling.");
}
}
catch (Exception error)
{
LogMessage($"{error.Message}");
}
}
private async void AppBarButton_Click(object sender, RoutedEventArgs e)
{
var picker = new Windows.Storage.Pickers.FileOpenPicker();
picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail;
picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.PicturesLibrary;
picker.FileTypeFilter.Add(".txt");
picker.FileTypeFilter.Add(".dat");
picker.FileTypeFilter.Add(".rtf");
Windows.Storage.StorageFile file = await picker.PickSingleFileAsync();
if (file != null)
{
// Application now has read/write access to the picked file
this.nameFile.Text = "Имя файла: " + file.Name;
char[] rowSplitter = { '\r', '\n' };
string[] text = (await Windows.Storage.FileIO.ReadTextAsync(file)).Split(rowSplitter, StringSplitOptions.RemoveEmptyEntries);
for (int i = 0; i < text.Length; i++)
{
string[] text1 = text[i].Split('\t');
try
{
if (text1[3] == String.Empty || text1[3] == null || text1[4] == String.Empty || text1[4] == null || text1[1].Split('_')[1] == "Test")
{
}
else
{
DataColecF.Add(new ClassFileLT()
{
nomer = Convert.ToInt32(text1[0]), nameFile = text1[1], TimeOpen = text1[3], TimeClose = text1[4], nameRun = text1[5]
});
}
}
catch (Exception ex)
{
MessageDialog messageDialog = new MessageDialog(ex.ToString());
await messageDialog.ShowAsync();
}
}
}
else
{
this.nameFile.Text = "Файл не выбран";
}
}
private async void Button_Click_5(object sender, RoutedEventArgs e)
{
var picker = new Windows.Storage.Pickers.FileOpenPicker();
picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.List;
picker.FileTypeFilter.Add(".xml");
Windows.Storage.StorageFile file = await picker.PickSingleFileAsync();
var stream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read);
XmlSerializer serializer = new XmlSerializer(typeof(List <personer>));
StreamReader reader = new StreamReader(stream.AsStream());
var input = serializer.Deserialize(reader);
ListView.ItemsSource = input;
}
/*
* Este método busca el archivo en la carpeta de Assets, de no encontrarlo lanza una excepción de tipo 'FileNotFoundException'
* @param nombreArchivoParaBuscar Es el nombre del archivo a buscar
* @return Windows.Storage.StorageFile Regresa una variable que contiene el archivo listo para ser leído, e de tipo
*/
private async System.Threading.Tasks.Task <Windows.Storage.StorageFile> BuscarArchivoAsync(string nombreArchivoParaBuscar)
{
Windows.Storage.StorageFile formulario;
try
{
formulario = await Windows.ApplicationModel.Package.Current.InstalledLocation.GetFileAsync(@"Assets\" + nombreArchivoParaBuscar);
}
catch (FileNotFoundException)
{
Windows.Storage.StorageFile bitacora = await Windows.ApplicationModel.Package.Current.InstalledLocation.GetFileAsync(@"Assets\bitacoraErrores.txt");
await Windows.Storage.FileIO.AppendTextAsync(bitacora, "\nNo se halló el directorio: " + nombreArchivoParaBuscar + ", fecha: " + new DateTime());
throw new FileNotFoundException("No se halló la fórmula necesaría");
}
return(formulario);
}
public async Task PickAndSetWallpaper()
{
var picker = new Windows.Storage.Pickers.FileOpenPicker();
picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail;
picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.PicturesLibrary;
picker.FileTypeFilter.Add(".jpg");
picker.FileTypeFilter.Add(".jpeg");
picker.FileTypeFilter.Add(".png");
Windows.Storage.StorageFile file = await picker.PickSingleFileAsync();
if (file != null)
{
await SetAsAsync(image : file);
}
}
private async void Save_Click(object sender, RoutedEventArgs e)
{
var savePicker = new Windows.Storage.Pickers.FileSavePicker();
savePicker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.DocumentsLibrary;
savePicker.FileTypeChoices.Add("Plain Text", new List <String>()
{
".txt"
});
savePicker.SuggestedFileName = selected.file.Name;
Windows.Storage.StorageFile file = await savePicker.PickSaveFileAsync();
if (file != null)
{
await selected.file.CopyAndReplaceAsync(file);
}
}
public async Task WriteDataToFileAsync(StorageFile file, byte[] data)
{
using (var s = await file.OpenStreamForWriteAsync())
{
await s.WriteAsync(data, 0, data.Length);
}
}
