private async static Task<string> GetResponseMessage(UploadOperation uploadOperation)
{
ResponseInformation responseInformation = uploadOperation.GetResponseInformation();
//uint contentLength = Convert.ToUInt32(responseInformation.Headers["Content-Length"]);
uint contentLength = (uint)uploadOperation.Progress.BytesReceived;
uint statusCode = responseInformation.StatusCode;
IInputStream resultStreamAt = uploadOperation.GetResultStreamAt(0);
IBuffer result = await resultStreamAt.ReadAsync(
new Windows.Storage.Streams.Buffer(contentLength),
contentLength,
InputStreamOptions.None);
Stream responseStream = result.AsStream();
XDocument xDocument = XDocument.Load(responseStream);
foreach (XElement xe in xDocument.Root.Descendants())
{
if (xe.Name.LocalName.Equals("Ok"))
{
return "SUCCESS";
}
if (xe.Name.LocalName.Equals("Error"))
{
return xe.Value;
}
}
return "Unspecified error submiting video";
}
private async Task UploadProgress(UploadOperation obj)
{
Debug.WriteLine(obj.Progress.BytesSent * 100 / obj.Progress.TotalBytesToSend);
if (obj.Progress.HasResponseChanged)
{
var stream = obj.GetResultStreamAt(0);
var reader = new StreamReader(stream.AsStreamForRead());
var results = await reader.ReadToEndAsync();
var image = JsonConvert.DeserializeObject<ImageResponse>(results);
//<?xml version="1.0" encoding="utf-8"?><rsp stat="ok"><method>smugmug.images.upload</method><Image id="2125852928" Key="R6bnfnM" URL="http://photos.jenkinsfamily.com.au/Other/Nat/25253579_mbht3D#2125852928_R6bnfnM"/></rsp>
}
}
/// <summary>
/// Called when a progress event is raised from the BT.UploadOperation and this
/// will call this TailoredUploadOperation's progress handler.
/// </summary>
private void OnUploadProgress(BT.UploadOperation uploadOp)
{
Debug.Assert(uploadOp != null);
if (uploadOp.Progress.Status == BT.BackgroundTransferStatus.Error ||
uploadOp.Progress.Status == BT.BackgroundTransferStatus.Canceled ||
this.isAttach ||
this.Progress == null)
{
return;
}
this.Progress.Report(
new LiveOperationProgress(
(long)uploadOp.Progress.BytesSent,
(long)uploadOp.Progress.TotalBytesToSend));
}
public async void Attach(BT.UploadOperation uploadOp)
{
Debug.Assert(uploadOp != null);
this.uploadOp = uploadOp;
this.isAttach = true;
this.uploadOpCts = new CancellationTokenSource();
var progressHandler = new Progress <BT.UploadOperation>(this.OnUploadProgress);
try
{
// Since we don't provide API for apps to attach to pending upload operations, we have no
// way to invoke the app event handler to provide any feedback. We would just ignore the result here.
this.uploadOp = await this.uploadOp.AttachAsync().AsTask(this.uploadOpCts.Token, progressHandler);
}
catch
{
// Ignore errors as well.
}
}
private bool IsExceptionHandled(string title, Exception ex, UploadOperation upload = null)
{
WebErrorStatus error = BackgroundTransferError.GetStatus(ex.HResult);
if (error == WebErrorStatus.Unknown)
{
return false;
}
if (upload == null)
{
LogStatus(String.Format(CultureInfo.CurrentCulture, "Error: {0}: {1}", title, error),
NotifyType.ErrorMessage);
}
else
{
LogStatus(String.Format(CultureInfo.CurrentCulture, "Error: {0} - {1}: {2}", upload.Guid, title,
error), NotifyType.ErrorMessage);
}
return true;
}
private async Task HandleUploadAsync(UploadOperation upload, bool start)
{
try
{
LogStatus("Running: " + upload.Guid, NotifyType.StatusMessage);
Progress<UploadOperation> progressCallback = new Progress<UploadOperation>(UploadProgress);
if (start)
{
// Start the upload and attach a progress handler.
await upload.StartAsync().AsTask(cts.Token, progressCallback);
}
else
{
// The upload was already running when the application started, re-attach the progress handler.
await upload.AttachAsync().AsTask(cts.Token, progressCallback);
}
ResponseInformation response = upload.GetResponseInformation();
LogStatus(String.Format(CultureInfo.CurrentCulture, "Completed: {0}, Status Code: {1}", upload.Guid,
response.StatusCode), NotifyType.StatusMessage);
}
catch (TaskCanceledException)
{
LogStatus("Canceled: " + upload.Guid, NotifyType.StatusMessage);
}
catch (Exception ex)
{
if (!IsExceptionHandled("Error", ex, upload))
{
throw;
}
}
}
// Note that this event is invoked on a background thread, so we cannot access the UI directly.
private void UploadProgress(UploadOperation upload)
{
MarshalLog(String.Format(CultureInfo.CurrentCulture, "Progress: {0}, Status: {1}", upload.Guid,
upload.Progress.Status));
BackgroundUploadProgress progress = upload.Progress;
double percentSent = 100;
if (progress.TotalBytesToSend > 0)
{
percentSent = progress.BytesSent * 100 / progress.TotalBytesToSend;
}
MarshalLog(String.Format(CultureInfo.CurrentCulture,
" - Sent bytes: {0} of {1} ({2}%), Received bytes: {3} of {4}", progress.BytesSent,
progress.TotalBytesToSend, percentSent, progress.BytesReceived, progress.TotalBytesToReceive));
if (progress.HasRestarted)
{
MarshalLog(" - Upload restarted");
}
if (progress.HasResponseChanged)
{
// We've received new response headers from the server.
MarshalLog(" - Response updated; Header count: " + upload.GetResponseInformation().Headers.Count);
// If you want to stream the response data this is a good time to start.
// upload.GetResultStreamAt(0);
}
}
private async Task HandleUploadAsync(UploadOperation upload, bool start)
{
try
{
CancellationTokenSource cts = new CancellationTokenSource();
Progress<UploadOperation> progressCallback = new Progress<UploadOperation>();
if (start)
{
// Start the upload and attach a progress handler.
await upload.StartAsync().AsTask(cts.Token, progressCallback);
}
else
{
// The upload was already running when the application started, re-attach the progress handler.
await upload.AttachAsync().AsTask(cts.Token, progressCallback);
}
ResponseInformation response = upload.GetResponseInformation();
// Log(String.Format("Completed: {0}, Status Code: {1}", upload.Guid, response.StatusCode));
}
catch (TaskCanceledException)
{
// Log("Upload cancelled.");
}
catch (Exception ex)
{
//LogException("Error", ex);
}
}
/// <summary>
/// Initializes a new instance of LiveUplaodOperation class.
/// </summary>
/// <param name="uploadOperaton"></param>
internal LiveUploadOperation(UploadOperation uploadOperation)
{
this.uploadOperation = uploadOperation;
}
private async void OnGetUploadLinkCompleted(LiveOperationResult result)
{
if (this.Status == OperationStatus.Cancelled)
{
base.OnCancel();
return;
}
if (result.Error != null || result.IsCancelled)
{
this.OnOperationCompleted(result);
return;
}
var uploadUrl = new Uri(result.RawResult, UriKind.Absolute);
// NOTE: the GetUploadLinkOperation will return a uri with the overwite, suppress_response_codes,
// and suppress_redirect query parameters set.
Debug.Assert(uploadUrl.Query != null);
Debug.Assert(uploadUrl.Query.Contains(QueryParameters.Overwrite));
Debug.Assert(uploadUrl.Query.Contains(QueryParameters.SuppressRedirects));
Debug.Assert(uploadUrl.Query.Contains(QueryParameters.SuppressResponseCodes));
var uploader = new BT.BackgroundUploader();
uploader.Group = LiveConnectClient.LiveSDKUploadGroup;
if (this.LiveClient.Session != null)
{
uploader.SetRequestHeader(
ApiOperation.AuthorizationHeader,
AuthConstants.BearerTokenType + " " + this.LiveClient.Session.AccessToken);
}
uploader.SetRequestHeader(ApiOperation.LibraryHeader, Platform.GetLibraryHeaderValue());
uploader.Method = HttpMethods.Put;
this.uploadOpCts = new CancellationTokenSource();
Exception webError = null;
LiveOperationResult opResult = null;
try
{
if (this.InputStream != null)
{
this.uploadOp = await uploader.CreateUploadFromStreamAsync(uploadUrl, this.InputStream);
}
else
{
this.uploadOp = uploader.CreateUpload(uploadUrl, this.InputFile);
}
var progressHandler = new Progress<BT.UploadOperation>(this.OnUploadProgress);
this.uploadOp = await this.uploadOp.StartAsync().AsTask(this.uploadOpCts.Token, progressHandler);
}
catch (TaskCanceledException exception)
{
opResult = new LiveOperationResult(exception, true);
}
catch (Exception exp)
{
// This might be an server error. We will read the response to determine the error message.
webError = exp;
}
if (opResult == null)
{
try
{
IInputStream responseStream = this.uploadOp.GetResultStreamAt(0);
if (responseStream == null)
{
var error = new LiveConnectException(
ApiOperation.ApiClientErrorCode,
ResourceHelper.GetString("ConnectionError"));
opResult = new LiveOperationResult(error, false);
}
else
{
var reader = new DataReader(responseStream);
uint length = await reader.LoadAsync(MaxUploadResponseLength);
opResult = ApiOperation.CreateOperationResultFrom(reader.ReadString(length), ApiMethod.Upload);
if (webError != null && opResult.Error != null && !(opResult.Error is LiveConnectException))
{
// If the error did not come from the api service,
// we'll just return the error thrown by the uploader.
opResult = new LiveOperationResult(webError, false);
}
}
}
catch (COMException exp)
{
opResult = new LiveOperationResult(exp, false);
}
catch (FileNotFoundException exp)
{
opResult = new LiveOperationResult(exp, false);
}
}
this.OnOperationCompleted(opResult);
}
public async void Attach(BT.UploadOperation uploadOp)
{
Debug.Assert(uploadOp != null);
this.uploadOp = uploadOp;
this.isAttach = true;
this.uploadOpCts = new CancellationTokenSource();
var progressHandler = new Progress<BT.UploadOperation>(this.OnUploadProgress);
try
{
// Since we don't provide API for apps to attach to pending upload operations, we have no
// way to invoke the app event handler to provide any feedback. We would just ignore the result here.
this.uploadOp = await this.uploadOp.AttachAsync().AsTask(this.uploadOpCts.Token, progressHandler);
}
catch
{
// Ignore errors as well.
}
}
// Note that this event is invoked on a background thread, so we cannot access the UI directly.
private void UploadProgress(UploadOperation upload)
{
// UploadOperation.Progress is updated in real-time while the operation is ongoing. Therefore,
// we must make a local copy at the beginning of the progress handler, so that we can have a consistent
// view of that ever-changing state throughout the handler's lifetime.
BackgroundUploadProgress currentProgress = upload.Progress;
MarshalLog(String.Format(CultureInfo.CurrentCulture, "Progress: {0}, Status: {1}", upload.Guid,
currentProgress.Status));
double percentSent = 100;
if (currentProgress.TotalBytesToSend > 0)
{
percentSent = currentProgress.BytesSent * 100 / currentProgress.TotalBytesToSend;
}
MarshalLog(String.Format(CultureInfo.CurrentCulture,
" - Sent bytes: {0} of {1} ({2}%), Received bytes: {3} of {4}", currentProgress.BytesSent,
currentProgress.TotalBytesToSend, percentSent, currentProgress.BytesReceived, currentProgress.TotalBytesToReceive));
if (currentProgress.HasRestarted)
{
MarshalLog(" - Upload restarted");
}
if (currentProgress.HasResponseChanged)
{
// We've received new response headers from the server.
MarshalLog(" - Response updated; Header count: " + upload.GetResponseInformation().Headers.Count);
// If you want to stream the response data this is a good time to start.
// upload.GetResultStreamAt(0);
}
}
private async void OnGetUploadLinkCompleted(LiveOperationResult result)
{
if (this.Status == OperationStatus.Cancelled)
{
base.OnCancel();
return;
}
if (result.Error != null || result.IsCancelled)
{
this.OnOperationCompleted(result);
return;
}
var uploadUrl = new Uri(result.RawResult, UriKind.Absolute);
// NOTE: the GetUploadLinkOperation will return a uri with the overwite, suppress_response_codes,
// and suppress_redirect query parameters set.
Debug.Assert(uploadUrl.Query != null);
Debug.Assert(uploadUrl.Query.Contains(QueryParameters.Overwrite));
Debug.Assert(uploadUrl.Query.Contains(QueryParameters.SuppressRedirects));
Debug.Assert(uploadUrl.Query.Contains(QueryParameters.SuppressResponseCodes));
var uploader = new BT.BackgroundUploader();
uploader.Group = LiveConnectClient.LiveSDKUploadGroup;
if (this.LiveClient.Session != null)
{
uploader.SetRequestHeader(
ApiOperation.AuthorizationHeader,
AuthConstants.BearerTokenType + " " + this.LiveClient.Session.AccessToken);
}
uploader.SetRequestHeader(ApiOperation.LibraryHeader, Platform.GetLibraryHeaderValue());
uploader.Method = HttpMethods.Put;
this.uploadOpCts = new CancellationTokenSource();
Exception webError = null;
LiveOperationResult opResult = null;
try
{
if (this.InputStream != null)
{
this.uploadOp = await uploader.CreateUploadFromStreamAsync(uploadUrl, this.InputStream);
}
else
{
this.uploadOp = uploader.CreateUpload(uploadUrl, this.InputFile);
}
var progressHandler = new Progress <BT.UploadOperation>(this.OnUploadProgress);
this.uploadOp = await this.uploadOp.StartAsync().AsTask(this.uploadOpCts.Token, progressHandler);
}
catch (TaskCanceledException exception)
{
opResult = new LiveOperationResult(exception, true);
}
catch (Exception exp)
{
// This might be an server error. We will read the response to determine the error message.
webError = exp;
}
if (opResult == null)
{
try
{
IInputStream responseStream = this.uploadOp.GetResultStreamAt(0);
if (responseStream == null)
{
var error = new LiveConnectException(
ApiOperation.ApiClientErrorCode,
ResourceHelper.GetString("ConnectionError"));
opResult = new LiveOperationResult(error, false);
}
else
{
var reader = new DataReader(responseStream);
uint length = await reader.LoadAsync(MaxUploadResponseLength);
opResult = this.CreateOperationResultFrom(reader.ReadString(length));
if (webError != null && opResult.Error != null && !(opResult.Error is LiveConnectException))
{
// If the error did not come from the api service,
// we'll just return the error thrown by the uploader.
opResult = new LiveOperationResult(webError, false);
}
}
}
catch (COMException exp)
{
opResult = new LiveOperationResult(exp, false);
}
catch (FileNotFoundException exp)
{
opResult = new LiveOperationResult(exp, false);
}
}
this.OnOperationCompleted(opResult);
}
/// <summary>
/// Start uplaod and create handler.
/// </summary>
/// <param name="upload">UploadOperation handled.</param>
/// <param name="start">Whether uplaod is started.</param>
/// <returns>
/// Represent the asynchronous operation.
/// </returns>
private async Task HandleUploadAsync(UploadOperation upload, bool start)
{
try
{
try
{
Progress<UploadOperation> progressCallback = new Progress<UploadOperation>(UploadProgress);
if (start)
{
// Start the upload and attach a progress handler.
await upload.StartAsync().AsTask(cts.Token, progressCallback);
}
else
{
// The upload was already running when the application started, re-attach the progress handler.
await upload.AttachAsync().AsTask(cts.Token, progressCallback);
}
}
catch
{
ShowMessageDialog("Error90! Upload canceled.");
}
ResponseInformation response = upload.GetResponseInformation();
foreach (var c in response.Headers)
{
System.Diagnostics.Debug.WriteLine("{0}, {1}. markkkkkkkk", c.Key, c.Value);
}
if (images != null && images.Count != 0 && hasImage == false)
{
toBeUploadCourse.ImageUri = response.Headers[images.FirstOrDefault().Name];
hasImage = true;
}
SaveUploadLessonToListAsync(response);
}
catch (TaskCanceledException)
{
ShowMessageDialog("Error9! Upload canceled.");
}
catch
{
ShowMessageDialog("Error10! Upload canceled.");
//throw;
}
}
/// <summary>
/// Event is invoked on a background thread.
/// </summary>
/// <param name="upload">UploadOperation.</param>
private void UploadProgress(UploadOperation upload)
{
// Progress: upload.Guid; Statues: uplaod.Progress.Status
BackgroundUploadProgress progress = upload.Progress;
double percentSend = 100;
if (progress.TotalBytesToSend > 0)
{
percentSend = progress.BytesSent * 100 / progress.TotalBytesToSend;
}
// Send bytes: progress.BytesSend of progress.TotalBytesSend (percentSend%)
// Received bytes: progress.BytesReceived of progress.TotalBytesToReceive
if (progress.HasRestarted)
{
// Upload restarted
System.Diagnostics.Debug.WriteLine("Upload restarted");
}
if (progress.HasResponseChanged)
{
// Response updated; Header count: upload.GetResponseInformation().Headers.Count
}
}
