async public Task <int> preparePaintingAreaCanvasForEraser() { RenderTargetBitmap retarbi = new RenderTargetBitmap(); Canvas eraserCanvas = PocketPaintApplication.GetInstance().EraserCanvas; try { if (eraserCanvas.Visibility == Visibility.Collapsed) { eraserCanvas.Visibility = Visibility.Visible; } await retarbi.RenderAsync(eraserCanvas); Windows.Storage.Streams.IBuffer buffer = await(retarbi.GetPixelsAsync()); pixelsCanvasEraser = WindowsRuntimeBufferExtensions.ToArray(buffer); this.pixelHeightCanvas = retarbi.PixelHeight; this.pixelWidthCanvas = retarbi.PixelWidth; } catch { return(1); } return(0); }
public async Task ZipFolderContents(StorageFolder sourceFolder, ZipArchive archive, string baseDirPath) { IReadOnlyList <StorageFile> files = await sourceFolder.GetFilesAsync(); foreach (StorageFile file in files) { ZipArchiveEntry readmeEntry = archive.CreateEntry(file.Path.Remove(0, baseDirPath.Length)); IBuffer FileBuffer = await FileIO.ReadBufferAsync(file); if (FileBuffer.Length != 0) { //byte[] buffer=FileBuffer.ToArray(); byte[] buffer = WindowsRuntimeBufferExtensions.ToArray(FileBuffer); using (Stream entryStream = readmeEntry.Open()) { await entryStream.WriteAsync(buffer, 0, buffer.Length); } } } IReadOnlyList <StorageFolder> subFolders = await sourceFolder.GetFoldersAsync(); if (subFolders.Count() == 0) { return; } foreach (StorageFolder subfolder in subFolders) { await ZipFolderContents(subfolder, archive, baseDirPath); } }
int GetSampleRate() { LibmadWrapper Libmad = new LibmadWrapper(); if (RhythmStream != null) { long currentPosition = RhythmStream.Position; Mp3bytes = new byte[RhythmStream.Length]; RhythmStream.Position = 0; RhythmStream.Read(Mp3bytes, 0, Mp3bytes.Length); RhythmStream.Position = currentPosition; } IBuffer buffer = WindowsRuntimeBufferExtensions.AsBuffer(Mp3bytes, 0, Mp3bytes.Length); if (Libmad.DecodeMp32Pcm_Init(buffer)) { int result = Libmad.ReadSamplesForSampleRate(); Libmad.CloseFile(); return(result); } else { return(-1); } }
private async Task <SolidColorBrush> GetPixelColor() { RenderTargetBitmap retarbi = new RenderTargetBitmap(); await retarbi.RenderAsync(PocketPaintApplication.GetInstance().PaintingAreaCanvas, (int)PocketPaintApplication.GetInstance().PaintingAreaCanvas.ActualWidth, (int)PocketPaintApplication.GetInstance().PaintingAreaCanvas.ActualHeight); Windows.Storage.Streams.IBuffer buffer = await(retarbi.GetPixelsAsync()); var pixels = WindowsRuntimeBufferExtensions.ToArray(buffer); var width = retarbi.PixelWidth; var height = retarbi.PixelHeight; double NormfactorX = (double)width / (double)PocketPaintApplication.GetInstance().Bitmap.PixelWidth; double NormfactorY = (double)height / (double)PocketPaintApplication.GetInstance().Bitmap.PixelHeight; double doubleY = ((double)Y) * NormfactorY; double doubleX = ((double)X) * NormfactorX; int intX = (int)Math.Round(doubleX, 0); int intY = (int)Math.Round(doubleY, 0); int intTemp = intY * width; int intXTemp = intTemp + intX; int intValue = intXTemp * 4; var a = pixels[intValue + 3]; var r = pixels[intValue + 2]; var g = pixels[intValue + 1]; var B = pixels[intValue]; return(new SolidColorBrush(Windows.UI.Color.FromArgb(a, r, g, B))); }
private void messageReceived(ProximityDevice proximityDevice, ProximityMessage message) { var rawMsg = WindowsRuntimeBufferExtensions.ToArray(message.Data); //このrawMsgをNDEF解析すればよいようだ //NDEF解析はOSでやってくれないらしい。OSがやるのはNFPだけか。 string str = "メッセージ"; switch (rawMsg[3]) { case (byte)'T': str += "TEXT"; break; case (byte)'U': str += "URI"; break; case (byte)'S': if (rawMsg[4] == (byte)'p') { str += "SmartPoster"; } break; } showToast(str); }
private void Characteristic_ValueChanged(GattCharacteristic sender, GattValueChangedEventArgs args) { if (sender == this.Characteristic) { var valueBytes = WindowsRuntimeBufferExtensions.ToArray(args.CharacteristicValue); // Convert the bytes array to the structure GCHandle pinnedPacket = GCHandle.Alloc(valueBytes, GCHandleType.Pinned); var msg = Marshal.PtrToStructure <NotificationSourceData>(pinnedPacket.AddrOfPinnedObject()); pinnedPacket.Free(); //We dont care about old notifications if (msg.EventFlags.HasFlag(EventFlags.EventFlagPreExisting)) { return; } switch (msg.EventId) { case EventID.NotificationAdded: this.NotificationAdded?.Invoke(this, msg); break; case EventID.NotificationModified: this.NotificationModified?.Invoke(this, msg); break; case EventID.NotificationRemoved: this.NotificationRemoved?.Invoke(this, msg); break; } } }
public async Task <string> PostAsync(string url, IDictionary <string, object> toPost) { var result = string.Empty; string postData = GetQueryString(toPost); var cts = new CancellationTokenSource(); try { using (var client = new HttpClient()) { var httpContent = new HttpStringContent(postData, Windows.Storage.Streams.UnicodeEncoding.Utf8); httpContent.Headers.ContentType.MediaType = "application/x-www-form-urlencoded"; var response = await client.PostAsync(new Uri(url), httpContent).AsTask(cts.Token); var buf = await response.Content.ReadAsBufferAsync(); byte[] bytes = WindowsRuntimeBufferExtensions.ToArray(buf, 0, (int)buf.Length); result = gbk.GetString(bytes, 0, bytes.Length); } } catch (Exception ex) { cts.Cancel(); await new MessageDialog(ex.Message + "\n\n请尝试刷新或检查网络连接是否正常!", "POST请求失败").ShowAsync(); } return(result); }
public override byte[] GetHashAndReset() { IBuffer result = hasher.GetValueAndReset(); var asBytes = WindowsRuntimeBufferExtensions.ToArray(result); return(asBytes); }
public void TestSha512ProviderConsistency() { byte[] message = System.Text.Encoding.UTF8.GetBytes( "abcdefghbcdefghicDEFghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"); int digestExpectedLength = 64; //for SHA 512, this is the expected length //The Bouncy Castle way org.whispersystems.curve25519.BouncyCastleDotNETSha512Provider provider = new org.whispersystems.curve25519.BouncyCastleDotNETSha512Provider(); byte[] digestActual = new byte[digestExpectedLength]; provider.calculateDigest(digestActual, message, message.Length); //The WinRT way HashAlgorithmProvider sha512Provider = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha512); IBuffer bMessage = WindowsRuntimeBufferExtensions.AsBuffer(message); IBuffer bDigest = sha512Provider.HashData(bMessage); byte[] digestWinRT = WindowsRuntimeBufferExtensions.ToArray(bDigest); //The PCLCrypto way PCLCrypto.IHashAlgorithmProvider sha512PCLProvider = PCLCrypto.WinRTCrypto.HashAlgorithmProvider.OpenAlgorithm(PCLCrypto.HashAlgorithm.Sha512); byte[] digestPCL = sha512PCLProvider.HashData(message); //Did we get the same value for all ways? CollectionAssert.AreEqual(digestWinRT, digestActual); CollectionAssert.AreEqual(digestPCL, digestWinRT); }
/// <summary> /// 加密密码 /// </summary> /// <param name="password">密码</param> /// <returns></returns> private async Task <string> EncryptedPasswordAsync(string password) { string base64String; try { string param = BiliTool.UrlContact("").TrimStart('?'); string content = await BiliTool.PostContentToWebAsync(Api.PASSPORT_KEY_ENCRYPT, param); JObject jobj = JObject.Parse(content); string str = jobj["data"]["hash"].ToString(); string str1 = jobj["data"]["key"].ToString(); string str2 = string.Concat(str, password); string str3 = Regex.Match(str1, "BEGIN PUBLIC KEY-----(?<key>[\\s\\S]+)-----END PUBLIC KEY").Groups["key"].Value.Trim(); byte[] numArray = Convert.FromBase64String(str3); AsymmetricKeyAlgorithmProvider asymmetricKeyAlgorithmProvider = AsymmetricKeyAlgorithmProvider.OpenAlgorithm(AsymmetricAlgorithmNames.RsaPkcs1); CryptographicKey cryptographicKey = asymmetricKeyAlgorithmProvider.ImportPublicKey(WindowsRuntimeBufferExtensions.AsBuffer(numArray), 0); IBuffer buffer = CryptographicEngine.Encrypt(cryptographicKey, WindowsRuntimeBufferExtensions.AsBuffer(Encoding.UTF8.GetBytes(str2)), null); base64String = Convert.ToBase64String(WindowsRuntimeBufferExtensions.ToArray(buffer)); } catch (Exception) { base64String = password; } return(base64String); }
public async Task <int> ReadAsync(byte[] buffer, int offset, int length, CancellationToken cancellationToken) { StreamSocket socket = this._socket; if (null == socket) { throw new InvalidOperationException("The socket is not open"); } IBuffer iBuffer = WindowsRuntimeBufferExtensions.AsBuffer(buffer, offset, 0, length); IBuffer iBuffer2 = await WindowsRuntimeSystemExtensions.AsTask <IBuffer, uint>(socket.InputStream.ReadAsync(iBuffer, (uint)length, InputStreamOptions.Partial), cancellationToken).ConfigureAwait(false); int bytesRead = (int)iBuffer2.Length; int num; if (bytesRead <= 0) { num = 0; } else if (object.ReferenceEquals((object)iBuffer, (object)iBuffer2)) { num = bytesRead; } else { Debug.Assert(bytesRead <= length, "Length out-of-range"); WindowsRuntimeBufferExtensions.CopyTo(iBuffer2, 0U, buffer, offset, bytesRead); num = bytesRead; } return(num); }
public void GetWindowsRuntimeBuffer_NonWritableStream_ThrowsUnauthorizedAccessException() { var memoryStream = new MemoryStream(new byte[10], false); Assert.Throws <UnauthorizedAccessException>(() => WindowsRuntimeBufferExtensions.GetWindowsRuntimeBuffer(memoryStream)); Assert.Throws <UnauthorizedAccessException>(() => WindowsRuntimeBufferExtensions.GetWindowsRuntimeBuffer(memoryStream, 0, 0)); }
/// <summary> /// ZipFolder and its sub folders /// </summary> /// <param name="tcpSocket"></param> async private static Task ZipFolderContents(StorageFolder sourceFolder, ZipArchive archive, string baseDirPath) { IReadOnlyList <StorageFile> files = await sourceFolder.GetFilesAsync(); foreach (StorageFile file in files) { ZipArchiveEntry readmeEntry = archive.CreateEntry(GetCompressedFileName(baseDirPath, file)); byte[] buffer = WindowsRuntimeBufferExtensions.ToArray(await FileIO.ReadBufferAsync(file)); // And write the contents to it using (Stream entryStream = readmeEntry.Open()) { await entryStream.WriteAsync(buffer, 0, buffer.Length); } } IReadOnlyList <StorageFolder> subFolders = await sourceFolder.GetFoldersAsync(); if (subFolders.Count() == 0) { return; } foreach (StorageFolder subfolder in subFolders) { await ZipFolderContents(subfolder, archive, baseDirPath); } }
private static async Task <string> EncryptedPassword(string passWord) { string base64String; try { HttpBaseProtocolFilter httpBaseProtocolFilter = new HttpBaseProtocolFilter(); httpBaseProtocolFilter.IgnorableServerCertificateErrors.Add(Windows.Security.Cryptography.Certificates.ChainValidationResult.Expired); httpBaseProtocolFilter.IgnorableServerCertificateErrors.Add(Windows.Security.Cryptography.Certificates.ChainValidationResult.Untrusted); Windows.Web.Http.HttpClient httpClient = new Windows.Web.Http.HttpClient(httpBaseProtocolFilter); string url = "https://passport.bilibili.com/api/oauth2/getKey"; string content = $"appkey={ApiHelper.AndroidKey.Appkey}&mobi_app=android&platform=android&ts={ApiHelper.GetTimeSpan}"; content += "&sign=" + ApiHelper.GetSign(content); string stringAsync = await WebClientClass.PostResults(new Uri(url), content); JObject jObjects = JObject.Parse(stringAsync); string str = jObjects["data"]["hash"].ToString(); string str1 = jObjects["data"]["key"].ToString(); string str2 = string.Concat(str, passWord); string str3 = Regex.Match(str1, "BEGIN PUBLIC KEY-----(?<key>[\\s\\S]+)-----END PUBLIC KEY").Groups["key"].Value.Trim(); byte[] numArray = Convert.FromBase64String(str3); AsymmetricKeyAlgorithmProvider asymmetricKeyAlgorithmProvider = AsymmetricKeyAlgorithmProvider.OpenAlgorithm(AsymmetricAlgorithmNames.RsaPkcs1); CryptographicKey cryptographicKey = asymmetricKeyAlgorithmProvider.ImportPublicKey(WindowsRuntimeBufferExtensions.AsBuffer(numArray), 0); IBuffer buffer = CryptographicEngine.Encrypt(cryptographicKey, WindowsRuntimeBufferExtensions.AsBuffer(Encoding.UTF8.GetBytes(str2)), null); base64String = Convert.ToBase64String(WindowsRuntimeBufferExtensions.ToArray(buffer)); } catch (Exception) { base64String = passWord; } return(base64String); }
private async Task <string> EncryptedPassword(string passWord) { string base64String; try { HttpBaseProtocolFilter httpBaseProtocolFilter = new HttpBaseProtocolFilter(); httpBaseProtocolFilter.IgnorableServerCertificateErrors.Add(Windows.Security.Cryptography.Certificates.ChainValidationResult.Expired); httpBaseProtocolFilter.IgnorableServerCertificateErrors.Add(Windows.Security.Cryptography.Certificates.ChainValidationResult.Untrusted); var jObjects = (await accountApi.GetKey().Request()).GetJObject(); string str = jObjects["data"]["hash"].ToString(); string str1 = jObjects["data"]["key"].ToString(); string str2 = string.Concat(str, passWord); string str3 = Regex.Match(str1, "BEGIN PUBLIC KEY-----(?<key>[\\s\\S]+)-----END PUBLIC KEY").Groups["key"].Value.Trim(); byte[] numArray = Convert.FromBase64String(str3); AsymmetricKeyAlgorithmProvider asymmetricKeyAlgorithmProvider = AsymmetricKeyAlgorithmProvider.OpenAlgorithm(AsymmetricAlgorithmNames.RsaPkcs1); CryptographicKey cryptographicKey = asymmetricKeyAlgorithmProvider.ImportPublicKey(WindowsRuntimeBufferExtensions.AsBuffer(numArray), 0); IBuffer buffer = CryptographicEngine.Encrypt(cryptographicKey, WindowsRuntimeBufferExtensions.AsBuffer(Encoding.UTF8.GetBytes(str2)), null); base64String = Convert.ToBase64String(WindowsRuntimeBufferExtensions.ToArray(buffer)); } catch (Exception) { base64String = passWord; } return(base64String); }
void RequestFrames(UInt32 timestamp, SocketStream sock, UInt32 maxFrames, UInt32[] gotFrames) { uint count = 0; try { for (count = 0; count < maxFrames; count++) { IBuffer buffer = WindowsRuntimeBufferExtensions.AsBuffer(_buffer, 0, (Int32)(_mp3Reader.FrameLen)); Int32 len = (Int32)_mp3Reader.ReadFrames(buffer, 1); byte[] byteArray = buffer.ToArray(); while (len > 0) { Int32[] sent = new Int32[1]; sock.Send(byteArray, (Int32)len, sent); len -= sent[0]; byte[] byteArray2 = new byte[len]; Array.Copy(byteArray, sent[0], byteArray2, 0, len); byteArray = byteArray2; } } } catch { // TODO } gotFrames[0] = count; }
public static async Task <string> GetEncryptedPassword(string passWord) { string base64String; try { //https://secure.bilibili.com/login?act=getkey&rnd=4928 //https://passport.bilibili.com/login?act=getkey&rnd=4928 HttpBaseProtocolFilter httpBaseProtocolFilter = new HttpBaseProtocolFilter(); httpBaseProtocolFilter.IgnorableServerCertificateErrors.Add(Windows.Security.Cryptography.Certificates.ChainValidationResult.Expired); httpBaseProtocolFilter.IgnorableServerCertificateErrors.Add(Windows.Security.Cryptography.Certificates.ChainValidationResult.Untrusted); Windows.Web.Http.HttpClient httpClient = new Windows.Web.Http.HttpClient(httpBaseProtocolFilter); //WebClientClass wc = new WebClientClass(); string stringAsync = await httpClient.GetStringAsync((new Uri("https://passport.bilibili.com/login?act=getkey&rnd=" + new Random().Next(1000, 9999), UriKind.Absolute))); JObject jObjects = JObject.Parse(stringAsync); string str = jObjects["hash"].ToString(); string str1 = jObjects["key"].ToString(); string str2 = string.Concat(str, passWord); string str3 = Regex.Match(str1, "BEGIN PUBLIC KEY-----(?<key>[\\s\\S]+)-----END PUBLIC KEY").Groups["key"].Value.Trim(); byte[] numArray = Convert.FromBase64String(str3); AsymmetricKeyAlgorithmProvider asymmetricKeyAlgorithmProvider = AsymmetricKeyAlgorithmProvider.OpenAlgorithm(AsymmetricAlgorithmNames.RsaPkcs1); CryptographicKey cryptographicKey = asymmetricKeyAlgorithmProvider.ImportPublicKey(WindowsRuntimeBufferExtensions.AsBuffer(numArray), 0); IBuffer buffer = CryptographicEngine.Encrypt(cryptographicKey, WindowsRuntimeBufferExtensions.AsBuffer(Encoding.UTF8.GetBytes(str2)), null); base64String = Convert.ToBase64String(WindowsRuntimeBufferExtensions.ToArray(buffer)); } catch (Exception) { //throw; base64String = passWord; } return(base64String); }
public async static Task <IBuffer> ReadBuffer(this IInputStream stream, uint length) { var buff = WindowsRuntimeBufferExtensions.AsBuffer(new byte[length]); await stream.ReadAsync(buff, length, InputStreamOptions.Partial); return(buff); } /*
public PixelBufferInfo(IBuffer pixelBuffer) { this.pixelStream = WindowsRuntimeBufferExtensions.AsStream(pixelBuffer); this.Bytes = new byte[this.pixelStream.Length]; this.pixelStream.Seek(0L, SeekOrigin.Begin); this.pixelStream.Read(this.Bytes, 0, this.Bytes.Length); }
public void CopyTo_NegativeCount_ThrowsArgumentOutOfRangeException() { IBuffer buffer = WindowsRuntimeBufferExtensions.AsBuffer(new byte[0]); AssertExtensions.Throws <ArgumentOutOfRangeException>("count", () => WindowsRuntimeBufferExtensions.CopyTo(new byte[0], 0, buffer, 0, -1)); AssertExtensions.Throws <ArgumentOutOfRangeException>("count", () => WindowsRuntimeBufferExtensions.CopyTo(buffer, 0, new byte[0], 0, -1)); }
public async Task <string> GetAsync(string url) { var result = string.Empty; var cts = new CancellationTokenSource(); try { using (var client = new HttpClient()) { // 在异步任务中加入进度监控 var response = await client.GetAsync(new Uri(url)).AsTask(cts.Token); var buf = await response.Content.ReadAsBufferAsync(); byte[] bytes = WindowsRuntimeBufferExtensions.ToArray(buf, 0, (int)buf.Length); result = gbk.GetString(bytes, 0, bytes.Length); } } catch (Exception ex) { cts.Cancel(); await new MessageDialog(ex.Message + "\n\n请尝试刷新或检查网络连接是否正常!", "GET请求失败").ShowAsync(); } return(result); }
/// <summary> /// Create the IBuffer to send with the image size /// </summary> /// <param name="sizeOfImage"></param> /// <returns>IBuffer</returns> public IBuffer ImageSizeCommand(int[] sizeOfImage) { if (sizeOfImage.Length != 3) { throw new ArgumentException(); } int softDeviceSize = sizeOfImage[0]; int bootLoaderSize = sizeOfImage[1]; int applicationSize = sizeOfImage[2]; if (softDeviceSize * bootLoaderSize * applicationSize < 0) { throw new ArgumentException(); } //as the specification <Length of SoftDevice><Length of Bootloader><Length of Application> var softDeviceBytes = BitConverter.GetBytes(softDeviceSize); var bootLoaderBytes = BitConverter.GetBytes(bootLoaderSize); var applicationSizeBytes = BitConverter.GetBytes(applicationSize); byte[] temp = new byte[softDeviceBytes.Length + bootLoaderBytes.Length + applicationSizeBytes.Length]; Array.Copy(softDeviceBytes, 0, temp, 0, softDeviceBytes.Length); Array.Copy(bootLoaderBytes, 0, temp, 4, bootLoaderBytes.Length); Array.Copy(applicationSizeBytes, 0, temp, 8, applicationSizeBytes.Length); var buffer = WindowsRuntimeBufferExtensions.AsBuffer(temp); return(buffer); }
public void GetWindowsRuntimeBuffer_EmptyStream_ThrowsArgumentException() { using (var stream = new MemoryStream()) { Assert.Throws <ArgumentException>(null, () => WindowsRuntimeBufferExtensions.GetWindowsRuntimeBuffer(stream, 0, 0)); } }
public void CopyTo_InvalidDestinationIndexCount_ThrowsArgumentException(byte[] bytes, uint destinationIndex, uint count) { IBuffer buffer = WindowsRuntimeBufferExtensions.AsBuffer(bytes); AssertExtensions.Throws <ArgumentException>(null, () => WindowsRuntimeBufferExtensions.CopyTo(new byte[10], 0, buffer, destinationIndex, (int)count)); AssertExtensions.Throws <ArgumentException>(null, () => WindowsRuntimeBufferExtensions.CopyTo(new byte[10].AsBuffer(), 0, bytes, (int)destinationIndex, (int)count)); AssertExtensions.Throws <ArgumentException>(null, () => WindowsRuntimeBufferExtensions.CopyTo(new byte[10].AsBuffer(), 0, buffer, destinationIndex, count)); }
public void CopyTo_InvalidSourceIndexCount_ThrowsArgumentException(byte[] bytes, uint sourceIndex, uint count) { IBuffer buffer = WindowsRuntimeBufferExtensions.AsBuffer(bytes); AssertExtensions.Throws <ArgumentException>(sourceIndex >= bytes.Length ? "sourceIndex" : null, () => WindowsRuntimeBufferExtensions.CopyTo(bytes, (int)sourceIndex, buffer, 0, (int)count)); AssertExtensions.Throws <ArgumentException>(null, () => WindowsRuntimeBufferExtensions.CopyTo(buffer, sourceIndex, buffer, 0, count)); AssertExtensions.Throws <ArgumentException>(null, () => WindowsRuntimeBufferExtensions.CopyTo(buffer, sourceIndex, new byte[0], 0, (int)count)); }
public void CopyTo_LargeSourceIndex_ThrowsArgumentException() { IBuffer buffer = WindowsRuntimeBufferExtensions.AsBuffer(new byte[0]); AssertExtensions.Throws <ArgumentException>("sourceIndex", () => WindowsRuntimeBufferExtensions.CopyTo(new byte[0], 1, buffer, 0, 0)); AssertExtensions.Throws <ArgumentException>(null, () => WindowsRuntimeBufferExtensions.CopyTo(buffer, 1, buffer, 0, 0)); AssertExtensions.Throws <ArgumentException>(null, () => WindowsRuntimeBufferExtensions.CopyTo(buffer, 1, new byte[0], 0, 0)); }
/// <inheritdoc /> protected override double[] SendStreams(StreamTools.StreamSendWrapper[] streamsToSend, double maxSendTimePerKB, long totalBytesToSend) { #if FREETRIAL if (this.ConnectionInfo.RemoteEndPoint.Address == IPAddress.Broadcast) { throw new NotSupportedException("Unable to send UDP broadcast datagram using this version of NetworkComms.Net. Please purchase a commercial license from www.networkcomms.net which supports UDP broadcast datagrams."); } #endif if (ConnectionInfo.RemoteIPEndPoint.Address.Equals(IPAddress.Any)) { throw new CommunicationException("Unable to send packet using this method as remoteEndPoint equals IPAddress.Any"); } if (totalBytesToSend > maximumSingleDatagramSizeBytes) { throw new CommunicationException("Attempted to send a UDP packet whose length is " + totalBytesToSend.ToString() + " bytes. The maximum size for a single UDP send is " + maximumSingleDatagramSizeBytes.ToString() + ". Consider using a TCP connection to send this object."); } byte[] udpDatagram = new byte[totalBytesToSend]; MemoryStream udpDatagramStream = new MemoryStream(udpDatagram, 0, udpDatagram.Length, true); for (int i = 0; i < streamsToSend.Length; i++) { if (streamsToSend[i].Length > 0) { //Write each stream streamsToSend[i].ThreadSafeStream.CopyTo(udpDatagramStream, streamsToSend[i].Start, streamsToSend[i].Length, NetworkComms.SendBufferSizeBytes, maxSendTimePerKB, MinSendTimeoutMS); streamsToSend[i].ThreadSafeStream.Dispose(); } } DateTime startTime = DateTime.Now; #if WINDOWS_PHONE || NETFX_CORE var getStreamTask = socket.GetOutputStreamAsync(new HostName(ConnectionInfo.RemoteIPEndPoint.Address.ToString()), ConnectionInfo.RemoteIPEndPoint.Port.ToString()).AsTask(); getStreamTask.Wait(); var outputStream = getStreamTask.Result; outputStream.WriteAsync(WindowsRuntimeBufferExtensions.AsBuffer(udpDatagram)).AsTask().Wait(); outputStream.FlushAsync().AsTask().Wait(); #else udpClient.Send(udpDatagram, udpDatagram.Length, ConnectionInfo.RemoteIPEndPoint); #endif udpDatagramStream.Dispose(); //Calculate timings based on fractional byte length double[] timings = new double[streamsToSend.Length]; double elapsedMS = (DateTime.Now - startTime).TotalMilliseconds; for (int i = 0; i < streamsToSend.Length; i++) { timings[i] = elapsedMS * (streamsToSend[i].Length / (double)totalBytesToSend); } return(timings); }
public void AsBuffer_InvalidOffsetLengthCapacity_ThrowsArgumentException(byte[] data, int offset, int length, int capacity) { if (capacity == 0) { AssertExtensions.Throws <ArgumentException>(null, () => WindowsRuntimeBufferExtensions.AsBuffer(data, offset, length)); } AssertExtensions.Throws <ArgumentException>(null, () => WindowsRuntimeBufferExtensions.AsBuffer(data, offset, length, capacity)); }
//Initialize the new Crypto object (initialized only once per app startup) public async void initCrypto() { this.strAsymmetricAlgName = AsymmetricAlgorithmNames.RsaPkcs1; this.asymmetricKeyLength = 512; //Checks SecureChat's folder if a key pair already exists and set keyPairExists boolean Windows.Storage.StorageFolder localAppFolder = Windows.Storage.ApplicationData.Current.LocalFolder; string cryptoFilePrivate = "SecureChatPrivateKeys.sckey"; //STORED AS BYTE DATA string cryptoFilePublic = "SecureChatPublicKey.sckey"; //STORED AS TEXT DATA if ((await localAppFolder.TryGetItemAsync(cryptoFilePublic) != null) && (await localAppFolder.TryGetItemAsync(cryptoFilePrivate) != null)) { this.keyPairExists = true; } else { this.keyPairExists = false; } //Load Keys depending on keyPairExists value if (this.keyPairExists == true) { //DIRECT IBUFFER //StorageFile loadedCryptoFilePublic = await localAppFolder.GetFileAsync(cryptoFilePublic); //this.buffPublicKey = await FileIO.ReadBufferAsync(loadedCryptoFilePublic); //FROM BYTE //StorageFile loadedCryptoFilePublic = await localAppFolder.GetFileAsync("BytePubKey.sckey"); //this.buffPublicKey = await FileIO.ReadBufferAsync(loadedCryptoFilePublic); //Open Public Key File. Convert key from STRING to BYTE and then convert to IBUFFER StorageFile loadedCryptoFilePublic = await localAppFolder.GetFileAsync(cryptoFilePublic); String publicKeyStringVersion = await FileIO.ReadTextAsync(loadedCryptoFilePublic); this.publicKeyByteVersion = Convert.FromBase64String(publicKeyStringVersion); this.buffPublicKey = this.publicKeyByteVersion.AsBuffer(); //Open Private Key File StorageFile loadedCryptoFilePrivate = await localAppFolder.GetFileAsync(cryptoFilePrivate); this.buffPrivateKeyStorage = await FileIO.ReadBufferAsync(loadedCryptoFilePrivate); } else { //Generate new key pair CryptographicKey temp = this.CreateAsymmetricKeyPair(strAsymmetricAlgName, asymmetricKeyLength, out buffPublicKey, out buffPrivateKeyStorage); //Convert public key from IBUFFER type to BYTE type. Convert from BYTE type to STRING type WindowsRuntimeBufferExtensions.CopyTo(this.buffPublicKey, this.publicKeyByteVersion); string publicKeyStringVersion = Convert.ToBase64String(this.publicKeyByteVersion); //Store keys in appropriate files (Public as PLAIN TEXT, Private as IBUFFER) await FileIO.WriteTextAsync((await localAppFolder.CreateFileAsync(cryptoFilePublic)), publicKeyStringVersion); await FileIO.WriteBufferAsync((await localAppFolder.CreateFileAsync(cryptoFilePrivate)), this.buffPrivateKeyStorage); } }
private async Task <WriteableBitmap> SaveRecognitionCanvas1(Canvas canvas, double width, double height) { //Create a temporary image file for the recognition canvas - recogCanvas.png StorageFolder pictureFolder = ApplicationData.Current.LocalFolder; var savefile = await pictureFolder.CreateFileAsync("recogCanvas.png", CreationCollisionOption.GenerateUniqueName); if (savefile == null) { return(null); } IRandomAccessStream stream = await savefile.OpenAsync(FileAccessMode.ReadWrite); //Retrieve the pixel data from the canvas RenderTargetBitmap renderBitmap = new RenderTargetBitmap(); await renderBitmap.RenderAsync(canvas, (int)width, (int)height); IBuffer x = await renderBitmap.GetPixelsAsync(); //Set the IsTooLarge flag if the IBuffer is too long for writing. This prevents an exception and writes only half the image. //7664640 - max buffer size int value; if ((int)x.Length > 7664640) { //Write only the max length of data IsTooLarge = true; value = 7664640; } else { //Write the whole lenght of data value = (int)x.Length; } //Write the image pixels to a bitmap WriteableBitmap WBitmap = new WriteableBitmap((int)width, (int)height); using (Stream pb = WBitmap.PixelBuffer.AsStream()) { //This method will throw and exception if he pixel array is too large await pb.WriteAsync(WindowsRuntimeBufferExtensions.ToArray(x), 0, value); } Stream pixelStream = WBitmap.PixelBuffer.AsStream(); byte[] pixels = new byte[pixelStream.Length]; var length = pixels.Length; await pixelStream.ReadAsync(pixels, 0, pixels.Length); // Save the image file with png extension so the image is transparent for merging BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, stream); encoder.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore, (uint)WBitmap.PixelWidth, (uint)WBitmap.PixelHeight, 96.0, 96.0, pixels); await encoder.FlushAsync(); return(WBitmap); }