Ejemplo n.º 1
0
        private async Task UploadFileToSkydrive(StorageFile file, string eventBuddyFolderId, LiveConnectClient client)
        {
            using (var stream = await file.OpenStreamForReadAsync())
            {
                var progressHandler = InitializeProgressBar();
                var hasErrors       = false;

                do
                {
                    try
                    {
                        hasErrors          = false;
                        this.retrySelected = false;
                        LiveOperationResult result = await client.BackgroundUploadAsync(eventBuddyFolderId, file.Name, stream.AsInputStream(), OverwriteOption.Overwrite, cancellationToken.Token, progressHandler);

                        this.FileNameTextBlock.Text = file.Name;
                        await UpdateSession(client, result);
                    }
                    catch (LiveConnectException)
                    {
                        hasErrors = true;
                    }

                    if (hasErrors)
                    {
                        var errorTitle = "Upload file error";
                        await ShowMessage(errorTitle, "Exception occured while trying to upload the " + file.Name + " file to Skydrive.");
                    }

                    uploadProgress.Visibility = Windows.UI.Xaml.Visibility.Collapsed;
                } while(this.retrySelected);
            }
        }
Ejemplo n.º 2
0
        // Example
        //private async Task<LiveDownloadOperationResult> DownloadExample(
        //    String skyDriveItemId,
        //    IStorageFile downloadFile)
        //{
        //    var client = new LiveConnectClient(_session);
        //    var path = String.Format("{0}/content", skyDriveItemId);
        //    var progressHandler =
        //        new Progress<LiveOperationProgress>(ShowProgress);
        //    var result = await client.BackgroundDownloadAsync(
        //        path,
        //        downloadFile,
        //        _cancellationTokenSource.Token,
        //        progressHandler);
        //    return result;
        //    // result.File
        //    // result.GetRandomAccessStreamAsync()
        //    // result.Stream
        //}

        //private void ShowProgress(LiveOperationProgress liveOperationProgress)
        //{
        //    // Display progress UI, making sure to check for thread access
        //    UpdateUserInterfaceProgress(
        //        liveOperationProgress.BytesTransferred,
        //        liveOperationProgress.TotalBytes,
        //        liveOperationProgress.ProgressPercentage);
        //}

        //private void CancelDownload(CancellationTokenSource tokenSource)
        //{
        //    // Respond to UI request to cancel the download
        //    tokenSource.Cancel();
        //}

        public async Task <dynamic> StartBackgroundUploadAsync(String skyDriveItemId, String uploadFileName, StorageFile fileToUpload, CancellationToken cancellationToken, Progress <LiveOperationProgress> progressHandler)
        {
            // requires wl.skydrive_update scope
            var client = new LiveConnectClient(_session);
            var result = await client.BackgroundUploadAsync(skyDriveItemId, uploadFileName, fileToUpload, OverwriteOption.Rename, cancellationToken, progressHandler);

            return(result.Result);
        }
Ejemplo n.º 3
0
        private async void UploadToSkydrive(object sender, RoutedEventArgs e)
        {
            try
            {
                var file = await storageFolder.GetFileAsync(fileInPC);

                var upfile = await storageFolder.GetFileAsync(fileToUpload);

                //StorageFile sampleFile = await storageFolder.GetFileAsync(fileInPC);
                string textFile = await Windows.Storage.FileIO.ReadTextAsync(file);

                string textUpFile = await Windows.Storage.FileIO.ReadTextAsync(upfile);

                //txtTemp.Text = " PC "+textFile;
                //txtSky.Text = "Sky "+textUpFile;
                try
                {
                    GlobalV.tempLevel = Convert.ToInt32(textFile);
                    GlobalV.Level     = Convert.ToInt32(textUpFile);
                }
                catch (OverflowException)
                {
                }
                catch (FormatException)
                {
                }

                if (GlobalV.tempLevel > GlobalV.Level)
                {
                    GlobalV.Level = GlobalV.tempLevel;
                    StorageFile newFile = await storageFolder.CreateFileAsync(fileToUpload, CreationCollisionOption.ReplaceExisting);

                    await Windows.Storage.FileIO.WriteTextAsync(newFile, GlobalV.Level.ToString());
                }
                else
                {
                }

                string textFile1 = await Windows.Storage.FileIO.ReadTextAsync(file);

                string textUpFile1 = await Windows.Storage.FileIO.ReadTextAsync(upfile);

                //txtTemp.Text = " PC " + textFile1;
                //txtSky.Text = "Sky " + textUpFile1;

                await client.BackgroundUploadAsync("me/skydrive", fileToUpload, upfile, OverwriteOption.Overwrite);

                MessageDialog dlg = new MessageDialog("File uploaded success fully");
                dlg.ShowAsync();
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
                MessageDialog dlg = new MessageDialog("File did not upload success fully");
                dlg.ShowAsync();
            }
        }
