|
public GetBasicPropertiesAsync ( ) : IAsyncOperation |
||
| return | IAsyncOperation |
|
// 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 void SetDetails(StorageFile file)
{
var data = await file.GetBasicPropertiesAsync();
_fileName = file.Name;
_saveTime = data.DateModified.LocalDateTime;
TxtDate.Text = _saveTime.ToString("dd/MM/yyyy HH:mm");
TxtSize.Text = Utilities.SizeSuffix((long) data.Size);
}
private static async Task MergeFileIntoNote(StorageFile file, Note note)
{
note.DateCreated = file.DateCreated.LocalDateTime;
BasicProperties properties = await file.GetBasicPropertiesAsync();
note.DateModified = properties.DateModified.LocalDateTime;
note.Name = file.Name;
note.Text = await FileIO.ReadTextAsync(file);
note.MarkAsClean();
}
public static async Task<PhotoCapturedData> CreatePhotoCapturedDataAsync(StorageFile imageFile, string categoryName)
{
var photoData = new PhotoCapturedData(categoryName);
photoData.ImageFile = imageFile;
photoData.ImageFileSize = (await imageFile.GetBasicPropertiesAsync()).Size;
return photoData;
}
protected async Task <string> fileNotFound()
{
Windows.Storage.StorageFile htmlErrorFile = await rootDirectory.GetFileAsync("404.html");
var properties = await htmlErrorFile.GetBasicPropertiesAsync();
string htmlErrorPage = "HTTP/1.0 404 Not Found\r\n" +
"Content-Lenght:" + properties.Size + "\r\n" +
"Content-type: text/html\r\n" +
"Connection: Close\r\n\r\n";
htmlErrorPage += await Windows.Storage.FileIO.ReadTextAsync(htmlErrorFile);
return(htmlErrorPage);
}
protected async Task <string> getFileFormattedHtml(string fileRequested)
{
Windows.Storage.StorageFile htmlPageRequested = await rootDirectory.GetFileAsync(fileRequested);
var properties = await htmlPageRequested.GetBasicPropertiesAsync();
string htmlPage = "HTTP/1.0 200 OK\r\n" +
"Content-Lenght:" + properties.Size + "\r\n" +
"Content-type: text/html\r\n" +
"Connection: Close\r\n\r\n";
htmlPage += await Windows.Storage.FileIO.ReadTextAsync(htmlPageRequested);
return(htmlPage);
}
/// <summary>
/// Ottiene la data di ultima modifica del file IN LOCALE
/// </summary>
/// <param name="filename">nome del file</param>
/// <returns>La data di modifica</returns>
public static async Task <DateTime> getLastUpdatedDate(string filename)
{
try
{
Windows.Storage.StorageFile tsaved = await Windows.Storage.ApplicationData.Current.LocalFolder.GetFileAsync(filename);
Windows.Storage.FileProperties.BasicProperties prop = await tsaved.GetBasicPropertiesAsync();
return(prop.DateModified.DateTime);
}
catch (Exception)
{
return(new DateTime());
}
}
internal async Task<MediaMetadata> GetMetadata(StorageFile targetFile)
{
if (targetFile == null) return null;
var fileMetaData = new MediaMetadata();
try
{
fileMetaData.ReferenceUrl = targetFile.Path.StartsWith(WindowsPhoneUtils.DocumentsFolder.Path) ? targetFile.Path.Replace(WindowsPhoneUtils.DocumentsFolder.Path, String.Empty) : String.Empty;
fileMetaData.Size = (long)(await targetFile.GetBasicPropertiesAsync()).Size;
fileMetaData.MimeType = targetFile.ContentType;
fileMetaData.Type = MediaType.NotSupported;
if (targetFile.ContentType.Contains("audio/"))
{
var musicProperties = await targetFile.Properties.GetMusicPropertiesAsync();
fileMetaData.Album = musicProperties.Album;
fileMetaData.Artist = musicProperties.Artist;
fileMetaData.Category = musicProperties.Genre.Aggregate(new StringBuilder(), (sb, a) => sb.Append(String.Join(",", a)), sb => sb.ToString());
fileMetaData.Duration = (long)musicProperties.Duration.TotalSeconds;
fileMetaData.Title = musicProperties.Title;
fileMetaData.Type = MediaType.Audio;
}
else if (targetFile.ContentType.Contains("video/"))
{
var videoProperties = await targetFile.Properties.GetVideoPropertiesAsync();
fileMetaData.Duration = (long)videoProperties.Duration.TotalSeconds;
fileMetaData.Artist = videoProperties.Directors.Aggregate(new StringBuilder(), (sb, a) => sb.Append(String.Join(",", a)), sb => sb.ToString());
fileMetaData.Title = videoProperties.Title;
fileMetaData.Category = videoProperties.Keywords.Aggregate(new StringBuilder(), (sb, a) => sb.Append(String.Join(",", a)), sb => sb.ToString());
fileMetaData.Type = MediaType.Video;
}
else if (targetFile.ContentType.Contains("image/"))
{
var imgProperties = await targetFile.Properties.GetImagePropertiesAsync();
fileMetaData.Title = imgProperties.Title;
fileMetaData.Category = imgProperties.Keywords.Aggregate(new StringBuilder(), (sb, a) => sb.Append(String.Join(",", a)), sb => sb.ToString());
fileMetaData.Type = MediaType.Photo;
}
return fileMetaData;
}
catch (Exception ex)
{
WindowsPhoneUtils.Log(ex.Message);
return null;
}
}
/// <summary>
/// Restituisce true se c'è abbastanza spazio nel folder per salvare il filesize
/// </summary>
public static async Task<bool> isThereFreeSpace(StorageFile file, StorageFolder folder)
{
BasicProperties bp = await file.GetBasicPropertiesAsync();
ulong filesize = bp.Size;
var retrivedProperties = await folder.Properties.RetrievePropertiesAsync(new string[] { "System.FreeSpace" });
ulong sizefree = (ulong)retrivedProperties["System.FreeSpace"];
if(filesize<sizefree)
{
return true;
}
else
{
return false;
}
}
private async Task<bool> Initialize(StorageFile file)
{
BinaryReader reader = new BinaryReader((await file.OpenAsync(FileAccessMode.Read)).AsStreamForRead());
int chunkID = reader.ReadInt32();
int fileSize = reader.ReadInt32() + 8;
int riffType = reader.ReadInt32();
int fmtID = reader.ReadInt32();
int fmtSize = reader.ReadInt32();
int fmtCode = reader.ReadInt16();
int channels = reader.ReadInt16();
int sampleRate = reader.ReadInt32();
int fmtAvgBPS = reader.ReadInt32();
int fmtBlockAlign = reader.ReadInt16();
int bitDepth = reader.ReadInt16();
if (fmtSize == 18)
{
// Read any extra values
int fmtExtraSize = reader.ReadInt16();
reader.ReadBytes(fmtExtraSize);
}
int dataID = reader.ReadInt32();
int dataSize = reader.ReadInt32();
Windows.Storage.FileProperties.BasicProperties basicProperties = await file.GetBasicPropertiesAsync();
System.Diagnostics.Debug.Assert(fileSize == (int)basicProperties.Size);
Debug.Assert(fmtSize == 16);
Debug.Assert(channels == 1);
while (reader.BaseStream.Position != reader.BaseStream.Length)
{
Samples.Add(reader.ReadInt16() / Math.Pow(2.0, 15.0));
}
return true;
}
private async Task SendFileAsync(String url, StorageFile sFile, HttpMethod httpMethod)
{
//Log data for upload attempt
Windows.Storage.FileProperties.BasicProperties fileProperties = await sFile.GetBasicPropertiesAsync();
Dictionary<string, string> properties = new Dictionary<string, string> { { "File Size", fileProperties.Size.ToString() } };
App.Controller.TelemetryClient.TrackEvent("OneDrive picture upload attempt", properties);
HttpStreamContent streamContent = null;
try
{
//Open file to send as stream
Stream stream = await sFile.OpenStreamForReadAsync();
streamContent = new HttpStreamContent(stream.AsInputStream());
Debug.WriteLine("SendFileAsync() - sending: " + sFile.Path);
}
catch (FileNotFoundException ex)
{
Debug.WriteLine(ex.Message);
// Log telemetry event about this exception
var events = new Dictionary<string, string> { { "OneDrive", ex.Message } };
App.Controller.TelemetryClient.TrackEvent("FailedToOpenFile", events);
}
catch (Exception ex)
{
// Log telemetry event about this exception
var events = new Dictionary<string, string> { { "OneDrive", ex.Message } };
App.Controller.TelemetryClient.TrackEvent("FailedToOpenFile", events);
throw new Exception("SendFileAsync() - Cannot open file. Err= " + ex.Message);
}
if (streamContent == null)
{
//Throw exception if stream is not created
Debug.WriteLine(" File Path = " + (sFile != null ? sFile.Path : "?"));
throw new Exception("SendFileAsync() - Cannot open file.");
}
try
{
Uri resourceAddress = new Uri(url);
//Create requst to upload file
using (HttpRequestMessage request = new HttpRequestMessage(httpMethod, resourceAddress))
{
request.Content = streamContent;
// Do an asynchronous POST.
using (HttpResponseMessage response = await httpClient.SendRequestAsync(request).AsTask(cts.Token))
{
await DebugTextResultAsync(response);
if (response.StatusCode != HttpStatusCode.Created)
{
throw new Exception("SendFileAsync() - " + response.StatusCode);
}
}
}
}
catch (TaskCanceledException ex)
{
// Log telemetry event about this exception
var events = new Dictionary<string, string> { { "OneDrive", ex.Message } };
App.Controller.TelemetryClient.TrackEvent("CancelledFileUpload", events);
throw new Exception("SendFileAsync() - " + ex.Message);
}
catch (Exception ex)
{
// This failure will already be logged in telemetry in the enclosing UploadPictures function. We don't want this to be recorded twice.
throw new Exception("SendFileAsync() - Error: " + ex.Message);
}
finally
{
streamContent.Dispose();
Debug.WriteLine("SendFileAsync() - final.");
}
App.Controller.TelemetryClient.TrackEvent("OneDrive picture upload success", properties);
}
/// <summary>
/// Displays an image file in the 'ScenarioOutputImage' element.
/// </summary>
/// <param name="imageFile">The image file to display.</param>
async private Task DisplayImageAsync(StorageFile imageFile)
{
var imageProperties = await imageFile.GetBasicPropertiesAsync();
if (imageProperties.Size > 0)
{
rootPage.NotifyUser("Displaying: " + imageFile.Name + ", date modified: " + imageProperties.DateModified + ", size: " + imageProperties.Size + " bytes", NotifyType.StatusMessage);
var stream = await imageFile.OpenAsync(FileAccessMode.Read);
// BitmapImage.SetSource needs to be called in the UI thread
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
var bitmap = new BitmapImage();
bitmap.SetSource(stream);
ScenarioOutputImage.SetValue(Image.SourceProperty, bitmap);
});
}
else
{
rootPage.NotifyUser("Cannot display " + imageFile.Name + " because its size is 0", NotifyType.ErrorMessage);
}
}
public static async Task<SettingsFlyout> CreatePropertiesFlyout(StorageFile file, StorageFolder topFolder, string fileSubPath)
{
if (file == null) return null;
SettingsFlyout flyout = null;
try
{
BasicProperties basicProps = null;
try { basicProps = await file.GetBasicPropertiesAsync(); }
catch (Exception ex) { Debug.WriteLine(ex.ToString()); }
if (file.ContentType.StartsWith("image", StringComparison.OrdinalIgnoreCase))
{
var flyoutImg = new PropertiesFlyoutImage();
flyout = flyoutImg;
ImageProperties imageProps = await file.Properties.GetImagePropertiesAsync();
if (imageProps != null)
FillImageProperties(flyoutImg, imageProps, file, basicProps);
}
else if (file.ContentType.ToLower().StartsWith("audio"))
{
var flyoutAud = new PropertiesFlyoutAudio();
flyout = flyoutAud;
MusicProperties musicProps = await file.Properties.GetMusicPropertiesAsync();
if (musicProps != null)
await FillAudioProperties(flyoutAud, musicProps, file);
}
else if (file.ContentType.ToLower().StartsWith("video"))
{
var flyoutVdo = new PropertiesFlyoutVideo();
flyout = flyoutVdo;
VideoProperties videoProps = await file.Properties.GetVideoPropertiesAsync();
if (videoProps != null)
FillVideoProperties(flyoutVdo, videoProps);
}
else
{
var flyoutGen = new PropertiesFlyoutGeneral();
flyout = flyoutGen;
await FillGeneralProperties(flyoutGen, file, basicProps);
}
Debug.Assert(flyout != null, "Flyout object must exist.");
if (flyout != null)
await FillFileProperties((IFileProperties)flyout, file, topFolder, fileSubPath, basicProps);
}
catch (Exception ex) { Debug.WriteLine(ex.ToString()); }
return flyout;
}
private async Task<long> GetFileSize(StorageFile file)
{
BasicProperties props = await file.GetBasicPropertiesAsync();
return (long)props.Size;
}
private static async Task<bool> IsFileOutOfDate(StorageFile file, DateTime expirationDate)
{
if (file != null)
{
var properties = await file.GetBasicPropertiesAsync();
return properties.DateModified < expirationDate;
}
return true;
}
/// <summary>
/// Attempts to generate a list of tests from a file.
///
/// NB this currently only works on .py files with Python tests
/// </summary>
/// <param name="file"></param>
/// <param name="path"></param>
/// <returns></returns>
internal async static Task<List<Test>> GetTestsFromFile(StorageFile file, string path)
{
var toreturn = new List<Test>();
if ((await file.GetBasicPropertiesAsync()).Size > 1024 * 1024 * 1024)
{
throw new Exception("File too large: " + file.Path);
}
try {
var reader = await file.OpenReadAsync();
var lines = await FileIO.ReadLinesAsync(file);
foreach (string line in lines)
{
if (line.Contains("def test_") && !line.Trim().StartsWith("##"))
{
var test = new Test();
string prefix = "";
if (path != "")
{
prefix = path + "/" + file.DisplayName + "/";
}
test.NameForDisplay = prefix + line.Replace("def ", "").Replace("(self):", "").Replace("test_", "").Trim();
test.NameInFile = line;
toreturn.Add(test);
}
}
} catch
{
return new List<Test>(); // TODO support unicode
}
return toreturn;
}
private async Task uploadFile(StorageFile file, string peer)
{
if (file == null) return;
if (shareOperation != null) shareOperation.ReportStarted();
var fileSize = (await file.GetBasicPropertiesAsync()).Size;
if ( fileSize> 20 * 1024 * 1024)
{
await DialogBoxes.AskForConfirmation("File may be too big to handle. The file size is "+(fileSize/1024/1024).ToString()+"MB. Files bigger than 20 MB may cause the application to crash. Proceed at your own risk?",
async () =>
{
byte[] fileContents = (await FileIO.ReadBufferAsync(file)).ToArray();
if (shareOperation != null) shareOperation.ReportDataRetrieved();
await Communicator.SendFile(file.Name, fileContents, peer);
});
}
else
{
byte[] fileContents = (await FileIO.ReadBufferAsync(file)).ToArray();
if ((bool)enableEncryption.IsChecked)
{
await Communicator.SendFile(file.Name, fileContents, peer);
}
else
{
await Communicator.SendFileNoCrypt(file.Name, fileContents, peer);
}
}
}
public static async Task<FileInfoDataItem> Create(StorageFile file, String uniqueId, Image image, FileInfoDataGroup group)
{
try
{
var obj = new FileInfoDataItem(file, uniqueId, image, group);
if (file != null)
{
obj.FileName = file.Name;
if (!string.IsNullOrEmpty(ItemsPage.Current.TopFolder.Path))
{
int topFolderLen = ItemsPage.Current.TopFolder.Path.Length;
int lastSepIdx = file.Path.LastIndexOf('\\');
Debug.Assert(lastSepIdx >= 0 && lastSepIdx < file.Path.Length && lastSepIdx >= topFolderLen);
if (lastSepIdx >= 0 && lastSepIdx < file.Path.Length && lastSepIdx > topFolderLen)
obj.SubPath += file.Path.Substring(topFolderLen + 1, lastSepIdx - topFolderLen - 1);
}
else
{
int idx = !string.IsNullOrEmpty(ItemsPage.Current.TopFolder.Name) ?
file.Path.IndexOf(ItemsPage.Current.TopFolder.Name, StringComparison.OrdinalIgnoreCase) : -1;
if (idx >= 0)
{
int idxSubPath = idx + ItemsPage.Current.TopFolder.Name.Length + 1;
int idxFileName = Math.Max(file.Path.LastIndexOf("\\"), 0);
if (idxFileName > idxSubPath)
obj.SubPath += file.Path.Substring(idxSubPath, idxFileName - idxSubPath);
}
else
{
idx = file.Path.LastIndexOf("\\");
if (idx > 0)
obj.SubPath = file.Path.Substring(0, idx);
else
obj.SubPath = file.Path;
}
}
BasicProperties props = await file.GetBasicPropertiesAsync();
if (props != null)
{
obj.Size = Util.SizeToString(props.Size, "B");
ItemsPage.Current.IncrTotalBytes(props.Size);
}
obj.DateModified = Util.DateTime_ToString(props.DateModified, Util.EDateTimeFormat.G);
obj.Extension = file.FileType;
obj.ContentType = file.ContentType;
#if DEBUG
{
string ext = (file.FileType == String.Empty) ? "EMPTY" : file.FileType;
string contyp = (file.ContentType == String.Empty) ? "EMPTY" : file.ContentType;
if (!ItemsPage.Current._ExtContyp.ContainsKey(ext))
{
//Debug.WriteLine(ext + " - " + contyp);
ItemsPage.Current._ExtContyp.Add(ext, contyp);
}
//else if (file.FileType == String.Empty)
// Debug.WriteLine(ext + " - " + contyp);
//if (!ItemsPage.Current._ContypExt.ContainsKey(contType))
//{
// Debug.WriteLine(contType + " - " + ext);
// ItemsPage.Current._ContypExt.Add(contType, ext);
//}
//else if (file.ContentType == String.Empty)
// Debug.WriteLine(contType + " - " + ext);
}
#endif
}
return obj;
}
catch (Exception ex) { Debug.WriteLine(ex.ToString()); return null; }
}
private async void SetDataContext(BitmapImage image, StorageFile file)
{
var stream = await file.OpenAsync(FileAccessMode.Read);
var properties = await (await file.GetBasicPropertiesAsync()).RetrievePropertiesAsync(new string[] { });
DataContext = new FileSummary(image, file, properties, stream);
// Show the relevant sub-headers
if (SubHeaderBasic.Visibility != Visibility.Visible)
{
SubHeaderBasic.Visibility = Visibility.Visible;
SubHeaderExif.Visibility = Visibility.Visible;
SubHeaderFull.Visibility = Visibility.Visible;
}
}
/*******************************************************************************************
* PRIVATE METHODS
********************************************************************************************/
private async Task uploadPictureToAzure(string imageName, StorageFile imageFile)
{
//Log data for upload attempt
Windows.Storage.FileProperties.BasicProperties fileProperties = await imageFile.GetBasicPropertiesAsync();
Dictionary<string, string> properties = new Dictionary<string, string> { { "File Size", fileProperties.Size.ToString() } };
TelemetryHelper.TrackEvent("Azure picture upload attempt", properties);
try
{
//Create a blank blob
CloudBlockBlob newBlob = blobContainer.GetBlockBlobReference(imageName);
//Add image data to blob
await newBlob.UploadFromFileAsync(imageFile);
}
catch(Exception ex)
{
//This failure will be logged in telemetry in the enclosing UploadPictures function. We don't want this to be recorded twice.
throw new Exception("Exception in uploading pictures to Azure: " + ex.Message);
}
//Log successful upload event
TelemetryHelper.TrackEvent("Azure picture upload success", properties);
}
private void OpenPDFDocument(Windows.Storage.StorageFile file)
{
if (file != null)
{
IAsyncOperation <Windows.Storage.FileProperties.BasicProperties> file_property = file.GetBasicPropertiesAsync();
Windows.Storage.FileProperties.BasicProperties properties = file_property.GetResults();
m_SDKDocument = new FSDK_Document();
int result = m_SDKDocument.OpenDocumentAsync(file, (int)properties.Size, null).GetResults();
if (result != 0)
{
return;
}
m_PDFDoc.pointer = m_SDKDocument.m_hDoc.pointer;
result = LoadPage(m_iCurPageIndex);
if (result != 0)
{
return;
}
m_dbScaleFator = (m_dbCommonFitWidthScale < m_dbCommonFitHeightScale) ? m_dbCommonFitWidthScale : m_dbCommonFitHeightScale;
ShowPage();
}
else
{
//ShowErrorLog("Error: Fail to pick a valid PDF file.", ref new UICommandInvokedHandler(this, renderPage.ReturnCommandInvokedHandler));
return;
}
}
private async Task<FileInfo> ScanFile(StorageFile file, bool doSha1)
{
var basicProps = await file.GetBasicPropertiesAsync();
string sha1str = null;
if (doSha1) {
try {
IBuffer buffer;
using (var stream = await file.OpenAsync(FileAccessMode.Read)) {
buffer = WindowsRuntimeBuffer.Create((int)basicProps.Size); // oh no we can't read large files
await stream.ReadAsync(buffer, (uint)basicProps.Size, InputStreamOptions.None);
}
var hash = Sha1.HashData(buffer);
var hashBytes = new byte[hash.Length];
hash.CopyTo(hashBytes);
sha1str = Convert.ToBase64String(hashBytes);
}
catch (UnauthorizedAccessException) { }
}
return new FileInfo {
Name = file.Name,
Path = file.Path,
Sha1 = sha1str,
Size = basicProps.Size,
};
}
private async Task<long> GetFileSizeInBytes(StorageFile file)
{
var fileProperties = await file.GetBasicPropertiesAsync();
return (long) fileProperties.Size;
}
public async Task Show_PickerAsync(object obj)
{
var picker = new Windows.Storage.Pickers.FileOpenPicker();
picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail;
picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.PicturesLibrary;
picker.FileTypeFilter.Add(".mp3");
picker.FileTypeFilter.Add(".mp4");
picker.FileTypeFilter.Add(".webm");
Windows.Storage.StorageFile file = await picker.PickSingleFileAsync();
if (file != null)
{
// Application now has read/write access to the picked file
string[] namedetail = file.Name.Split('.');
Song addsong = new Song { Name = namedetail[0], Path = file.Path };
Windows.Storage.FileProperties.BasicProperties basicProperties = await file.GetBasicPropertiesAsync();
string fileSize = string.Format("{0:n0}", basicProperties.Size);
Debug.WriteLine(fileSize);
ListSong.Add(addsong);
DatabaseService.Instance().DB.SongDao.Insert(addsong);
/* DatabaseService.Instance().DB.PlaylistDao.addSong(addsong,);*/
/* Messenger.Default.Send<MessengerBus>(new MessengerBus() { NameSong = namedetail[0], Path = file.Path });*/
}
/* var file = await picker.PickMultipleFilesAsync();*/
}
private async void UploadSingleFile(Uri uri, StorageFile file)
{
if (file == null)
{
rootPage.NotifyUser("No file selected.", NotifyType.ErrorMessage);
return;
}
BasicProperties properties = await file.GetBasicPropertiesAsync();
if (properties.Size > maxUploadFileSize)
{
rootPage.NotifyUser(String.Format(CultureInfo.CurrentCulture,
"Selected file exceeds max. upload file size ({0} MB).", maxUploadFileSize / (1024 * 1024)),
NotifyType.ErrorMessage);
return;
}
BackgroundUploader uploader = new BackgroundUploader();
uploader.SetRequestHeader("Filename", file.Name);
UploadOperation upload = uploader.CreateUpload(uri, file);
Log(String.Format(CultureInfo.CurrentCulture, "Uploading {0} to {1}, {2}", file.Name, uri.AbsoluteUri,
upload.Guid));
// Attach progress and completion handlers.
await HandleUploadAsync(upload, true);
}
private async Task CalculateFileSize(StorageFile file)
{
BasicProperties p = await file.GetBasicPropertiesAsync();
m_size = (long) p.Size;
}
private async void ShowProperties(StorageFile file)
{
Windows.Storage.FileProperties.BasicProperties basicProperties = await file.GetBasicPropertiesAsync();
ImageProperties imageProperties = await file.Properties.GetImagePropertiesAsync();
StringBuilder propertiesText = new StringBuilder();
propertiesText.AppendLine((String)_resources["fileName"]+": "+file.DisplayName);
propertiesText.AppendLine((String)_resources["fileSize"] + ": " + basicProperties.Size + " "+ (String)_resources["fileSizeBytes"]);
propertiesText.AppendLine((String)_resources["fileType"] + ": " + file.FileType);
propertiesText.AppendLine((String)_resources["fileDateModified"] + ": " + basicProperties.DateModified);
propertiesText.AppendLine((String)_resources["filePath"] + ": " + file.Path);
propertiesText.AppendLine();
propertiesText.AppendLine((String)_resources["fileCoordinates"]);
propertiesText.AppendLine((String)_resources["fileLongitude"] + ": " + imageProperties.Longitude);
propertiesText.AppendLine((String)_resources["fileLatitude"] + ": " + imageProperties.Latitude);
properties.Details = propertiesText.ToString() ;
}
private static async Task<CacheItem> GetCacheItemFromFileAsync(StorageFile file)
{
CacheItem result = null;
try
{
var fileName = file.Name;
var basicProperties = await file.GetBasicPropertiesAsync();
var parts = fileName.Split('.');
if (parts.Length == 3)
{
var size = GetSizeFromString(parts[1]);
if (size != default(Size))
{
result = new CacheItem
{
Key = parts[0],
ImageSize = size,
Size = basicProperties.Size,
LastAccessTime = basicProperties.DateModified.UtcDateTime
};
}
}
}
catch (SecurityException)
{
// Doesn't metter
}
catch (UnauthorizedAccessException)
{
// Doesn't metter
}
return result;
}