/// <summary> /// Encodes a buffer to a base64 string. /// </summary> /// <param name="buffer">Input buffer.</param> /// <returns>Base64-encoded output string.</returns> public static string EncodeToBase64String( IBuffer buffer ) { if (buffer == null) throw new ArgumentNullException("buffer"); return Convert.ToBase64String(buffer.ToArray()); }
/// <summary> /// Signs digital content. For more information, see MACs, Hashes, and Signatures. /// </summary> /// <param name="key">Key used for signing.</param> /// <param name="data">Data to be signed.</param> /// <returns>Signed data.</returns> public static IBuffer Sign( CryptographicKey key, IBuffer data ) { if (key.Hash != null) { var signature = key.Hash.ComputeHash(data.ToArray()); return new WindowsRuntimeBuffer(signature); } throw new NotImplementedException(); }
public int setDbCryptKey(String partition, String key, bool bPersistent) { Windows.Storage.Streams.IBuffer keyByte = Encoding.UTF8.GetBytes(key).AsBuffer(); DataProtectionProvider protecotor = new DataProtectionProvider(); IAsyncOperation <IBuffer> task = protecotor.ProtectAsync(keyByte); task.AsTask().Wait(); Windows.Storage.Streams.IBuffer protectedKeyByte = task.GetResults(); this.writeKeyToFile(partition, protectedKeyByte.ToArray()); return(getErrorCode() == 0 ? 1 : 0); }
public static async Task SaveToPicturesLibraryAsync(IBuffer bufImage, string fileName, CancellationToken cancellationToken = default(CancellationToken)) { var folder = await KnownFolders.PicturesLibrary.CreateFolderAsync("ImageVerificationExtras", CreationCollisionOption.OpenIfExists).AsTask(cancellationToken).ConfigureAwait(false); var file = await folder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting).AsTask(cancellationToken).ConfigureAwait(false); using (var stream = await file.OpenStreamForWriteAsync().ConfigureAwait(false)) { var data = bufImage.ToArray(); await stream.WriteAsync(data, 0, data.Length, cancellationToken).ConfigureAwait(false); await stream.FlushAsync(cancellationToken).ConfigureAwait(false); } }
public Salsa20RandomGenerator(IBuffer key) { if (key == null) throw new ArgumentNullException("key"); key = HashAlgorithmProvider .OpenAlgorithm(HashAlgorithmNames.Sha256) .HashData(key); var iv = new byte[] { 0xE8, 0x30, 0x09, 0x4B, 0x97, 0x20, 0x5D, 0x2A }; _cipher = new Salsa20Cipher(key.ToArray(), iv); }
string GetDataLabelString(IBuffer data, uint scanDataType) { string result = null; // Only certain data types contain encoded text. // To keep this simple, we'll just decode a few of them. if (data == null) { result = "No data"; } else { switch (BarcodeSymbologies.GetName(scanDataType)) { case "Upca": case "UpcaAdd2": case "UpcaAdd5": case "Upce": case "UpceAdd2": case "UpceAdd5": case "Ean8": case "Ean13": // The UPC, EAN8, EAN13, and 2 of 5 families encode the digits 0..9 // which are then sent to the app in a UTF8 string (like "01234") // This is not an exhaustive list of symbologies that can be converted to a string case "Qr": // Need to distinguish the scan data among Numeric, Alphanumeric, Binary/Byte, and Kanji/Kana. // But as current barcode scanner could not distinguish the data is in Binary/Byte format or in rest 3 formats. // So to read the decoded data as string. result = string.Format("{0}", System.Text.Encoding.UTF8.GetString(data.ToArray())); break; default: // Some other unsupport symbologies and just leave it as binary data result = string.Format("Decoded data unavailable. Raw label data: {0}", GetDataString(data)); break; } } return result; }
public async Task SetAsync(string key, IBuffer buffer, DateTime expires) { if (key == null) { throw new ArgumentNullException("The parameter key must not be null."); } if (buffer == null) { throw new ArgumentNullException("The parameter buffer must not be null."); } if (fileDb.IsOpen) { var bytes = buffer.ToArray(); var ok = await Task.Run(() => AddOrUpdateRecord(key, bytes, expires)); if (!ok && (await RepairDatabase())) { await Task.Run(() => AddOrUpdateRecord(key, bytes, expires)); } } }
public async Task<string> CreateStringFromBuffer(IBuffer buffer) { var bytes = buffer.ToArray(); return await Task.FromResult(Encoding.UTF8.GetString(bytes, 0, bytes.Length)); }
internal async Task<WriteResponse> WriteAsyncInternal(byte handle, IBuffer data) { await brick.SendCommandAsyncInternal(RequestTelegram.Write(handle, data.ToArray())); return ResponseTelegram.Write(brick.LastResponse); }
private async void SaveImage(IBuffer pixelBuffer) { //Rendu du composant Xaml, ici le graphique 'Syncfusion.Chart', sous forme d'image en mémoire. RenderTargetBitmap renderTargetBitmap = new RenderTargetBitmap(); //await renderTargetBitmap.RenderAsync(doughnutMadelin, (int)myDoughnutActualWidth, (int)myDoughnut.ActualHeight); // var pixelBuffer = await renderTargetBitmap.GetPixelsAsync(); var localFolder = Windows.Storage.KnownFolders.PicturesLibrary; string filepicname = homewebview.DocumentTitle; // var localFolder = Windows.ApplicationModel.Package.Current.InstalledLocation; var saveFile = await localFolder.CreateFileAsync(filepicname+".png", Windows.Storage.CreationCollisionOption.OpenIfExists); // Encodage de l'image en mémoire dans le fichier désigné sur le disque using (var fileStream = await saveFile.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite)) { var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, fileStream); encoder.SetPixelData( BitmapPixelFormat.Rgba8, BitmapAlphaMode.Premultiplied, (uint)homewebview.ActualWidth, (uint)homewebview.ActualHeight, DisplayInformation.GetForCurrentView().LogicalDpi, DisplayInformation.GetForCurrentView().LogicalDpi, pixelBuffer.ToArray()); await encoder.FlushAsync(); } MessageDialog one = new MessageDialog("截图保存到图片库"); await one.ShowAsync(); }
internal async Task MessageWriteAsyncInternal(int inboxNumber, IBuffer message) { await brick.SendCommandAsyncInternal(RequestTelegram.MessageWrite(inboxNumber, message.ToArray())); }
internal async Task LowSpeedWriteAsyncInternal(SensorPort sensorPort, IBuffer data, byte responseLength) { await brick.SendCommandAsyncInternal(RequestTelegram.LowSpeedWrite(sensorPort, data.ToArray(), responseLength)); }
private async void _colorImage_ImageOpened(object sender, RoutedEventArgs e) { if (_rtb != null) _rtb = null; _rtb = new RenderTargetBitmap(); await _rtb.RenderAsync(_colorImage); _pixelBuffer = await _rtb.GetPixelsAsync(); _pixelBufferData = _pixelBuffer.ToArray(); }
public void UpdateData(Windows.Storage.Streams.IBuffer buffer) { this.data = buffer.ToArray(); ParseData(); }
/// <summary> /// Gets the database schema version. /// </summary> /// <param name="buffer">The version bytes buffer</param> /// <returns>The database schema version.</returns> private static Version GetVersion(IBuffer buffer) { if (buffer == null) throw new ArgumentNullException("buffer"); var bytes = buffer.ToArray(0, 4); var minor = BitConverter.ToUInt16(bytes, 0); var major = BitConverter.ToUInt16(bytes, 2); return new Version(major, minor); }
/// <summary> /// Parse the headers fields. /// </summary> /// <param name="input">The input stream.</param> /// <param name="buffer">The header bytes reader.</param> /// <returns>The file headers.</returns> private static async Task<FileHeaders> GetHeaders( IInputStream input, IBuffer buffer) { var result = new FileHeaders(); while (true) { buffer = await input.ReadAsync(buffer, 3); var field = (HeaderFields)buffer.GetByte(0); var size = BitConverter.ToUInt16(buffer.ToArray(1, 2), 0); if (size > 0) buffer = await input.ReadAsync(buffer, size); switch (field) { case HeaderFields.EndOfHeader: return result; case HeaderFields.CompressionFlags: result.UseGZip = buffer.GetByte(0) == 1; break; case HeaderFields.EncryptionIV: result.EncryptionIV = buffer .ToArray().AsBuffer(); break; case HeaderFields.MasterSeed: result.MasterSeed = buffer .ToArray().AsBuffer(); break; case HeaderFields.StreamStartBytes: result.StartBytes = buffer .ToArray().AsBuffer(); break; case HeaderFields.TransformSeed: result.TransformSeed = buffer .ToArray().AsBuffer(); break; case HeaderFields.TransformRounds: result.TransformRounds = BitConverter.ToUInt64( buffer.ToArray(), 0); break; case HeaderFields.ProtectedStreamKey: result.ProtectedStreamKey = buffer .ToArray().AsBuffer(); break; case HeaderFields.InnerRandomStreamID: result.RandomAlgorithm = (CrsAlgorithm) BitConverter.ToUInt32(buffer.ToArray(), 0); break; } } }