Ejemplo n.º 4
0
        private async Task <int> UploadFileToOneDrive()
        {
            try
            {
                //  create OneDrive auth client
                var authClient = new LiveAuthClient();

                //  ask for both read and write access to the OneDrive
                LiveLoginResult result = await authClient.LoginAsync(new string[] { "wl.skydrive", "wl.skydrive_update" });

                //  if login successful
                if (result.Status == LiveConnectSessionStatus.Connected)
                {
                    //  create a OneDrive client
                    liveClient = new LiveConnectClient(result.Session);

                    //  create a local file
                    StorageFile file = await ApplicationData.Current.LocalFolder.CreateFileAsync("filename", CreationCollisionOption.ReplaceExisting);

                    //  copy some txt to local file
                    MemoryStream           ms         = new MemoryStream();
                    DataContractSerializer serializer = new DataContractSerializer(typeof(string));
                    serializer.WriteObject(ms, "Hello OneDrive World!!");

                    using (Stream fileStream = await file.OpenStreamForWriteAsync())
                    {
                        ms.Seek(0, SeekOrigin.Begin);
                        await ms.CopyToAsync(fileStream);

                        await fileStream.FlushAsync();
                    }

                    //  create a folder
                    string folderID = await GetFolderID("folderone");

                    if (string.IsNullOrEmpty(folderID))
                    {
                        //  return error
                        return(0);
                    }

                    //  upload local file to OneDrive
                    await liveClient.BackgroundUploadAsync(folderID, file.Name, file, OverwriteOption.Overwrite);

                    return(1);
                }
            }
            catch
            {
            }
            //  return error
            return(0);
        }
Ejemplo n.º 5
0
        public async Task <string> UploadFileToTrackTimerFolder(StorageFile localFile, bool uploadOverWifi, bool overwrite = false)
        {
            LiveConnectSessionStatus connectStatus;

            if (client != null || (connectStatus = await Connect()) == LiveConnectSessionStatus.Connected)
            {
                client.BackgroundTransferPreferences = uploadOverWifi
                                                        ? BackgroundTransferPreferences.AllowBattery
                                                        : BackgroundTransferPreferences.AllowCellularAndBattery;

                Exception fileUploadException = null;
                try
                {
                    // Copy file to transfers folder
                    var sharedFolder = await ApplicationData.Current.LocalFolder.GetFolderAsync("shared");

                    var transfersFolder = await sharedFolder.GetFolderAsync("transfers");

                    var fileToUpload = await localFile.CopyAsync(transfersFolder, localFile.Name, NameCollisionOption.ReplaceExisting);

                    // Upload to SkyDrive
                    await FindTrackTimerFolder(client);

                    var localFileUri = new Uri(string.Format("/shared/transfers/{0}", fileToUpload.Name), UriKind.RelativeOrAbsolute);
                    var result       = await client.BackgroundUploadAsync(trackTimerFolderId, localFileUri, overwrite?OverwriteOption.Overwrite : OverwriteOption.Rename);

                    // Delete local file once upload is complete
                    if (!uploadOverWifi)
                    {
                        await fileToUpload.DeleteAsync(StorageDeleteOption.PermanentDelete);
                    }

                    // Return the OneDrive Id of the uploaded file
                    return(result.Result != null && result.Result.ContainsKey("id")
                            ? result.Result["id"].ToString()
                            : string.Empty);
                }
                catch (Exception ex)
                {
                    fileUploadException = ex;
                }

                if (fileUploadException != null)
                {
                    var extraData = new LimitedCrashExtraDataList();
                    extraData.Add("Message", string.Format("Failed to upload file {0}", localFile.Name));
                    extraData.Add("UploadOverWifi", uploadOverWifi.ToString());
                    await BugSenseHandler.Instance.LogExceptionAsync(fileUploadException, extraData);
                }
            }
            return(string.Empty);
        }
Ejemplo n.º 6
0
        internal async void RunTaskAsync(LiveConnectClient client, Action <bool> callback)
        {
            bool succeeded = true;

            using (var stream = await File.OpenStreamForReadAsync())
            {
                try
                {
                    const int backgroundTheshold = 1024 * 1024 * 100;
                    if (stream.Length >= backgroundTheshold)
                    {
                        const string rootPath     = "/shell/transfers";
                        var          tempFilePath = string.Format("{0}/{1}/{2}", rootPath, FolderId, FileName);
                        using (var storage = IsolatedStorageFile.GetUserStoreForApplication())
                        {
                            if (!storage.DirectoryExists(rootPath))
                            {
                                storage.CreateDirectory(rootPath);
                            }
                            if (storage.FileExists(tempFilePath))
                            {
                                storage.DeleteFile(tempFilePath);
                            }
                            using (var file = storage.CreateFile(tempFilePath))
                            {
                                var position = stream.Position;
                                await stream.CopyToAsync(file);

                                stream.Position = position;
                            }
                        }
                        client.BackgroundTransferPreferences = BackgroundTransferPreferences.None;
                        await client.BackgroundUploadAsync(FolderId, new Uri(tempFilePath, UriKind.Relative), OverwriteOption.Overwrite);
                    }
                    else
                    {
                        await client.UploadAsync(FolderId, FileName, stream, OverwriteOption.Overwrite);
                    }
                }
                catch (Exception)
                {
                    succeeded = false;
                }
            }
            if (callback != null)
            {
                callback(succeeded);
            }
        }
