public async Task Restore(string filename) { if (await SignInSkydrive()) { await LoadData(); try { StorageFile restoreFile = await ApplicationData.Current.LocalFolder.CreateFileAsync(filename, CreationCollisionOption.ReplaceExisting); LiveConnectClient client = new LiveConnectClient(_session); LiveOperationResult liveOpResult2 = await client.GetAsync(_skyDriveFolderId + "/files"); dynamic result = liveOpResult2.Result; string backupFileID = null; foreach (var item in result.data) { if (item.name == filename) { backupFileID = item.id; break; } } if (backupFileID != null) { LiveDownloadOperationResult operationResult = await client.BackgroundDownloadAsync(backupFileID + "/content", restoreFile); } } catch (Exception exception) { throw new Exception("Error during restore: " + exception.Message); } } }
private async void btnSelectDownloadFile_Click(object sender, RoutedEventArgs e) { if (this.liveClient == null) { this.ShowMessage("Please sign in first."); return; } if (string.IsNullOrEmpty(this.tbdownloadUrl.Text)) { this.ShowMessage("Please specify the link to the file to be downloaded."); return; } try { string fileLink = this.tbdownloadUrl.Text; var roamingSettings = ApplicationData.Current.RoamingSettings; roamingSettings.Values["FileName"] = this.fileName; var appSettingContainer = roamingSettings.CreateContainer( "FileUploadDownload Settings", ApplicationDataCreateDisposition.Always); appSettingContainer.Values[this.fileName] = true; var roamingFolder = ApplicationData.Current.RoamingFolder; var storageDir = await roamingFolder.CreateFolderAsync( "FileUploadDownload sample", CreationCollisionOption.OpenIfExists); var storageFile = await storageDir.CreateFileAsync(this.fileName, CreationCollisionOption.ReplaceExisting); if (storageFile != null) { this.progressBar.Value = 0; var progressHandler = new Progress<LiveOperationProgress>( (progress) => { this.progressBar.Value = progress.ProgressPercentage; }); this.ShowProgress(); this.cts = new CancellationTokenSource(); LiveDownloadOperation operation = await this.liveClient.CreateBackgroundDownloadAsync( fileLink, storageFile); LiveDownloadOperationResult result = await operation.StartAsync(this.cts.Token, progressHandler); this.ShowMessage("Download completed."); } } catch (TaskCanceledException) { this.ShowMessage("User has cancelled the operation."); } catch (Exception exp) { this.ShowMessage(exp.ToString()); } }
private async void OnAuthCompleted(AuthResult authResult) { this.CleanupBrowser(); if (authResult.AuthorizeCode != null) { try { LiveConnectSession session = await this.AuthClient.ExchangeAuthCodeAsync(authResult.AuthorizeCode); this.liveConnectClient = new LiveConnectClient(session); LiveOperationResult meRes = await this.liveConnectClient.GetAsync("me"); dynamic meData = meRes.Result; this.nameLabel.Text = meData.name; LiveDownloadOperationResult meImgResult = await this.liveConnectClient.DownloadAsync("me/picture"); this.meImage.Image = Image.FromStream(meImgResult.Stream); } catch (Exception e) { MessageBox.Show("Error", e.Message); } updateTree(); } }
public virtual async Task <bool> DownloadPasswords() { if (!IsConnected) { await Login(); } if (!IsConnected) { return(false); } IsolatedStorageFile isoStore = IsolatedStorageFile.GetUserStoreForApplication(); string passwordFileId = await GetPasswordFileId(); if (passwordFileId == null) { return(false); } using (IsolatedStorageFileStream isoStream = new IsolatedStorageFileStream("accounts.dat", FileMode.OpenOrCreate, isoStore)) { LiveDownloadOperationResult result = await _connectClient.DownloadAsync(passwordFileId + "/content"); result.Stream.CopyTo(isoStream); } return(true); }
private async void OnAuthCompleted(AuthResult result) { this.CleanupAuthForm(); if (result.AuthorizeCode != null) { try { LiveConnectSession session = await this.AuthClient.ExchangeAuthCodeAsync(result.AuthorizeCode); this.liveConnectClient = new LiveConnectClient(session); LiveOperationResult meRs = await this.liveConnectClient.GetAsync("me"); dynamic meData = meRs.Result; this.meNameLabel.Text = meData.name; LiveDownloadOperationResult meImgResult = await this.liveConnectClient.DownloadAsync("me/picture"); this.mePictureBox.Image = Image.FromStream(meImgResult.Stream); } catch (LiveAuthException aex) { this.LogOutput("Failed to retrieve access token. Error: " + aex.Message); } catch (LiveConnectException cex) { this.LogOutput("Failed to retrieve the user's data. Error: " + cex.Message); } } else { this.LogOutput(string.Format("Error received. Error: {0} Detail: {1}", result.ErrorCode, result.ErrorDescription)); } }
private void CompleteOperation(Exception error) { LiveDownloadOperationResult opResult; if (this.response != null) { this.response.Close(); } if (this.IsCancelled) { opResult = new LiveDownloadOperationResult(null, true); } else if (error != null) { opResult = new LiveDownloadOperationResult(error, false); } else { this.outputStream.Seek(0, 0); opResult = new LiveDownloadOperationResult(this.outputStream); } Action <LiveDownloadOperationResult> callback = this.OperationCompletedCallback; if (callback != null) { callback(opResult); } }
private async Task DownloadFile(SkyDriveListItem item, LiveConnectClient client) { var indicator = SystemTray.GetProgressIndicator(this); indicator.IsIndeterminate = true; indicator.Text = String.Format(AppResources.DownloadingProgressText, item.Name); item.Downloading = true; try { LiveDownloadOperationResult e = await client.DownloadAsync(item.SkyDriveID + "/content"); if (e != null) { item.Stream = e.Stream; } } catch (Exception ex) { MessageBox.Show(String.Format(AppResources.DownloadErrorText, item.Name, ex.Message), AppResources.ErrorCaption, MessageBoxButton.OK); } #if GBC indicator.Text = AppResources.ApplicationTitle2; #else indicator.Text = AppResources.ApplicationTitle; #endif indicator.IsIndeterminate = false; item.Downloading = false; }
/// <summary> /// Calls the OperationCompletedCallback with the given result. /// This should be called when the TailoredDownloadOperation is completed. /// </summary> protected void OnOperationCompleted(LiveDownloadOperationResult result) { Action <LiveDownloadOperationResult> callback = this.OperationCompletedCallback; if (callback != null) { callback(result); } }
private async void OnPhotoChooserTaskCompleted(object sender, PhotoResult e) { if (e.Error != null) { this.ShowMessage(e.Error.ToString()); } else if (e.OriginalFileName == null) { this.ShowMessage("No Photo Choosen."); } else { string[] filePathSegments = e.OriginalFileName.Split('\\'); string fileName = filePathSegments[filePathSegments.Length - 1]; try { var progressHandler = new Progress <LiveOperationProgress>((LiveOperationProgress progress) => { this.progressBar.Value = progress.ProgressPercentage; }); this.ShowProgress(); LiveOperationResult operationResult = await this.liveClient.UploadAsync( this.tbUrl.Text, fileName, e.ChosenPhoto, OverwriteOption.Rename, new CancellationToken(false), progressHandler); e.ChosenPhoto.Dispose(); this.progressBar.Value = 0; dynamic result = operationResult.Result; string fileLocation = result.source; LiveDownloadOperationResult downloadOperationResult = await this.liveClient.DownloadAsync(fileLocation, new CancellationToken(false), progressHandler); using (Stream downloadStream = downloadOperationResult.Stream) { if (downloadStream != null) { var imgSource = new BitmapImage(); imgSource.SetSource(downloadStream); this.imgPreview.Source = imgSource; this.ShowImage(); } } } catch (Exception exp) { this.ShowMessage(exp.ToString()); } } }
/// <summary> /// Overrides the base execute logic to use the background downloader to download the file. /// </summary> protected async override void OnExecute() { BT.BackgroundDownloader downloader; if (this.Url.OriginalString.StartsWith(this.LiveClient.ApiEndpoint, StringComparison.OrdinalIgnoreCase)) { if (base.RefreshTokenIfNeeded()) { return; } downloader = new BT.BackgroundDownloader(); if (this.LiveClient.Session != null) { downloader.SetRequestHeader( ApiOperation.AuthorizationHeader, AuthConstants.BearerTokenType + " " + this.LiveClient.Session.AccessToken); } downloader.SetRequestHeader(ApiOperation.LibraryHeader, Platform.GetLibraryHeaderValue()); } else { downloader = new BT.BackgroundDownloader(); } downloader.Group = LiveConnectClient.LiveSDKDownloadGroup; this.cts = new CancellationTokenSource(); this.downloadOp = downloader.CreateDownload(this.Url, this.OutputFile); var progressHandler = new Progress <BT.DownloadOperation>(this.OnDownloadProgress); LiveDownloadOperationResult result = null; Exception webError = null; try { this.downloadOp = await this.downloadOp.StartAsync().AsTask(this.cts.Token, progressHandler); result = this.OutputFile != null ? new LiveDownloadOperationResult(this.OutputFile) : new LiveDownloadOperationResult(this.downloadOp.GetResultStreamAt(0)); } catch (TaskCanceledException) { result = new LiveDownloadOperationResult(null, true); } catch (Exception error) { webError = error; } if (webError != null) { result = await this.ProcessDownloadErrorResponse(webError); } this.OnOperationCompleted(result); }
/// <summary> /// Downloads the contents of a file represented by this OneDriveItem. /// </summary> /// <param name="btp"></param> /// <param name="progress"></param> /// <returns></returns> public async Task <System.IO.Stream> DownloadContentsAsync(IBackgroundTransferProvider btp = null, IProgress <LiveOperationProgress> progress = null) { if (this.ItemType != OneDriveItemType.GenericFile) { throw new InvalidOperationException("Cannot download items that are not files"); } LiveDownloadOperationResult result = await Client.LiveClient.DownloadAsync(string.Format("/{0}/content", this.Identifier), btp, progress); return(result.Stream); }
private async void DownloadFile() { if (this.liveClient == null) { this.ShowMessage("Please sign in first."); return; } try { string filePath = this.tbUrl.Text; if (string.IsNullOrEmpty(filePath)) { this.ShowMessage("Please specify a file id or a url."); } else { this.progressBar.Value = 0; this.ShowProgress(); var progressHandler = new Progress <LiveOperationProgress>( (progress) => { this.progressBar.Value = progress.ProgressPercentage; }); this.cts = new CancellationTokenSource(); LiveDownloadOperation op = await this.liveClient.CreateBackgroundDownloadAsync(filePath); LiveDownloadOperationResult downloadResult = await op.StartAsync(this.cts.Token, progressHandler); if (downloadResult.Stream != null) { using (IRandomAccessStream ras = await downloadResult.GetRandomAccessStreamAsync()) { var imgSource = new BitmapImage(); imgSource.SetSource(ras); this.imgPreview.Source = imgSource; this.ShowImage(); } } else { this.ShowMessage("Download failed."); } } } catch (TaskCanceledException) { this.ShowMessage("User has cancelled the operation."); } catch (Exception exp) { this.ShowMessage(exp.ToString()); } }
public async Task <Stream> DownloadFileAsStream(string fileId) { LiveConnectSessionStatus connectStatus; if (client != null || (connectStatus = await Connect()) == LiveConnectSessionStatus.Connected) { LiveDownloadOperationResult fileDownloadResult = await client.DownloadAsync(fileId + "/content"); return(fileDownloadResult.Stream); } return(null); }
public async Task RestoreBackupfile(Backupfile file) { RestoreLock = true; string tmpPathDatabase = "downloadedDatabase.sdf"; //release all resources from DB LiveConnectClient liveClient = new LiveConnectClient(oneDriveAuthClient.Session); try { LiveDownloadOperationResult downloadResult = await liveClient.DownloadAsync(file.FileID + "/content"); using (Stream downloadStream = downloadResult.Stream) { if (downloadStream != null) { using (IsolatedStorageFile storage = IsolatedStorageFile.GetUserStoreForApplication()) { using (IsolatedStorageFileStream output = storage.CreateFile(tmpPathDatabase)) { // Initialize the buffer. byte[] readBuffer = new byte[4096]; int bytesRead = -1; // Copy the file from the installation folder to the local folder. while ((bytesRead = downloadStream.Read(readBuffer, 0, readBuffer.Length)) > 0) { output.Write(readBuffer, 0, bytesRead); } } } } } MessageBox.Show("Download successful. Restore started."); IsolatedStorageFile iso = IsolatedStorageFile.GetUserStoreForApplication(); App.AppViewModel.RestoreDatabase(tmpPathDatabase); if (iso.FileExists(tmpPathDatabase)) { iso.DeleteFile(tmpPathDatabase); } MessageBox.Show("Restore succesfull."); RestoreLock = false; } catch (LiveConnectException ex) { App.AppViewModel.SendExceptionReport(ex); RestoreLock = false; } }
private async void ButtonSave_Click(object sender, RoutedEventArgs e) { try { LiveDownloadOperationResult downloadOperationResult = await this.liveClient.DownloadAsync(this.id + "/content", new CancellationToken(false), this); this.SaveToStorage(downloadOperationResult.Stream); } catch (LiveConnectException exception) { this.TextBox.Text = exception.Message; } }
// Summary: // Download a file by file id. // // Parameters: // sourceFileId: // The id of the file you want to download. // // Returns: // The input stream to download file. public async Task <Stream> DownloadFileStreamAsync(string sourceFileId) { System.Threading.CancellationTokenSource ctsDownload = new System.Threading.CancellationTokenSource(); LiveDownloadOperationResult result = null; try { //result = await this.LiveClient.DownloadAsync(sourceFileId + "/content"); result = await this.LiveClient.BackgroundDownloadAsync(sourceFileId + "/content"); } catch { throw new ShareException(sourceFileId, ShareException.ShareType.DOWNLOAD); } return(result.Stream.AsStreamForRead()); }
private async Task <byte[]> GetProfileImageData(LiveConnectClient client) { byte[] imgData = null; try { LiveDownloadOperationResult meImgResult = await client.DownloadAsync("me/picture"); imgData = new byte[meImgResult.Stream.Length]; await meImgResult.Stream.ReadAsync(imgData, 0, imgData.Length); } catch { // Failed to download image data. } return(imgData); }
private async void LoadFileAsync(string fileID, AsyncContext context) { try { LiveConnectClient skyDrive = await _liveLogin.Login(); if (skyDrive == null) { context.Error = new Exception("Login Required"); return; } LiveOperationResult fileData = await skyDrive.GetAsync(fileID); string path = FixSkyDriveUrl((string)fileData.Result["source"]); LiveDownloadOperationResult downloadResult = await skyDrive.DownloadAsync(path); var buffer = new byte[4096]; var memoryStream = new MemoryStream(); StreamUtils.Copy(downloadResult.Stream, memoryStream, buffer); memoryStream.Position = 0L; context.Stream = memoryStream; } catch (WebException e) { if (e.Status == WebExceptionStatus.RequestCanceled) { context.Error = new RestartException(e.Message, e); return; } context.Error = e; } catch (TaskCanceledException e) { context.Error = new RestartException(e.Message, e); } catch (Exception e) { context.Error = e; } finally { context.WaitHandle.Set(); } }
private void OnLiveClientDownloadCompleted(System.Threading.Tasks.Task <LiveDownloadOperationResult> task, OneDriveFile file) { // Sync Step 4. The file has been downloaded as a memory stream. // Write it to its direct location. // (This runs on the emulator and on devices where the background download method failed.) if (!CheckTaskCompleted(task, "Download failed (" + file.Name + ")")) { PostProcessDownload(file, null, false); return; } LiveDownloadOperationResult result = task.Result; string filepath = GetIsoStorePath(file.Name, file.DownloadDirectory); bool success = false; try { using (IsolatedStorageFile isf = IsolatedStorageFile.GetUserStoreForApplication()) { // Makes sure the directory exists. isf.CreateDirectory(file.DownloadDirectory); // Creates a file at the right place. using (IsolatedStorageFileStream fs = isf.OpenFile(filepath, FileMode.Create)) { result.Stream.CopyTo(fs); } } Log("Created " + filepath); success = true; } catch (Exception e) { Log("Error while writing " + filepath + ": " + e.Message); Geowigo.Utils.DebugUtils.DumpException(e, file.ToString(), true); success = false; } PostProcessDownload(file, filepath, success); }
/// <summary> /// Download TNS from path in Skydrive and update known routes/stops /// </summary> /// <param name="path"></param> /// <returns></returns> public static async Task DownloadTNS(string path) { try { LiveDownloadOperationResult ldor = await CloudStorage.Client.DownloadAsync(path + "/content"); //TransitNetworkSearch tns = JsonConvert.DeserializeObject<TransitNetworkSearch>("hi"); TransitNetworkSearch tns; using (StreamReader sr = new StreamReader(ldor.Stream)) { string content = sr.ReadToEnd(); tns = JsonConvert.DeserializeObject <TransitNetworkSearch>(content); } TransitNetworkSearch.SaveTNS(tns); } catch { } }
/// <summary> /// Downloads the profile picture of the current user. /// </summary> private async void GetProfilePicture() { try { LiveDownloadOperationResult downloadOperationResult = await this.liveClient.DownloadAsync("me/picture"); Stream stream = downloadOperationResult.Stream; if (stream != null) { BitmapImage imgSource = new BitmapImage(); imgSource.SetSource(stream); this.imgMe.Source = imgSource; } } catch (LiveConnectException e) { this.tbResponse.Text = e.ToString(); } }
public async static Task <string> DownloadAsync(string fileId) { try { if (fileId != null) { LiveDownloadOperationResult operationResult = await _client.DownloadAsync(fileId + "/content"); if (operationResult.Stream != null) { operationResult.Stream.Position = 0; StreamReader sr = new StreamReader(operationResult.Stream); return(await sr.ReadToEndAsync()); } } } catch (Exception) { } return(null); }
public static async Task<string> SetupChmFileFromOneDrive(LiveConnectClient client, IProgress<LiveOperationProgress> progressHandler, System.Threading.CancellationToken ctoken, string id, string name, string path) { ChmFile ret = new ChmFile(); ret.Key = Guid.NewGuid().ToString("N"); ret.HasThumbnail = false; Windows.Storage.StorageFolder localFolder = Windows.Storage.ApplicationData.Current.LocalFolder; StorageFile file = await localFolder.CreateFileAsync(ret.Key + ChmFileExtension, CreationCollisionOption.ReplaceExisting); LiveDownloadOperationResult result = await client.BackgroundDownloadAsync(id + "/content", file, ctoken, progressHandler); try { ret.Chm = await LoadChm(file.Path, false); MetaInfo meta = new MetaInfo(); meta.SetOriginalPath(path); if (ret.Chm.Title != null) { meta.SetDisplayName(ret.Chm.Title); } else { meta.SetDisplayName(System.IO.Path.GetFileNameWithoutExtension(name)); } ret.ChmMeta = meta; await ret.Save(); FileHistory.AddToHistory(ret.Key); } catch { ret.Chm = null; } if (ret.Chm == null) { await MetaInfo.DeleteMetaFile(ret.Key); await DeleteFile(ret.Key); return null; } return ret.Key; }
/// <summary> /// Process the error response. /// </summary> private async Task <LiveDownloadOperationResult> ProcessDownloadErrorResponse(Exception exception) { LiveDownloadOperationResult opResult; try { IInputStream responseStream = this.downloadOp.GetResultStreamAt(0); if (responseStream == null) { var error = new LiveConnectException( ApiOperation.ApiServerErrorCode, ResourceHelper.GetString("ConnectionError")); opResult = new LiveDownloadOperationResult(error, false); } else { var reader = new DataReader(responseStream); uint length = await reader.LoadAsync(TailoredDownloadOperation.MaxDownloadResponseLength); Exception error = CreateOperationResultFrom(reader.ReadString(length), this.Method).Error; if (error is FormatException) { // if we cannot understand the error response, // return the exception thrown by the background downloader. error = exception; } opResult = new LiveDownloadOperationResult(error, false); } } catch (COMException exp) { opResult = new LiveDownloadOperationResult(exp, false); } catch (FileNotFoundException exp) { opResult = new LiveDownloadOperationResult(exp, false); } return(opResult); }
private async void GetProfilePicture() { try { LiveDownloadOperationResult result = await this.liveClient.BackgroundDownloadAsync("me/picture"); if (result != null && result.Stream != null) { using (IRandomAccessStream ras = await result.GetRandomAccessStreamAsync()) { BitmapImage imgSource = new BitmapImage(); imgSource.SetSource(ras); this.imgMe.Source = imgSource; } } } catch (LiveConnectException e) { this.tbResponse.Text = e.ToString(); } }
private async void ButtonDownload_Click(object sender, RoutedEventArgs e) { this.ShowProgress(); try { LiveDownloadOperationResult downloadOperationResult = await this.liveClient.DownloadAsync(this.id + "/content", new CancellationToken(false), this); Stream fileContent = downloadOperationResult.Stream; if (IsImageFile(this.name)) { this.ShowImage(fileContent); } else { this.ShowText(fileContent); } } catch (LiveConnectException exception) { this.ShowMessage(exception.Message); } }
private async Task LoadProfileImage(LiveConnectClient connectClient) { try { LiveDownloadOperation downloadOperation = await connectClient.CreateBackgroundDownloadAsync("me/picture"); LiveDownloadOperationResult result = await downloadOperation.StartAsync(); if (result != null && result.Stream != null) { using (IRandomAccessStream ras = await result.GetRandomAccessStreamAsync()) { BitmapImage imgSource = new BitmapImage(); imgSource.SetSource(ras); profileImage.Source = imgSource; } } } catch (LiveConnectException) { // Handle error cases. } }
private async Task DownloadFile(string path) { SaveFileDialog dialog = new SaveFileDialog(); Stream stream = null; dialog.RestoreDirectory = true; if (dialog.ShowDialog() != DialogResult.OK) { throw new InvalidOperationException("No file is picked to upload."); } try { if ((stream = dialog.OpenFile()) == null) { throw new Exception("Unable to open the file selected to upload."); } using (stream) { LiveDownloadOperationResult result = await this.liveConnectClient.DownloadAsync(path); if (result.Stream != null) { using (result.Stream) { await result.Stream.CopyToAsync(stream); } } } } catch (Exception ex) { throw ex; } }
/// <summary> /// Overrides the base execute logic to use the background downloader to download the file. /// </summary> protected async override void OnExecute() { BT.BackgroundDownloader downloader; if (this.Url.OriginalString.StartsWith(this.LiveClient.ApiEndpoint, StringComparison.OrdinalIgnoreCase)) { if (base.RefreshTokenIfNeeded()) { return; } downloader = new BT.BackgroundDownloader(); if (this.LiveClient.Session != null) { downloader.SetRequestHeader( ApiOperation.AuthorizationHeader, AuthConstants.BearerTokenType + " " + this.LiveClient.Session.AccessToken); } downloader.SetRequestHeader(ApiOperation.LibraryHeader, Platform.GetLibraryHeaderValue()); } else { downloader = new BT.BackgroundDownloader(); } downloader.Group = LiveConnectClient.LiveSDKDownloadGroup; this.cts = new CancellationTokenSource(); this.downloadOp = downloader.CreateDownload(this.Url, this.OutputFile); var progressHandler = new Progress<BT.DownloadOperation>(this.OnDownloadProgress); LiveDownloadOperationResult result = null; Exception webError = null; try { this.downloadOp = await this.downloadOp.StartAsync().AsTask(this.cts.Token, progressHandler); result = this.OutputFile != null ? new LiveDownloadOperationResult(this.OutputFile) : new LiveDownloadOperationResult(this.downloadOp.GetResultStreamAt(0)); } catch (TaskCanceledException) { result = new LiveDownloadOperationResult(null, true); } catch (Exception error) { webError = error; } if (webError != null) { result = await this.ProcessDownloadErrorResponse(webError); } this.OnOperationCompleted(result); }
/// <summary> /// Process the error response. /// </summary> private async Task<LiveDownloadOperationResult> ProcessDownloadErrorResponse(Exception exception) { LiveDownloadOperationResult opResult; try { IInputStream responseStream = this.downloadOp.GetResultStreamAt(0); if (responseStream == null) { var error = new LiveConnectException( ApiOperation.ApiServerErrorCode, ResourceHelper.GetString("ConnectionError")); opResult = new LiveDownloadOperationResult(error, false); } else { var reader = new DataReader(responseStream); uint length = await reader.LoadAsync(TailoredDownloadOperation.MaxDownloadResponseLength); Exception error = CreateOperationResultFrom(reader.ReadString(length), this.Method).Error; if (error is FormatException) { // if we cannot understand the error response, // return the exception thrown by the background downloader. error = exception; } opResult = new LiveDownloadOperationResult(error, false); } } catch (COMException exp) { opResult = new LiveDownloadOperationResult(exp, false); } catch (FileNotFoundException exp) { opResult = new LiveDownloadOperationResult(exp, false); } return opResult; }
private void CompleteOperation(Exception error) { LiveDownloadOperationResult opResult; if (this.response != null) { this.response.Dispose(); //this.response.Close(); } if (this.IsCancelled) { opResult = new LiveDownloadOperationResult(null, true); } else if (error != null) { opResult = new LiveDownloadOperationResult(error, false); } else { this.outputStream.Seek(0, 0); opResult = new LiveDownloadOperationResult(this.outputStream); } Action<LiveDownloadOperationResult> callback = this.OperationCompletedCallback; if (callback != null) { callback(opResult); } }
private async Task DownloadFile(SkyDriveListItem item, LiveConnectClient client) { StorageFolder folder = ApplicationData.Current.LocalFolder; StorageFolder romFolder = await folder.CreateFolderAsync(FileHandler.ROM_DIRECTORY, CreationCollisionOption.OpenIfExists); StorageFolder saveFolder = await romFolder.CreateFolderAsync(FileHandler.SAVE_DIRECTORY, CreationCollisionOption.OpenIfExists); String path = romFolder.Path; String savePath = saveFolder.Path; ROMDatabase db = ROMDatabase.Current; var indicator = SystemTray.GetProgressIndicator(this); indicator.IsIndeterminate = true; indicator.Text = String.Format(AppResources.DownloadingProgressText, item.Name); LiveDownloadOperationResult e = await client.DownloadAsync(item.SkyDriveID + "/content"); if (e != null) { byte[] tmpBuf = new byte[e.Stream.Length]; StorageFile destinationFile = null; ROMDBEntry entry = null; if (item.Type == SkyDriveItemType.SRAM) { entry = db.GetROMFromSRAMName(item.Name); if (entry != null) { destinationFile = await saveFolder.CreateFileAsync(Path.GetFileNameWithoutExtension(entry.FileName) + ".sav", CreationCollisionOption.ReplaceExisting); } else { destinationFile = await saveFolder.CreateFileAsync(item.Name, CreationCollisionOption.ReplaceExisting); } } else if (item.Type == SkyDriveItemType.Savestate) { entry = db.GetROMFromSavestateName(item.Name); if (entry != null) { destinationFile = await saveFolder.CreateFileAsync(Path.GetFileNameWithoutExtension(entry.FileName) + item.Name.Substring(item.Name.Length - 5), CreationCollisionOption.ReplaceExisting); } else { destinationFile = await saveFolder.CreateFileAsync(item.Name, CreationCollisionOption.ReplaceExisting); } } using (IRandomAccessStream destStream = await destinationFile.OpenAsync(FileAccessMode.ReadWrite)) using (DataWriter writer = new DataWriter(destStream)) { while (e.Stream.Read(tmpBuf, 0, tmpBuf.Length) != 0) { writer.WriteBytes(tmpBuf); } await writer.StoreAsync(); await writer.FlushAsync(); writer.DetachStream(); } e.Stream.Close(); item.Downloading = false; if (item.Type == SkyDriveItemType.Savestate) { String number = item.Name.Substring(item.Name.Length - 5, 1); int slot = int.Parse(number); if (entry != null) //NULL = do nothing { SavestateEntry saveentry = db.SavestateEntryExisting(entry.FileName, slot); if (saveentry != null) { //delete entry db.RemoveSavestateFromDB(saveentry); } SavestateEntry ssEntry = new SavestateEntry() { ROM = entry, Savetime = DateTime.Now, Slot = slot, FileName = item.Name }; db.Add(ssEntry); db.CommitChanges(); } } MessageBox.Show(String.Format(AppResources.DownloadCompleteText, item.Name)); } else { MessageBox.Show(String.Format(AppResources.DownloadErrorText, item.Name, "Api error"), AppResources.ErrorCaption, MessageBoxButton.OK); } #if GBC indicator.Text = AppResources.ApplicationTitle2; #else indicator.Text = AppResources.ApplicationTitle; #endif indicator.IsIndeterminate = false; }
private async Task DownloadFile(SkyDriveListItem item, LiveConnectClient client) { StorageFolder folder = ApplicationData.Current.LocalFolder; StorageFolder romFolder = await folder.CreateFolderAsync(FileHandler.ROM_DIRECTORY, CreationCollisionOption.OpenIfExists); StorageFolder saveFolder = await romFolder.CreateFolderAsync(FileHandler.SAVE_DIRECTORY, CreationCollisionOption.OpenIfExists); String path = romFolder.Path; String savePath = saveFolder.Path; ROMDatabase db = ROMDatabase.Current; var indicator = new ProgressIndicator() { IsIndeterminate = true, IsVisible = true, Text = String.Format(AppResources.DownloadingProgressText, item.Name) }; SystemTray.SetProgressIndicator(this, indicator); LiveDownloadOperationResult e = await client.DownloadAsync(item.SkyDriveID + "/content"); if (e != null) { byte[] tmpBuf = new byte[e.Stream.Length]; StorageFile destinationFile = await saveFolder.CreateFileAsync(item.Name, CreationCollisionOption.ReplaceExisting); using (IRandomAccessStream destStream = await destinationFile.OpenAsync(FileAccessMode.ReadWrite)) using (DataWriter writer = new DataWriter(destStream)) { while (e.Stream.Read(tmpBuf, 0, tmpBuf.Length) != 0) { writer.WriteBytes(tmpBuf); } await writer.StoreAsync(); await writer.FlushAsync(); writer.DetachStream(); } e.Stream.Close(); item.Downloading = false; SystemTray.GetProgressIndicator(this).IsVisible = false; if (item.Type == SkyDriveItemType.Savestate) { if (!db.SavestateEntryExisting(item.Name)) { String number = item.Name.Substring(item.Name.Length - 5, 1); int slot = int.Parse(number); ROMDBEntry entry = db.GetROMFromSavestateName(item.Name); // Null = No ROM existing for this file -> skip inserting into database. The file will be inserted when the corresponding ROM is downloaded. if (entry != null) { SavestateEntry ssEntry = new SavestateEntry() { ROM = entry, Savetime = DateTime.Now, Slot = slot, FileName = item.Name }; db.Add(ssEntry); db.CommitChanges(); } } } MessageBox.Show(String.Format(AppResources.DownloadCompleteText, item.Name)); } else { SystemTray.GetProgressIndicator(this).IsVisible = false; MessageBox.Show(String.Format(AppResources.DownloadErrorText, item.Name, "Api error"), AppResources.ErrorCaption, MessageBoxButton.OK); } }
/// <summary> /// Calls the OperationCompletedCallback with the given result. /// This should be called when the TailoredDownloadOperation is completed. /// </summary> protected void OnOperationCompleted(LiveDownloadOperationResult result) { Action<LiveDownloadOperationResult> callback = this.OperationCompletedCallback; if (callback != null) { callback(result); } }