public static async Task<string> UploadImageAsync(Stream imageStream)
{
CloudStorageAccount account = new CloudStorageAccount(
useHttps: true,
storageCredentials: new Microsoft.WindowsAzure.Storage.Auth.StorageCredentials(
accountName: Constants.StorageAccountName,
keyValue: Constants.StorageAccessKey)
);
try
{
var blobClient = account.CreateCloudBlobClient();
var container = blobClient.GetContainerReference("visitors");
var blob = container.GetBlockBlobReference(Guid.NewGuid().ToString() + ".jpg");
using (var stream = imageStream.AsInputStream())
{
await blob.UploadFromStreamAsync(stream);
}
return blob.Uri.ToString();
}
catch (Exception ex)
{
return null;
}
}
public async static Task<byte[]> getBytes(Stream stream)
{
IInputStream inputStream = stream.AsInputStream();
DataReader dataReader = new DataReader(inputStream);
await dataReader.LoadAsync((uint)stream.Length);
byte[] buffer = new byte[(int)stream.Length];
dataReader.ReadBytes(buffer);
return buffer;
}
/// <summary>
/// Write the contents of stream to filename in the cache location. If a null stream is provided, the file is created with no contents.
/// </summary>
/// <param name="stream">Content to be written to file</param>
/// <param name="filename">Name of the file to be written in cache location</param>
private static async Task WriteFileAsync(Stream stream, string filename)
{
// Prepare output file stream
StorageFolder parent = GetCacheFolder();
StorageFile file = null;
try
{
file = await parent.CreateFileAsync(filename, CreationCollisionOption.ReplaceExisting);
}
catch (Exception)
{
}
if (file != null && stream != null)
{
// Prepare input image stream
IInputStream inStream = stream.AsInputStream();
DataReader reader = new DataReader(inStream);
IRandomAccessStream fileStream = null;
try
{
fileStream = await file.OpenAsync(FileAccessMode.ReadWrite);
// Buffered write to file
await reader.LoadAsync(1024);
while (reader.UnconsumedBufferLength > 0)
{
await fileStream.WriteAsync(reader.ReadBuffer(reader.UnconsumedBufferLength));
await reader.LoadAsync(1024);
}
}
catch (Exception)
{
}
finally
{
if (fileStream != null)
{
fileStream.FlushAsync();
}
}
inStream.Dispose();
}
}
protected override async void init(Stream stream, bool flip, Loader.LoadedCallbackMethod loadedCallback)
{
try
{
using (var memoryStream = new InMemoryRandomAccessStream())
{
await RandomAccessStream.CopyAsync(stream.AsInputStream(), memoryStream);
var decoder = await BitmapDecoder.CreateAsync(memoryStream);
var frame = await decoder.GetFrameAsync(0);
var transform = new BitmapTransform();
transform.InterpolationMode = BitmapInterpolationMode.NearestNeighbor;
transform.Rotation = BitmapRotation.None;
var dataProvider = await decoder.GetPixelDataAsync(BitmapPixelFormat.Rgba8, BitmapAlphaMode.Straight, transform, ExifOrientationMode.IgnoreExifOrientation, ColorManagementMode.ColorManageToSRgb);
var data = dataProvider.DetachPixelData();
int width = (int)decoder.PixelWidth;
int height = (int)decoder.PixelHeight;
Mipmaps = new Mipmap[1];
Size = new Size2(width, height);
Mipmaps[0] = new Mipmap(data, width, height, 1, 4);
if (flip) Mipmaps[0].FlipVertical();
}
}
catch (Exception e)
{
FailedToLoad = true;
Loader.AddLoadableException(e);
if (loadedCallback != null) loadedCallback(this, false);
return;
}
Loaded = true;
if (loadedCallback != null) loadedCallback(this, 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);
}
private async void btn_Random_Click(object sender, RoutedEventArgs e)
{
try
{
pr_Load.Visibility = Visibility.Visible;
Uri uri = new Uri("ms-appx:///Assets/avatar/ic_avatar" + new Random().Next(1, 12) + ".jpg");
RandomAccessStreamReference streamRef = RandomAccessStreamReference.CreateFromUri(uri);
Windows.Storage.Streams.Buffer buffer = null;
using (IRandomAccessStreamWithContentType fileStream = await streamRef.OpenReadAsync())
{
buffer = new Windows.Storage.Streams.Buffer((uint)fileStream.Size);
await fileStream.ReadAsync(buffer, (uint)fileStream.Size, InputStreamOptions.None);
}
Stream stream = WindowsRuntimeBufferExtensions.AsStream(buffer);
string resutls = "";
// resutls = await WebClientClass.PostResults(new Uri(string.Format("https://account.bilibili.com/pendant/updateFace?type=jpg&size=s")), stream.AsInputStream(), "https://account.bilibili.com/site/updateface.html?type=face");
// resutls = await WebClientClass.PostResults(new Uri(string.Format("https://account.bilibili.com/pendant/updateFace?type=jpg&size=m")), stream.AsInputStream(), "https://account.bilibili.com/site/updateface.html?type=face");
resutls = await WebClientClass.PostResults(new Uri(string.Format("https://account.bilibili.com/pendant/updateFace?type=jpg&size=l")), stream.AsInputStream(), "https://account.bilibili.com/site/updateface.html?type=face");
JObject obj = JObject.Parse(resutls);
if (obj["state"].ToString() == "OK")
{
MessageCenter.SendLogined();
Utils.ShowMessageToast("头像更换成功", 3000);
}
else
{
Utils.ShowMessageToast("头像更换失败", 3000);
}
}
catch (Exception ex)
{
Utils.ShowMessageToast("头像更换失败\r\n" + ex.Message, 3000);
}
finally
{
pr_Load.Visibility = Visibility.Collapsed;
GetProfile();
}
}
// Summary:
// Upload files by output stream.
//
// Parameters:
// sourceFolderId:
// The id of the place you want to upload.
//
// fileName:
// The name you want to use after upload.
//
// Returns:
// The StorageFolder where you downloaded folder.
public async Task<bool> UploadFileStreamAsync(string folderIdToStore, string fileName, Stream outstream)
{
//ProgressBar progressBar = new ProgressBar();
//progressBar.Value = 0;
//var progressHandler = new Progress<LiveOperationProgress>(
// (progress) => { progressBar.Value = progress.ProgressPercentage; });
System.Threading.CancellationTokenSource ctsUpload = new System.Threading.CancellationTokenSource();
try
{
//LiveOperationResult result = await this.LiveClient
// .UploadAsync(folderIdToStore, fileName, outstream, OverwriteOption.Overwrite, ctsUpload.Token, progressHandler);
LiveOperationResult result = await this.LiveClient.BackgroundUploadAsync(folderIdToStore, fileName, outstream.AsInputStream(), OverwriteOption.Overwrite);
}
catch
{
ctsUpload.Cancel();
throw new ShareException(fileName, ShareException.ShareType.UPLOAD);
}
return true;
}
#pragma warning disable 4014
/// <summary>
/// Starts an asynchronous PutBlock operation as soon as the parallel
/// operation semaphore becomes available.
/// </summary>
/// <param name="blockData">Data to be uploaded</param>
/// <param name="blockId">Block ID</param>
/// <returns>A task that represents the asynchronous write operation.</returns>
/// <remarks>Warning CS4014 is disabled here, since we intentionally do not
/// await PutBlockAsync call.</remarks>
private async Task WriteBlockAsync(Stream blockData, string blockId, string blockMD5)
{
Interlocked.Increment(ref this.pendingWrites);
this.noPendingWritesEvent.Reset();
await this.parallelOperationSemaphore.WaitAsync();
// Without await have found last block doesn't get uploaded properly and noPendingWritesEvent will always equal 1.
// Then the putblocklist will never happen, therefore no blob. Bug #211
await this.blockBlob.PutBlockAsync(blockId, blockData.AsInputStream(), blockMD5, this.accessCondition, this.options, this.operationContext).AsTask().ContinueWith(task =>
{
if (task.Exception != null)
{
this.lastException = task.Exception;
}
if (Interlocked.Decrement(ref this.pendingWrites) == 0)
{
this.noPendingWritesEvent.Set();
}
this.parallelOperationSemaphore.Release();
});
}
public JsonStreamCommandReader(Stream stream)
{
_dataReader = new DataReader(stream.AsInputStream());
}
/// <summary>
/// Starts an asynchronous AppendBlock operation as soon as the parallel
/// operation semaphore becomes available. Since parallelism is always set
/// to 1 for append blobs, appendblock operations are called serially.
/// </summary>
/// <param name="blockData">Data to be uploaded</param>
/// <param name="offset">Offset within the append blob to be used to set the append offset conditional header.</param>
/// <param name="blockMD5">MD5 hash of the data to be uploaded</param>
/// <returns>A task that represents the asynchronous write operation.</returns>
private async Task WriteAppendBlockAsync(Stream blockData, long offset, string blockMD5)
{
this.noPendingWritesEvent.Increment();
await this.parallelOperationSemaphore.WaitAsync();
this.accessCondition.IfAppendPositionEqual = offset;
int previousResultsCount = this.operationContext.RequestResults.Count;
Task writeBlockTask = this.appendBlob.AppendBlockAsync(blockData.AsInputStream(), blockMD5, this.accessCondition, this.options, this.operationContext).AsTask().ContinueWith(task =>
{
if (task.Exception != null)
{
if (this.options.AbsorbConditionalErrorsOnRetry.Value
&& this.operationContext.LastResult.HttpStatusCode == (int)HttpStatusCode.PreconditionFailed)
{
StorageExtendedErrorInformation extendedInfo = this.operationContext.LastResult.ExtendedErrorInformation;
if (extendedInfo != null
&& (extendedInfo.ErrorCode == BlobErrorCodeStrings.InvalidAppendCondition || extendedInfo.ErrorCode == BlobErrorCodeStrings.InvalidMaxBlobSizeCondition)
&& (this.operationContext.RequestResults.Count - previousResultsCount > 1))
{
// Pre-condition failure on a retry should be ignored in a single writer scenario since the request
// succeeded in the first attempt.
Logger.LogWarning(this.operationContext, SR.PreconditionFailureIgnored);
}
else
{
this.lastException = task.Exception;
}
}
else
{
this.lastException = task.Exception;
}
}
this.noPendingWritesEvent.Decrement();
this.parallelOperationSemaphore.Release();
});
}
/// <summary>
/// Helper method used for saving the content of a response to a file.
/// This allows unittests to easily generate real data to use as mock responses.
/// </summary>
/// <param name="endpoint">API endpoint we are calling.</param>
/// <param name="directory">Directory to store our file.</param>
/// <param name="httpMethod">The http method to be performed.</param>
/// <param name="requestBody">An optional stream to use for the request body content.</param>
/// <param name="requestBodyContentType">The content type of the request stream.</param>
/// <returns>Task waiting for HTTP call to return and file copy to complete.</returns>
public async Task SaveEndpointResponseToFile(
string endpoint,
string directory,
HttpMethods httpMethod,
Stream requestBody = null,
string requestBodyContentType = null)
{
Uri uri = new Uri(this.deviceConnection.Connection, endpoint);
// Convert the OS version, such as 14385.1002.amd64fre.rs1_xbox_rel_1608.160709-1700, into a friendly OS version, such as rs1_xbox_rel_1608
string friendlyOSVersion = this.OperatingSystemVersion;
string[] versionParts = friendlyOSVersion.Split('.');
if (versionParts.Length == ExpectedOSVersionSections)
{
friendlyOSVersion = versionParts[TargetOSVersionSection];
}
// Create the filename as DeviceFamily_OSVersion.dat, replacing '/', '.', and '-' with '_' so
// we can create a class with the same name as this Device/OS pair for tests.
string filename = endpoint + "_" + this.Platform.ToString() + "_" + friendlyOSVersion;
if (httpMethod != HttpMethods.Get)
{
filename = httpMethod.ToString() + "_" + filename;
}
Utilities.ModifyEndpointForFilename(ref filename);
filename += ".dat";
string filepath = Path.Combine(directory, filename);
if (HttpMethods.WebSocket == httpMethod)
{
#if WINDOWS_UWP
WebSocket <object> websocket = new WebSocket <object>(this.deviceConnection, true);
#else
WebSocket <object> websocket = new WebSocket <object>(this.deviceConnection, this.ServerCertificateValidation, true);
#endif // WINDOWS_UWP
ManualResetEvent streamReceived = new ManualResetEvent(false);
Stream stream = null;
WindowsDevicePortal.WebSocketStreamReceivedEventInternalHandler <object> streamReceivedHandler =
delegate(WebSocket <object> sender, WebSocketMessageReceivedEventArgs <Stream> args)
{
if (args.Message != null)
{
stream = args.Message;
streamReceived.Set();
}
};
websocket.WebSocketStreamReceived += streamReceivedHandler;
Task startListeningForStreamTask = websocket.StartListeningForMessages(endpoint);
startListeningForStreamTask.Wait();
streamReceived.WaitOne();
Task stopListeningForStreamTask = websocket.StopListeningForMessages();
stopListeningForStreamTask.Wait();
websocket.WebSocketStreamReceived -= streamReceivedHandler;
using (stream)
{
using (var fileStream = File.Create(filepath))
{
stream.Seek(0, SeekOrigin.Begin);
stream.CopyTo(fileStream);
}
}
}
else if (HttpMethods.Put == httpMethod)
{
#if WINDOWS_UWP
HttpStreamContent streamContent = null;
#else
StreamContent streamContent = null;
#endif // WINDOWS_UWP
if (requestBody != null)
{
#if WINDOWS_UWP
streamContent = new HttpStreamContent(requestBody.AsInputStream());
streamContent.Headers.ContentType = new HttpMediaTypeHeaderValue(requestBodyContentType);
#else
streamContent = new StreamContent(requestBody);
streamContent.Headers.ContentType = new MediaTypeHeaderValue(requestBodyContentType);
#endif // WINDOWS_UWP
}
using (Stream dataStream = await this.Put(uri, streamContent))
{
using (var fileStream = File.Create(filepath))
{
dataStream.Seek(0, SeekOrigin.Begin);
dataStream.CopyTo(fileStream);
}
}
}
else if (HttpMethods.Post == httpMethod)
{
using (Stream dataStream = await this.Post(uri, requestBody, requestBodyContentType))
{
using (var fileStream = File.Create(filepath))
{
dataStream.Seek(0, SeekOrigin.Begin);
dataStream.CopyTo(fileStream);
}
}
}
else if (HttpMethods.Delete == httpMethod)
{
using (Stream dataStream = await this.Delete(uri))
{
using (var fileStream = File.Create(filepath))
{
dataStream.Seek(0, SeekOrigin.Begin);
dataStream.CopyTo(fileStream);
}
}
}
else if (HttpMethods.Get == httpMethod)
{
using (Stream dataStream = await this.Get(uri))
{
using (var fileStream = File.Create(filepath))
{
dataStream.Seek(0, SeekOrigin.Begin);
dataStream.CopyTo(fileStream);
}
}
}
else
{
throw new NotImplementedException(string.Format("Unsupported HttpMethod {0}", httpMethod.ToString()));
}
}
private async Task SetContactProperties(StoredContact contact, User user, User originalUser = null)
{
if (contact != null)
{
contact.RemoteId = (ContactsManager.GetRemoteId(user));
contact.GivenName = (user.first_name);
contact.FamilyName = (user.last_name);
if (!string.IsNullOrWhiteSpace(user.photo_max) && !user.photo_max.EndsWith(".gif"))
{
Stream stream = await HttpExtensions.TryGetResponseStreamAsync(user.photo_max);
if (stream == null)
{
throw new Exception("failed to download contact pic " + user.photo_max);
}
await contact.SetDisplayPictureAsync(stream.AsInputStream());
}
IDictionary <string, object> dictionary = await contact.GetPropertiesAsync();
if (!string.IsNullOrWhiteSpace(user.site))
{
dictionary[KnownContactProperties.Url] = user.site;
}
if (!string.IsNullOrWhiteSpace(user.mobile_phone) && this.IsPhoneNumber(user.mobile_phone))
{
List <string> var_6_262 = BaseFormatterHelper.ParsePhoneNumbers(user.mobile_phone);
if (var_6_262.Count >= 1)
{
dictionary[KnownContactProperties.MobileTelephone] = var_6_262[0];
}
if (var_6_262.Count >= 2)
{
dictionary[KnownContactProperties.AlternateMobileTelephone] = var_6_262[1];
}
}
if (!string.IsNullOrWhiteSpace(user.home_phone) && this.IsPhoneNumber(user.home_phone))
{
List <string> var_7_2D8 = BaseFormatterHelper.ParsePhoneNumbers(user.home_phone);
if (var_7_2D8.Count >= 1)
{
dictionary[KnownContactProperties.Telephone] = var_7_2D8[0];
}
if (var_7_2D8.Count >= 2)
{
dictionary[KnownContactProperties.AlternateTelephone] = var_7_2D8[1];
}
}
DateTime var_8;
if (!string.IsNullOrWhiteSpace(user.bdate) && ContactsManager.TryParseDateTimeFromString(user.bdate, out var_8))
{
var_8 = var_8.Add(DateTime.Now - DateTime.UtcNow);
new DateTimeOffset(var_8.Year, var_8.Month, var_8.Day, 0, 0, 0, 0, TimeSpan.Zero);
dictionary[KnownContactProperties.Birthdate] = new DateTimeOffset(var_8);
}
}
if (originalUser != null)
{
originalUser.first_name = user.first_name;
originalUser.last_name = user.last_name;
originalUser.site = user.site;
originalUser.mobile_phone = user.mobile_phone;
originalUser.home_phone = user.home_phone;
originalUser.photo_max = user.photo_max;
originalUser.bdate = user.bdate;
}
}
private async Task <IInputStream> OpenReadAsync(string key)
{
Stream stream = await m_objectStore.OpenReadStreamAsync(key);
return(stream.AsInputStream());
}
/// <summary>
/// Loads the data from an image stream and returns a new WriteableBitmap.
/// </summary>
/// <param name="stream">The stream with the image data.</param>
/// <param name="pixelFormat">The pixel format of the stream data. If Unknown is provided as param, the default format of the BitmapDecoder is used.</param>
/// <returns>A new WriteableBitmap containing the pixel data.</returns>
public static async Task<WriteableBitmap> FromStream(Stream stream, BitmapPixelFormat pixelFormat = BitmapPixelFormat.Unknown)
{
using (var dstStream = new InMemoryRandomAccessStream())
{
await RandomAccessStream.CopyAsync(stream.AsInputStream(), dstStream);
return await FromStream(dstStream);
}
}
protected override async Task <string> RequestAsync(string address, String requestData = null, Stream imageData = null)
{
try
{
if (requestData != null)
{
address += "?" + requestData;
}
UtilityHelper.CountlyLogging("POST " + address);
//make sure stream is at start
imageData?.Seek(0, SeekOrigin.Begin);
var httpResponseMessage = await Client.PostAsync(new Uri(address), (imageData != null)?new HttpStreamContent(imageData.AsInputStream()) : null);
if (httpResponseMessage.IsSuccessStatusCode)
{
return(await httpResponseMessage.Content.ReadAsStringAsync());
}
else
{
return(null);
}
}
catch (Exception ex)
{
UtilityHelper.CountlyLogging("Encountered a exception while making a POST request, " + ex.ToString());
return(null);
}
}
public IInputStream GetInputStreamAt(ulong position)
{
internstream.Position = (long)position;
return(internstream.AsInputStream());
}
#pragma warning disable CS0618
#pragma warning disable CS1998
public static async Task <bool> ImportAnchors(this WindowsMRAnchorSubsystem wmrrp, Stream input)
{
bool ret = false;
#if ENABLE_WINMD_SUPPORT
try
{
var access = await SpatialAnchorTransferManager.RequestAccessAsync();
if (access != SpatialPerceptionAccessStatus.Allowed)
{
return(ret);
}
var spatialAnchorStore = await SpatialAnchorManager.RequestStoreAsync();
if (spatialAnchorStore == null)
{
return(ret);
}
var anchors = await SpatialAnchorTransferManager.TryImportAnchorsAsync(input.AsInputStream());
foreach (var kvp in anchors)
{
spatialAnchorStore.TrySave(kvp.Key, kvp.Value);
}
ret = true;
}
catch (Exception e)
{
Debug.Log(e);
ret = false;
}
#else
Debug.LogError("This API is only available for use in UWP based applications.");
#endif //ENABLE_WINMD_SUPPORT
return(ret);
}
private static async Task <string> RequestAsync(string address, Stream data = null)
{
try
{
if (Countly.IsLoggingEnabled)
{
Debug.WriteLine("POST " + address);
}
var httpResponseMessage = await Client.PostAsync(new Uri(address), (data != null)?new HttpStreamContent(data.AsInputStream()) : null);
if (httpResponseMessage.IsSuccessStatusCode)
{
return(await httpResponseMessage.Content.ReadAsStringAsync());
}
else
{
return(null);
}
}
catch (Exception ex)
{
if (Countly.IsLoggingEnabled)
{
//Debug.WriteLine("Encountered a exception while making a POST request");
//Debug.WriteLine(ex);
}
return(null);
}
}
private async void LoadStrokesFromStream(Stream stream)
{
await inkManager.LoadAsync(stream.AsInputStream());
needToRedrawInkSurface = true;
}
public XBeeStreamWrapper(Stream stream)
{
_stream = stream;
_outputStream = _stream.AsOutputStream();
_inputStream = _stream.AsInputStream();
}
public static async void Upload(string uri, Stream data, string paramName, string uploadContentType,Action<VKHttpResult> resultCallback, Action<double> progressCallback = null, string fileName = null)
{
#if SILVERLIGHT
var rState = new RequestState();
rState.resultCallback = resultCallback;
#endif
try
{
#if SILVERLIGHT
var request = (HttpWebRequest)WebRequest.Create(uri);
request.AllowWriteStreamBuffering = false;
rState.request = request;
request.Method = "POST";
string formDataBoundary = String.Format("----------{0:N}", Guid.NewGuid());
string contentType = "multipart/form-data; boundary=" + formDataBoundary;
request.ContentType = contentType;
request.CookieContainer = new CookieContainer();
string header = string.Format("--{0}\r\nContent-Disposition: form-data; name=\"{1}\"; filename=\"{2}\";\r\nContent-Type: {3}\r\n\r\n",
formDataBoundary,
paramName,
fileName ?? "myDataFile",
uploadContentType);
string footer = "\r\n--" + formDataBoundary + "--\r\n";
request.ContentLength = Encoding.UTF8.GetByteCount(header) + data.Length + Encoding.UTF8.GetByteCount(footer);
request.BeginGetRequestStream(ar =>
{
try
{
var requestStream = request.EndGetRequestStream(ar);
requestStream.Write(Encoding.UTF8.GetBytes(header), 0, Encoding.UTF8.GetByteCount(header));
StreamUtils.CopyStream(data, requestStream, progressCallback);
requestStream.Write(Encoding.UTF8.GetBytes(footer), 0, Encoding.UTF8.GetByteCount(footer));
requestStream.Close();
request.BeginGetResponse(new AsyncCallback(ResponseCallback), rState);
}
catch (Exception ex)
{
Logger.Error("VKHttpRequestHelper.Upload failed to write data to request stream.", ex);
SafeClose(rState);
SafeInvokeCallback(rState.resultCallback, false, null);
}
}, null);
#else
var httpClient = new Windows.Web.Http.HttpClient();
HttpMultipartFormDataContent content = new HttpMultipartFormDataContent();
content.Add(new HttpStreamContent(data.AsInputStream()), paramName, fileName ?? "myDataFile");
content.Headers.Add("Content-Type", uploadContentType);
var postAsyncOp = httpClient.PostAsync(new Uri(uri, UriKind.Absolute),
content);
postAsyncOp.Progress = (r, progress) =>
{
if (progressCallback != null && progress.TotalBytesToSend.HasValue && progress.TotalBytesToSend > 0)
{
progressCallback(((double)progress.BytesSent * 100) / progress.TotalBytesToSend.Value);
}
};
var result = await postAsyncOp;
var resultStr = await result.Content.ReadAsStringAsync();
SafeInvokeCallback(resultCallback, result.IsSuccessStatusCode, resultStr);
#endif
}
catch (Exception exc)
{
Logger.Error("VKHttpRequestHelper.Upload failed.", exc);
#if SILVERLIGHT
SafeClose(rState);
SafeInvokeCallback(rState.resultCallback, false, null);
#else
SafeInvokeCallback(resultCallback, false, null);
#endif
}
}
/// <summary>
/// Loads the data from an image stream and fills this WriteableBitmap with it.
/// </summary>
/// <param name="bmp">The WriteableBitmap.</param>
/// <param name="stream">The stream with the image data.</param>
/// <returns>The WriteableBitmap that was passed as parameter.</returns>
public static async Task<WriteableBitmap> FromStream(this WriteableBitmap bmp, Stream stream)
{
using (var dstStream = new InMemoryRandomAccessStream())
{
await RandomAccessStream.CopyAsync(stream.AsInputStream(), dstStream);
return await FromStream(bmp, dstStream);
}
}
public static async void Upload(string uri, Stream data, string paramName, string uploadContentType, Action <VKHttpResult> resultCallback, Action <double> progressCallback = null, string fileName = null)
{
#if SILVERLIGHT
var rState = new RequestState();
rState.resultCallback = resultCallback;
#endif
try
{
#if SILVERLIGHT
var request = (HttpWebRequest)WebRequest.Create(uri);
request.AllowWriteStreamBuffering = false;
rState.request = request;
request.Method = "POST";
string formDataBoundary = String.Format("----------{0:N}", Guid.NewGuid());
string contentType = "multipart/form-data; boundary=" + formDataBoundary;
request.ContentType = contentType;
request.CookieContainer = new CookieContainer();
string header = string.Format("--{0}\r\nContent-Disposition: form-data; name=\"{1}\"; filename=\"{2}\";\r\nContent-Type: {3}\r\n\r\n",
formDataBoundary,
paramName,
fileName ?? "myDataFile",
uploadContentType);
string footer = "\r\n--" + formDataBoundary + "--\r\n";
request.ContentLength = Encoding.UTF8.GetByteCount(header) + data.Length + Encoding.UTF8.GetByteCount(footer);
request.BeginGetRequestStream(ar =>
{
try
{
var requestStream = request.EndGetRequestStream(ar);
requestStream.Write(Encoding.UTF8.GetBytes(header), 0, Encoding.UTF8.GetByteCount(header));
StreamUtils.CopyStream(data, requestStream, progressCallback);
requestStream.Write(Encoding.UTF8.GetBytes(footer), 0, Encoding.UTF8.GetByteCount(footer));
requestStream.Close();
request.BeginGetResponse(new AsyncCallback(ResponseCallback), rState);
}
catch (Exception ex)
{
Logger.Error("VKHttpRequestHelper.Upload failed to write data to request stream.", ex);
SafeClose(rState);
SafeInvokeCallback(rState.resultCallback, false, null);
}
}, null);
#else
var httpClient = new Windows.Web.Http.HttpClient();
HttpMultipartFormDataContent content = new HttpMultipartFormDataContent();
content.Add(new HttpStreamContent(data.AsInputStream()), paramName, fileName ?? "myDataFile");
content.Headers.Add("Content-Type", uploadContentType);
var postAsyncOp = httpClient.PostAsync(new Uri(uri, UriKind.Absolute),
content);
postAsyncOp.Progress = (r, progress) =>
{
if (progressCallback != null && progress.TotalBytesToSend.HasValue && progress.TotalBytesToSend > 0)
{
progressCallback(((double)progress.BytesSent * 100) / progress.TotalBytesToSend.Value);
}
};
var result = await postAsyncOp;
var resultStr = await result.Content.ReadAsStringAsync();
SafeInvokeCallback(resultCallback, result.IsSuccessStatusCode, resultStr);
#endif
}
catch (Exception exc)
{
Logger.Error("VKHttpRequestHelper.Upload failed.", exc);
#if SILVERLIGHT
SafeClose(rState);
SafeInvokeCallback(rState.resultCallback, false, null);
#else
SafeInvokeCallback(resultCallback, false, null);
#endif
}
}
public async Task<AIResponse> VoiceRequestAsync(Stream voiceStream, RequestExtras requestExtras = null)
{
var request = new AIRequest
{
Language = config.Language.code,
Timezone = TimeZoneInfo.Local.StandardName,
SessionId = sessionId
};
if (requestExtras != null)
{
if (requestExtras.HasContexts)
{
request.Contexts = requestExtras.Contexts;
}
if (requestExtras.HasEntities)
{
request.Entities = requestExtras.Entities;
}
}
try
{
var content = new HttpMultipartFormDataContent();
var jsonRequest = JsonConvert.SerializeObject(request, Formatting.None, jsonSettings);
if (config.DebugLog)
{
Debug.WriteLine($"Request: {jsonRequest}");
}
content.Add(new HttpStringContent(jsonRequest, UnicodeEncoding.Utf8, "application/json"), "request");
content.Add(new HttpStreamContent(voiceStream.AsInputStream()), "voiceData", "voice.wav");
var response = await httpClient.PostAsync(new Uri(config.RequestUrl), content);
return await ProcessResponse(response);
}
catch (Exception e)
{
throw new AIServiceException(e);
}
}
public async void DoHttpClientRequest()
{
//根据是否存在body判断是Get请求还是Post请求
RequestType method = string.IsNullOrEmpty(_body) ? RequestType.Get : RequestType.Post;
var request = CreateHttp(_url, method);
if (_httpClient != null)
{
try
{
HttpResponseMessage response = null;
if (method == RequestType.Post)
{
//POST
//_httpProgressUpload = new Progress<HttpProcess>(ProgressUploadHandler);
//response = await _httpClient.SendRequestAsync(request).AsTask(_cts.Token, _progressUpload);
response = await _httpClient.SendRequestAsync(request).AsTask(_cts.Token);
}
else if (method == RequestType.Get)
{
//GET
//下载进度状态信息
_httpProgressDownload = new Progress <HttpProgress>(ProgressDownloadHandler);
try
{
response = await _httpClient.SendRequestAsync(request).AsTask(_cts.Token, _httpProgressDownload);
//HttpCompletionOption.ResponseHeadersRead多了这个参数 在接受到头之后完成。 于是就不继续进行了
//response = await _httpClient.SendRequestAsync(request, HttpCompletionOption.ResponseHeadersRead).AsTask(_cts.Token, _httpProgressDownload);
_cts.Token.ThrowIfCancellationRequested();
//处理流
using (Stream responseStream = (await response.Content.ReadAsInputStreamAsync()).AsStreamForRead())
{
//将Stream转换为IRandomAccessStream
var randomAccessStream = new InMemoryRandomAccessStream();
var outputStream = randomAccessStream.GetOutputStreamAt(0);
await RandomAccessStream.CopyAsync(responseStream.AsInputStream(), outputStream);
if (randomAccessStream != null)
{
if (SucceedEvent != null)
{
SucceedEvent(randomAccessStream); //获取到源的回调方法，并返回获取的内容
}
}
}
}
//中断Task时候会抛出异常，所以要通过try catch这种方法来获取是否终止。
catch (TaskCanceledException)
{
//请求被取消
CancelEvent("下载已停止");
}
}
}
catch (WebException e)
{
FailedEvent(e.Message, e.Status);
}
}
}
public InputStreamWithDisposeCallback(Stream stream)
{
this.stream = stream.AsInputStream();
}
internal async static Task <StorageException> PopulateStorageExceptionFromHttpResponseMessage(HttpResponseMessage response, RequestResult currentResult)
{
if (!response.IsSuccessStatusCode)
{
try
{
currentResult.HttpStatusMessage = response.ReasonPhrase;
currentResult.HttpStatusCode = (int)response.StatusCode;
currentResult.ServiceRequestID = HttpResponseMessageUtils.GetHeaderSingleValueOrDefault(response.Headers, Constants.HeaderConstants.RequestIdHeader);
string tempDate = HttpResponseMessageUtils.GetHeaderSingleValueOrDefault(response.Headers, Constants.HeaderConstants.Date);
currentResult.RequestDate = string.IsNullOrEmpty(tempDate) ? DateTime.Now.ToString("R", CultureInfo.InvariantCulture) : tempDate;
if (response.Headers.ETag != null)
{
currentResult.Etag = response.Headers.ETag.ToString();
}
if (response.Content != null && response.Content.Headers.ContentMD5 != null)
{
currentResult.ContentMd5 = Convert.ToBase64String(response.Content.Headers.ContentMD5);
}
}
catch (Exception)
{
// no op
}
try
{
Stream errStream = await response.Content.ReadAsStreamAsync();
currentResult.ExtendedErrorInformation = StorageExtendedErrorInformation.ReadFromStream(errStream.AsInputStream());
}
catch (Exception)
{
// no op
}
return(new StorageException(currentResult, response.ReasonPhrase, null));
}
else
{
return(null);
}
}
/// <summary>
/// Return the MD5 hash of the provided memory stream as a string. Stream position will be equal to the length of stream on
/// return, this ensures the MD5 is consistent.
/// </summary>
/// <param name="streamToMD5">The bytes which will be checksummed</param>
/// <returns>The MD5 checksum as a string</returns>
public static string MD5(Stream streamToMD5)
{
if (streamToMD5 == null) throw new ArgumentNullException("streamToMD5", "Provided Stream cannot be null.");
string resultStr;
#if NETFX_CORE
var alg = Windows.Security.Cryptography.Core.HashAlgorithmProvider.OpenAlgorithm(Windows.Security.Cryptography.Core.HashAlgorithmNames.Md5);
var buffer = (new Windows.Storage.Streams.DataReader(streamToMD5.AsInputStream())).ReadBuffer((uint)streamToMD5.Length);
var hashedData = alg.HashData(buffer);
resultStr = Windows.Security.Cryptography.CryptographicBuffer.EncodeToHexString(hashedData).Replace("-", "");
#else
using (System.Security.Cryptography.HashAlgorithm md5 =
#if WINDOWS_PHONE
new Tools.MD5Managed())
#else
System.Security.Cryptography.MD5.Create())
#endif
{
//If we don't ensure the position is consistent the MD5 changes
streamToMD5.Seek(0, SeekOrigin.Begin);
resultStr = BitConverter.ToString(md5.ComputeHash(streamToMD5)).Replace("-", "");
}
#endif
return resultStr;
}
private async void btn_Select_Click(object sender, RoutedEventArgs e)
{
try
{
pr_Load.Visibility = Visibility.Visible;
Uri uri = new Uri("ms-appx:///Assets/avatar/ic_avatar" + new Random().Next(1, 12) + ".jpg");
FileOpenPicker openPicker = new FileOpenPicker();
openPicker.CommitButtonText = "选中此文件";
openPicker.ViewMode = PickerViewMode.Thumbnail;
openPicker.SuggestedStartLocation = PickerLocationId.PicturesLibrary;
openPicker.FileTypeFilter.Add(".jpg");
openPicker.FileTypeFilter.Add(".gif");
openPicker.FileTypeFilter.Add(".png");
// 弹出文件选择窗口
StorageFile file = await openPicker.PickSingleFileAsync(); // 用户在“文件选择窗口”中完成操作后，会返回对应的
if (file == null)
{
Utils.ShowMessageToast("没有选择图片", 3000);
return;
}
Stream stream = await file.OpenStreamForReadAsync();
string resutls = "";
// resutls = await WebClientClass.PostResults(new Uri(string.Format("https://account.bilibili.com/pendant/updateFace?type=jpg&size=s")), stream.AsInputStream(), "https://account.bilibili.com/site/updateface.html?type=face");
// resutls = await WebClientClass.PostResults(new Uri(string.Format("https://account.bilibili.com/pendant/updateFace?type=jpg&size=m")), stream.AsInputStream(), "https://account.bilibili.com/site/updateface.html?type=face");
resutls = await WebClientClass.PostResults(new Uri(string.Format("https://account.bilibili.com/pendant/updateFace?type=jpg&size=l")), stream.AsInputStream(), "https://account.bilibili.com/site/updateface.html?type=face");
JObject obj = JObject.Parse(resutls);
if (obj["state"].ToString() == "OK")
{
MessageCenter.SendLogined();
Utils.ShowMessageToast("头像更换成功", 3000);
}
else
{
Utils.ShowMessageToast("头像更换失败", 3000);
}
}
catch (Exception ex)
{
Utils.ShowMessageToast("头像更换失败\r\n" + ex.Message, 3000);
}
finally
{
pr_Load.Visibility = Visibility.Collapsed;
GetProfile();
}
}
private async void LoadStrokesFromStream(Stream stream)
{
await inkManager.LoadAsync(stream.AsInputStream());
strokeList.Clear();
strokeList.AddRange(inkManager.GetStrokes());
needsInkSurfaceValidation = true;
}
/// <summary>
/// Submits the http post request to the specified uri.
/// </summary>
/// <param name="uri">The uri to which the post request will be issued.</param>
/// <param name="requestStream">Optional stream containing data for the request body.</param>
/// <param name="requestStreamContentType">The type of that request body data.</param>
/// <param name="allowRetry">Allow the Post to be retried after issuing a Get call. Currently used for CSRF failures.</param>
/// <returns>Task tracking the completion of the POST request</returns>
#pragma warning disable 1998
private async Task <Stream> Post(
Uri uri,
Stream requestStream = null,
string requestStreamContentType = null,
bool allowRetry = true)
{
HttpStreamContent requestContent = null;
IBuffer dataBuffer = null;
if (requestStream != null)
{
requestContent = new HttpStreamContent(requestStream.AsInputStream());
requestContent.Headers.Remove(ContentTypeHeaderName);
requestContent.Headers.TryAppendWithoutValidation(ContentTypeHeaderName, requestStreamContentType);
}
HttpBaseProtocolFilter httpFilter = new HttpBaseProtocolFilter();
httpFilter.AllowUI = false;
if (this.deviceConnection.Credentials != null)
{
httpFilter.ServerCredential = new PasswordCredential();
httpFilter.ServerCredential.UserName = this.deviceConnection.Credentials.UserName;
httpFilter.ServerCredential.Password = this.deviceConnection.Credentials.Password;
}
using (HttpClient client = new HttpClient(httpFilter))
{
this.ApplyHttpHeaders(client, HttpMethods.Post);
IAsyncOperationWithProgress <HttpResponseMessage, HttpProgress> responseOperation = client.PostAsync(uri, requestContent);
TaskAwaiter <HttpResponseMessage> responseAwaiter = responseOperation.GetAwaiter();
while (!responseAwaiter.IsCompleted)
{
}
using (HttpResponseMessage response = responseOperation.GetResults())
{
if (!response.IsSuccessStatusCode)
{
// If this isn't a retry and it failed due to a bad CSRF
// token, issue a GET to refresh the token and then retry.
if (allowRetry && this.IsBadCsrfToken(response))
{
await this.RefreshCsrfToken();
return(await this.Post(uri, requestStream, requestStreamContentType, false));
}
throw new DevicePortalException(response);
}
this.RetrieveCsrfToken(response);
if (response.Content != null)
{
using (IHttpContent messageContent = response.Content)
{
IAsyncOperationWithProgress <IBuffer, ulong> bufferOperation = messageContent.ReadAsBufferAsync();
while (bufferOperation.Status != AsyncStatus.Completed)
{
}
dataBuffer = bufferOperation.GetResults();
}
}
}
}
return((dataBuffer != null) ? dataBuffer.AsStream() : null);
}
/*
* 分为地图查找和交通路况显示，由checkbox控制
*/
private async void searchMap(object sender, RoutedEventArgs e)
{
currentCity = "";
if (searchTraffic.IsChecked == false)
{
if (mapSearchBlock.Text != "")
{
string url = "http://restapi.amap.com/v3/geocode/geo?key=5fd3b8bd943a505ccfec387943bba945&address=" + mapSearchBlock.Text;
HttpClient client = new HttpClient();
string result = await client.GetStringAsync(url);
JObject jo = (JObject)JsonConvert.DeserializeObject(result);
if (jo["status"].ToString() == "0" || jo["count"].ToString() == "0")
{
var i = new MessageDialog("查无此地区").ShowAsync();
}
else
{
JArray ja = (JArray)jo["geocodes"];
string location = ja[0]["location"].ToString();
currentCity = ja[0]["formatted_address"].ToString();
string url2 = "http://restapi.amap.com/v3/staticmap?key=5fd3b8bd943a505ccfec387943bba945&location=" + location + "&zoom=10&size=731*458&labels=" + mapSearchBlock.Text + ",2,0,16,0xFFFFFF,0x008000:" + location;
HttpResponseMessage response = await client.GetAsync(url2);
BitmapImage bitmap = new BitmapImage();
Stream stream = await response.Content.ReadAsStreamAsync();
IInputStream inputStream = stream.AsInputStream();
using (IRandomAccessStream randomAccessStream = new InMemoryRandomAccessStream())
{
using (IOutputStream outputStream = randomAccessStream.GetOutputStreamAt(0))
{
await RandomAccessStream.CopyAsync(inputStream, outputStream);
randomAccessStream.Seek(0);
bitmap.SetSource(randomAccessStream);
map.Source = bitmap;
}
}
}
}
}
else
{
if (mapSearchBlock.Text != "")
{
string url = "http://restapi.amap.com/v3/geocode/geo?key=5fd3b8bd943a505ccfec387943bba945&address=" + mapSearchBlock.Text;
HttpClient client = new HttpClient();
string result = await client.GetStringAsync(url);
JObject jo = (JObject)JsonConvert.DeserializeObject(result);
if (jo["status"].ToString() == "0" || jo["count"].ToString() == "0")
{
var i = new MessageDialog("查无此地区").ShowAsync();
}
else
{
JArray ja = (JArray)jo["geocodes"];
string location = ja[0]["location"].ToString();
currentCity = ja[0]["formatted_address"].ToString();
string url2 = "http://restapi.amap.com/v3/staticmap?key=5fd3b8bd943a505ccfec387943bba945&zoom=10&size=731*458&traffic=1&location=" + location;
HttpResponseMessage response = await client.GetAsync(url2);
BitmapImage bitmap = new BitmapImage();
Stream stream = await response.Content.ReadAsStreamAsync();
IInputStream inputStream = stream.AsInputStream();
using (IRandomAccessStream randomAccessStream = new InMemoryRandomAccessStream())
{
using (IOutputStream outputStream = randomAccessStream.GetOutputStreamAt(0))
{
await RandomAccessStream.CopyAsync(inputStream, outputStream);
randomAccessStream.Seek(0);
bitmap.SetSource(randomAccessStream);
map.Source = bitmap;
}
}
}
}
}
}
private static async Task <RTIHttpContent> CreateRequestContentAsync(HttpRequestMessage request, HttpRequestHeaderCollection rtHeaderCollection)
{
HttpContent content = request.Content;
RTIHttpContent rtContent;
ArraySegment <byte> buffer;
// If we are buffered already, it is more efficient to send the data directly using the buffer with the
// WinRT HttpBufferContent class than using HttpStreamContent. This also avoids issues caused by
// a design limitation in the System.Runtime.WindowsRuntime System.IO.NetFxToWinRtStreamAdapter.
if (content.TryGetBuffer(out buffer))
{
rtContent = new RTHttpBufferContent(buffer.Array.AsBuffer(), (uint)buffer.Offset, (uint)buffer.Count);
}
else
{
Stream contentStream = await content.ReadAsStreamAsync().ConfigureAwait(false);
if (contentStream is RTIInputStream)
{
rtContent = new RTHttpStreamContent((RTIInputStream)contentStream);
}
else if (contentStream is MemoryStream)
{
var memStream = contentStream as MemoryStream;
if (memStream.TryGetBuffer(out buffer))
{
rtContent = new RTHttpBufferContent(buffer.Array.AsBuffer(), (uint)buffer.Offset, (uint)buffer.Count);
}
else
{
byte[] byteArray = memStream.ToArray();
rtContent = new RTHttpBufferContent(byteArray.AsBuffer(), 0, (uint)byteArray.Length);
}
}
else
{
rtContent = new RTHttpStreamContent(contentStream.AsInputStream());
}
}
// RTHttpBufferContent constructor automatically adds a Content-Length header. RTHttpStreamContent does not.
// Clear any 'Content-Length' header added by the RTHttp*Content objects. We need to clear that now
// and decide later whether we need 'Content-Length' or 'Transfer-Encoding: chunked' headers based on the
// .NET HttpRequestMessage and Content header collections.
rtContent.Headers.ContentLength = null;
// Deal with conflict between 'Content-Length' vs. 'Transfer-Encoding: chunked' semantics.
// Desktop System.Net allows both headers to be specified but ends up stripping out
// 'Content-Length' and using chunked semantics. The WinRT APIs throw an exception so
// we need to manually strip out the conflicting header to maintain app compatibility.
if (request.Headers.TransferEncodingChunked.HasValue && request.Headers.TransferEncodingChunked.Value)
{
content.Headers.ContentLength = null;
}
else
{
// Trigger delayed header generation via TryComputeLength. This code is needed due to an outstanding
// bug in HttpContentHeaders.ContentLength. See GitHub Issue #5523.
content.Headers.ContentLength = content.Headers.ContentLength;
}
foreach (KeyValuePair <string, IEnumerable <string> > headerPair in content.Headers)
{
foreach (string value in headerPair.Value)
{
if (!rtContent.Headers.TryAppendWithoutValidation(headerPair.Key, value))
{
// rtContent headers are restricted to a white-list of allowed headers, while System.Net.HttpClient's content headers
// will allow custom headers. If something is not successfully added to the content headers, try adding them to the standard headers.
bool success = rtHeaderCollection.TryAppendWithoutValidation(headerPair.Key, value);
Debug.Assert(success);
}
}
}
return(rtContent);
}
// Summary:
// Upload files by output stream.
//
// Parameters:
// sourceFolderId:
// The id of the place you want to upload.
//
// fileName:
// The name you want to use after upload.
//
// Returns:
// The StorageFolder where you downloaded folder.
public async Task <bool> UploadFileStreamAsync(string folderIdToStore, string fileName, Stream outstream)
{
//ProgressBar progressBar = new ProgressBar();
//progressBar.Value = 0;
//var progressHandler = new Progress<LiveOperationProgress>(
// (progress) => { progressBar.Value = progress.ProgressPercentage; });
System.Threading.CancellationTokenSource ctsUpload = new System.Threading.CancellationTokenSource();
try
{
//LiveOperationResult result = await this.LiveClient
// .UploadAsync(folderIdToStore, fileName, outstream, OverwriteOption.Overwrite, ctsUpload.Token, progressHandler);
LiveOperationResult result = await this.LiveClient.BackgroundUploadAsync(folderIdToStore, fileName, outstream.AsInputStream(), OverwriteOption.Overwrite);
}
catch
{
ctsUpload.Cancel();
throw new ShareException(fileName, ShareException.ShareType.UPLOAD);
}
return(true);
}
private async void LoadStrokesFromStream(Stream stream)
{
await inkManager.LoadAsync(stream.AsInputStream());
needToRedrawInkSurface = true;
}
private async Task <string> GetHashForFileAsync(ListedItem fileItem, string nameOfAlg, CancellationToken token, IProgress <float> progress, IShellPage associatedInstance)
{
HashAlgorithmProvider algorithmProvider = HashAlgorithmProvider.OpenAlgorithm(nameOfAlg);
BaseStorageFile file = await StorageItemHelpers.ToStorageItem <BaseStorageFile>((fileItem as ShortcutItem)?.TargetPath ?? fileItem.ItemPath, associatedInstance);
if (file == null)
{
return("");
}
Stream stream = await FilesystemTasks.Wrap(() => file.OpenStreamForReadAsync());
if (stream == null)
{
return("");
}
uint capacity;
var inputStream = stream.AsInputStream();
bool isProgressSupported = false;
try
{
var cap = (long)(0.5 * stream.Length) / 100;
if (cap >= uint.MaxValue)
{
capacity = uint.MaxValue;
}
else
{
capacity = Convert.ToUInt32(cap);
}
isProgressSupported = true;
}
catch (NotSupportedException)
{
capacity = 64 * 1024;
}
Windows.Storage.Streams.Buffer buffer = new Windows.Storage.Streams.Buffer(capacity);
var hash = algorithmProvider.CreateHash();
while (!token.IsCancellationRequested)
{
await inputStream.ReadAsync(buffer, capacity, InputStreamOptions.None);
if (buffer.Length > 0)
{
hash.Append(buffer);
}
else
{
break;
}
if (stream.Length > 0)
{
progress?.Report(isProgressSupported ? (float)stream.Position / stream.Length * 100.0f : 20);
}
}
inputStream.Dispose();
stream.Dispose();
if (token.IsCancellationRequested)
{
return("");
}
return(CryptographicBuffer.EncodeToHexString(hash.GetValueAndReset()).ToLower());
}
/// <summary>
/// Starts an asynchronous WritePages operation as soon as the parallel
/// operation semaphore becomes available.
/// </summary>
/// <param name="pageData">Data to be uploaded</param>
/// <param name="offset">Offset within the page blob</param>
/// <returns>A task that represents the asynchronous write operation.</returns>
private async Task WritePagesAsync(Stream pageData, long offset, string contentMD5)
{
this.noPendingWritesEvent.Increment();
await this.parallelOperationSemaphore.WaitAsync();
Task writePagesTask = this.pageBlob.WritePagesAsync(pageData.AsInputStream(), offset, contentMD5, this.accessCondition, this.options, this.operationContext).AsTask().ContinueWith(task =>
{
if (task.Exception != null)
{
this.lastException = task.Exception;
}
this.noPendingWritesEvent.Decrement();
this.parallelOperationSemaphore.Release();
});
}
public IInputStream GetInputStreamAt(ulong position)
{
//THANKS Microsoft! This is GREATLY appreciated!
internstream.Position = (long)position;
return(internstream.AsInputStream());
}
/// <summary>
/// Starts an asynchronous PutBlock operation as soon as the parallel
/// operation semaphore becomes available.
/// </summary>
/// <param name="blockData">Data to be uploaded</param>
/// <param name="blockId">Block ID</param>
/// <returns>A task that represents the asynchronous write operation.</returns>
private async Task WriteBlockAsync(Stream blockData, string blockId, string blockMD5)
{
this.noPendingWritesEvent.Increment();
await this.parallelOperationSemaphore.WaitAsync();
Task putBlockTask = this.blockBlob.PutBlockAsync(blockId, blockData.AsInputStream(), blockMD5, this.accessCondition, this.options, this.operationContext).AsTask().ContinueWith(task =>
{
if (task.Exception != null)
{
this.lastException = task.Exception;
}
this.noPendingWritesEvent.Decrement();
this.parallelOperationSemaphore.Release();
});
}
public async Task<long> UploadFileAsync( string fileName, Stream fileContent )
{
var client = new HttpClient();
foreach ( var pair in _headers.Current )
{
client.DefaultRequestHeaders.Add( pair.Key, pair.Value );
}
string downloadUrl = _settings.Configuration.ServerBaseUrl + PluginName;
var uri = new Uri( downloadUrl, UriKind.Absolute );
var streamContent = new HttpStreamContent( fileContent.AsInputStream() );
var content = new HttpMultipartFormDataContent
{
{ streamContent, FileContentName },
};
// It's important to set this here and not before;
// HttpMultipartFormDataContent overwrites the headers of its contents.
streamContent.Headers.ContentDisposition.FileName = fileName;
var response = await client.PostAsync( uri, content );
if ( response.StatusCode == HttpStatusCode.ProxyAuthenticationRequired )
{
throw new AuthenticationRequiredException();
}
response.EnsureSuccessStatusCode();
var responseStream = await response.Content.ReadAsInputStreamAsync();
var serializer = new DataContractJsonSerializer( typeof( CloudPrintUploadResponse ) );
var responseObj = (CloudPrintUploadResponse) serializer.ReadObject( responseStream.AsStreamForRead() );
return responseObj.DocumentId;
}