Ejemplo n.º 7
0
        private async Task <Dictionary <string, string> > UploadFile(StorageFile file)
        {
            Upload Upload = new Upload(file);

            try {
                if (file != null)
                {
                    Dictionary <string, string> fileInfoDict = new Dictionary <string, string>();

                    Upload.ProgressHandler   = new Progress <LiveOperationProgress>((progress) => Upload.SetProgressValue(progress.ProgressPercentage));
                    Upload.CancellationToken = new System.Threading.CancellationTokenSource();

                    PendingUploads.Add(Upload);

                    await LiveConnectClient.BackgroundUploadAsync(SkyDriveFolderToUpload, Upload.File.Name, Upload.File, OverwriteOption.Rename, Upload.CancellationToken.Token, Upload.ProgressHandler);

                    Upload.SetProgressValue(100);

                    fileInfoDict.Add("name", Upload.File.Name);
                    string fileID = await GetSkyDriveFileID(Upload.File.Name);

                    Debug.WriteLine("Upload completed, file name: " + Upload.File.Name + " file ID: " + fileID);
                    string fileLink = await GetLinkOfFile(fileID);

                    fileInfoDict.Add("link", fileLink);

                    friendsPage.HidePendingUploadsPopup();
                    PendingUploads.Remove(Upload);

                    return(fileInfoDict);
                }
            } catch (TaskCanceledException) {
                PendingUploads.Remove(Upload);
                friendsPage.HidePendingUploadsPopup();
                var dialog = new MessageDialog("Upload of file " + file.Name + " has been cancelled.");
                dialog.Commands.Add(new UICommand("Ok"));
                dialog.ShowAsync();
            } catch (LiveConnectException exception) {
                PendingUploads.Remove(Upload);
                friendsPage.HidePendingUploadsPopup();
                var dialog = new MessageDialog("Error uploading file: " + exception.Message);
                dialog.Commands.Add(new UICommand("Ok"));
                dialog.ShowAsync();
            }
            return(null);
        }
        public void TestUploadEmptyStringPath()
        {
            var connectClient = new LiveConnectClient(new LiveConnectSession());

            try
            {
                connectClient.BackgroundUploadAsync(
                    string.Empty,
                    "fileName.txt",
                    new InMemoryRandomAccessStream(),
                    OverwriteOption.Overwrite);
                Assert.Fail("Expected ArguementException to be thrown.");
            }
            catch (ArgumentException)
            {
            }
        }
Ejemplo n.º 9
0
        public void TestBackgroundUploadNullPath()
        {
            var connectClient = new LiveConnectClient(new LiveConnectSession());

            try
            {
                var uploadLocation = new Uri("/shared/transfers/uploadLocation.txt", UriKind.RelativeOrAbsolute);
                connectClient.BackgroundUploadAsync(
                    null,
                    uploadLocation,
                    OverwriteOption.Overwrite);
                Assert.Fail("Expected ArguementException to be thrown.");
            }
            catch (ArgumentException)
            {
            }
        }
Ejemplo n.º 10
0
        /// <summary>
        /// Upload a file to OneDrive
        /// </summary>
        /// <param name="Filename"></param>
        /// <param name="Content"></param>
        /// <returns></returns>
        public static async Task <int> UploadFileAsync(String Foldername, String Filename)
        {
            try
            {
                //  create OneDrive auth client
                var authClient = new LiveAuthClient();

                //  ask for both read and write access to the OneDrive
                LiveLoginResult result = await authClient.LoginAsync(new string[] { "wl.signin", "wl.skydrive", "wl.skydrive_update" });

                //  if login successful
                if (result.Status == LiveConnectSessionStatus.Connected)
                {
                    //  create a OneDrive client
                    liveClient = new LiveConnectClient(result.Session);

                    //  create a local file
                    StorageFile file = await ApplicationData.Current.LocalFolder.GetFileAsync(Filename);

                    //  create a folder
                    string folderID = await GetFolderIDAsync(Foldername, true);

                    if (string.IsNullOrEmpty(folderID))
                    {
                        //  return error
                        return(0);
                    }

                    //  upload local file to OneDrive
                    await liveClient.BackgroundUploadAsync(folderID, file.Name, file, OverwriteOption.Overwrite);

                    return(1);
                }
            }
            catch (Exception e)
            {
                return(e.Message.Length);
            }

            //  return error
            return(0);
        }
