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);
}