Ejemplo n.º 11
0
        private async void fileUpload_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                var picker = new Windows.Storage.Pickers.FileOpenPicker();
                picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail;
                picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.PicturesLibrary;
                picker.FileTypeFilter.Add(".png");
                Windows.Storage.StorageFile file = await picker.PickSingleFileAsync();

                if (file != null)
                {
                    LiveConnectClient liveClient = new LiveConnectClient(((App)Application.Current).LiveSession);
                    await liveClient.BackgroundUploadAsync("me/skydrive", "MyUploadedPicture.pnsg", file, OverwriteOption.Overwrite);
                }
            }
            catch (LiveConnectException)
            {
                // Handle exceptions.
            }
        }
Ejemplo n.º 12
0
        private async Task DoBackup(string filename)
        {
            if (await SignInSkydrive())
            {
                await LoadData();

                StorageFile backupFile = await ApplicationData.Current.LocalFolder.GetFileAsync(filename);

                if (backupFile != null && _skyDriveFolderId != null)
                {
                    LiveConnectClient   client          = new LiveConnectClient(_session);
                    LiveOperationResult operationResult =
                        await
                        client.BackgroundUploadAsync(_skyDriveFolderId, filename, backupFile,
                                                     OverwriteOption.Overwrite);

                    dynamic result = operationResult.Result;
                }
                else
                {
                    throw new Exception();
                }
            }
        }
Ejemplo n.º 13
0
        /// <summary>
        /// Uploads selected files to skydrive
        /// </summary>
        /// <returns></returns>
        public static async Task UploadFilesAsync(Progress <LiveOperationProgress> progress)
        {
            await CheckIfExists();

            var picker = new Windows.Storage.Pickers.FileOpenPicker();

            picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.MusicLibrary;
            picker.FileTypeFilter.Add(".bbf");
            picker.FileTypeFilter.Add(".mp3");
            picker.FileTypeFilter.Add(".wav");
            picker.FileTypeFilter.Add(".aac");
            IReadOnlyList <Windows.Storage.StorageFile> files = await picker.PickMultipleFilesAsync();

            if (files.Count > 0)
            {
                OneDriveManager.CancelToken = new System.Threading.CancellationTokenSource();
                foreach (var file in files)
                {
                    await _client.BackgroundUploadAsync(OneDriveManager._folderId,
                                                        file.Name, file, Microsoft.Live.OverwriteOption.Overwrite, OneDriveManager.CancelToken.Token, progress);
                }
                OneDriveManager.CancelToken = null;
            }
        }
Ejemplo n.º 14
0
        private void uploadFile()
        {
            if (String.IsNullOrEmpty(_skyDriveFolderID))
            {
                return;
            }

            Dispatcher.BeginInvoke(() =>
            {
                ApplicationTitle.Text = "Subiendo a Skydrive...";
            });

            this.client.BackgroundUploadCompleted += client_BackgroundUploadCompleted;

            // Upload file
            try
            {
                client.BackgroundUploadAsync(_skyDriveFolderID, new Uri(filename, UriKind.Relative), OverwriteOption.Overwrite);
            }
            catch (Exception e)
            {
                MessageBox.Show(e.Message);
            }
        }
 public void TestUploadEmptyStringPath()
 {
     var connectClient = new LiveConnectClient(new LiveConnectSession());
     try
     {
         connectClient.BackgroundUploadAsync(
             string.Empty, 
             "fileName.txt", 
             new InMemoryRandomAccessStream(), 
             OverwriteOption.Overwrite);
         Assert.Fail("Expected ArguementException to be thrown.");
     }
     catch (ArgumentException)
     {
     }
 }
Ejemplo n.º 16
0
 async public Task uploadFileBackground(String folderId, Uri localFileUri)
 {
     LiveOperationResult res = await liveConnect.BackgroundUploadAsync(folderId, localFileUri, OverwriteOption.Overwrite);
 }
 public void TestBackgroundUploadNullPath()
 {
     var connectClient = new LiveConnectClient(new LiveConnectSession());
     try
     {
         var uploadLocation = new Uri("/shared/transfers/uploadLocation.txt", UriKind.RelativeOrAbsolute);
         connectClient.BackgroundUploadAsync(
             null,
             uploadLocation,
             OverwriteOption.Overwrite);
         Assert.Fail("Expected ArguementException to be thrown.");
     }
     catch (ArgumentException)
     {
     }
 }