public WinRtTransferHandler(StreamSocket socket)
{
if (socket == null) throw new ArgumentNullException("socket");
_reader = new DataReader(socket.InputStream);
_writer = new DataWriter(socket.OutputStream);
}
private async void WriteFile(string s)
{
Windows.Storage.StorageFolder storageFolder =
Windows.Storage.ApplicationData.Current.LocalFolder;
Windows.Storage.StorageFile sampleFile =
await storageFolder.GetFileAsync("dsp_data.txt");
try
{
var stream = await sampleFile.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite);
using (var outputStream = stream.GetOutputStreamAt(stream.Size))
{
using (var dataWriter = new Windows.Storage.Streams.DataWriter(outputStream))
{
dataWriter.WriteString(s);
await dataWriter.StoreAsync();
await outputStream.FlushAsync();
}
}
stream.Dispose();
}
catch (Exception E) { }
}
private async Task <WriteableBitmap> LoadWritableBitmap(string path)
{
var file = await StorageFile.GetFileFromPathAsync(path);
var data = await FileIO.ReadBufferAsync(file);
var ms = new InMemoryRandomAccessStream();
var dw = new Windows.Storage.Streams.DataWriter(ms);
dw.WriteBuffer(data);
await dw.StoreAsync();
ms.Seek(0);
var bm = new BitmapImage();
await bm.SetSourceAsync(ms);
var wb = new WriteableBitmap(bm.PixelWidth, bm.PixelHeight);
ms.Seek(0);
await wb.SetSourceAsync(ms);
return(wb);
}
public override async void Start()
{
if (_Started)
return;
_SequenceNumber = 1;
try
{
// Connect to the Drone
udpClient = new DatagramSocket();
await udpClient.BindServiceNameAsync(_ServiceName);
await udpClient.ConnectAsync(new HostName(DroneClient.Host), _ServiceName);
udpWriter = new DataWriter(udpClient.OutputStream);
udpWriter.WriteByte(1);
await udpWriter.StoreAsync();
_Timer = ThreadPoolTimer.CreatePeriodicTimer(new TimerElapsedHandler(timerElapsedHandler), TimeSpan.FromMilliseconds(25));
_Started = true;
}
catch (Exception)
{
Stop();
}
}
public async void WriteToSerialPort(string message)
{
var writer = new DataWriter(_realDevice.OutputStream);
writer.WriteString(AddNewLine(message));
await writer.StoreAsync().AsTask();
writer.DetachStream();
}
IBuffer getBuffer(short i)
{
var writer = new Windows.Storage.Streams.DataWriter();
writer.WriteInt16(i);
return(writer.DetachBuffer());
}
public static async void SetSensorPeriod(SensorChars sensorCharacteristics, int period)
{
SensorServicesCls.SensorIndexes SensorIndex = sensorCharacteristics.Sensor_Index;
Debug.WriteLine("Begin SetSensorPeriod(): " + SensorIndex.ToString());
try
{
if (sensorCharacteristics.Charcteristics.Keys.Contains(SensorServicesCls.CharacteristicTypes.Period))
{
GattCharacteristic characteristic = sensorCharacteristics.Charcteristics[SensorServicesCls.CharacteristicTypes.Period];
{
if (characteristic.CharacteristicProperties.HasFlag(GattCharacteristicProperties.Write))
{
var writer = new Windows.Storage.Streams.DataWriter();
// Accelerometer period = [Input * 10]ms
writer.WriteByte((Byte)(period / 10));
await characteristic.WriteValueAsync(writer.DetachBuffer());
}
}
}
}
catch (Exception ex)
{
Debug.WriteLine("Error: SetSensorPeriod(): " + SensorIndex.ToString() + " " + ex.Message);
}
Debug.WriteLine("End SetSensorPeriod(): " + SensorIndex.ToString());
}
// ---------------------------------------------------
// Hardware Configuration Helper Functions
// ---------------------------------------------------
// Retrieve Barometer Calibration data
private async void calibrateBarometer()
{
GattDeviceService service;
if (_serviceList.TryGetValue(BAROMETRIC_PRESSURE, out service))
{
// Set Barometer configuration to 2, so that calibration data is saved
var characteristicList = service.GetCharacteristics(BAROMETER_CONFIGURATION_GUID);
if (characteristicList != null)
{
GattCharacteristic characteristic = characteristicList[0];
if (characteristic.CharacteristicProperties.HasFlag(GattCharacteristicProperties.Write))
{
var writer = new Windows.Storage.Streams.DataWriter();
writer.WriteByte((Byte)0x02);
await characteristic.WriteValueAsync(writer.DetachBuffer());
}
}
// Save Barometer calibration data
characteristicList = service.GetCharacteristics(BAROMETER_CALIBRATION_GUID);
if (characteristicList != null)
{
GattReadResult result = await characteristicList[0].ReadValueAsync(BluetoothCacheMode.Uncached);
baroCalibrationData = new byte[result.Value.Length];
DataReader.FromBuffer(result.Value).ReadBytes(baroCalibrationData);
}
}
}
public override async void receive_file(String devicename, String add, int not)
{
try
{
_httpurl = new Uri(add);
_httpprogress = new Progress<HttpProgress>(ProgressHandler);
HttpRequestMessage request = new HttpRequestMessage(new HttpMethod("GET"), _httpurl);
HttpBaseProtocolFilter filter = new HttpBaseProtocolFilter();
filter.CacheControl.ReadBehavior = HttpCacheReadBehavior.MostRecent;
filter.CacheControl.WriteBehavior = HttpCacheWriteBehavior.NoCache;
_httpclient = new HttpClient(filter);
_cancel_token_source = new CancellationTokenSource();
_cancel_token = _cancel_token_source.Token;
scan_network_speed();
_stopwatch.Start();
_httpresponse = await _httpclient.SendRequestAsync(request).AsTask(_cancel_token, _httpprogress);
StorageFolder folder = KnownFolders.PicturesLibrary;
StorageFile file = await folder.CreateFileAsync(this.filepath, CreationCollisionOption.ReplaceExisting);
IRandomAccessStream filestream = await file.OpenAsync(FileAccessMode.ReadWrite);
IOutputStream filewriter = filestream.GetOutputStreamAt(0);
_datawriter = new DataWriter(filewriter);
_timer.Cancel();
_transferspeed /= 1024;
_message = format_message(_stopwatch.Elapsed, "Transferspeed", _transferspeed.ToString(), " kB/s");
this.callback.on_transfer_speed_change(_message, this.results);
this.main_view.text_to_logs(_message.Replace("\t", " "));
_stopwatch.Stop();
_buffer = await _httpresponse.Content.ReadAsBufferAsync();
_datawriter.WriteBuffer(_buffer);
await _datawriter.StoreAsync();
_datawriter.Dispose();
filewriter.Dispose();
filestream.Dispose();
_httpresponse.Content.Dispose();
_httpresponse.Dispose();
_httpclient.Dispose();
_message = format_message(_stopwatch.Elapsed, "File Transfer", "OK", this.filepath);
this.callback.on_file_received(_message, this.results);
this.main_view.text_to_logs(_message.Replace("\t", " "));
}
catch (Exception e)
{
append_error_tolog(e, _stopwatch.Elapsed, "");
}
}
public async Task Connect()
{
if (!_isLoggedIn)
throw new DiscordException(ExceptionList.NotLoggedIn);
_socket = new MessageWebSocket();
_writer = new DataWriter(_socket.OutputStream) { UnicodeEncoding = UnicodeEncoding.Utf8 };
_socket.Control.MessageType = SocketMessageType.Utf8;
_socket.MessageReceived += socket_MessageReceived;
string gatewayUrl = await GetGateway();
await _socket.ConnectAsync(new Uri(gatewayUrl));
JsonObject request = new JsonObject
{
{ "op", JsonValue.CreateNumberValue(2) },
{ "d", new JsonObject
{
{ "token", JsonValue.CreateStringValue(_token) },
{ "v", JsonValue.CreateNumberValue(3) },
{ "properties", new JsonObject
{
{ "$os", JsonValue.CreateStringValue("Windows") }
}},
{ "large_threshold", JsonValue.CreateNumberValue(0) }
}
}
};
await WriteToSocket(request.Stringify());
}
public async void SendMessage(string msg)
{
HostName hostName;
try
{
hostName = new HostName("localhost");
}
catch (ArgumentException)
{
return;
}
StreamSocket socket;
try
{
using (socket = new StreamSocket())
{
await socket.ConnectAsync(hostName, port2);
//CoreApplication.Properties.Add("connected", null);
DataWriter dw = new DataWriter(socket.OutputStream);
dw.WriteString(msg);
await dw.StoreAsync();
}
}
catch
{
//break;
}
}
//</SnippetVertices>
/// <summary>
/// Fixes issue in API where textures are not saved correctly
/// </summary>
/// <param name="modelStream">3dmodel.model data</param>
/// <returns></returns>
private async Task <IRandomAccessStream> FixTextureContentType(IRandomAccessStream modelStream)
{
XDocument xmldoc = XDocument.Load(modelStream.AsStreamForRead());
var outputStream = new Windows.Storage.Streams.InMemoryRandomAccessStream();
var writer = new Windows.Storage.Streams.DataWriter(outputStream);
writer.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
writer.ByteOrder = Windows.Storage.Streams.ByteOrder.LittleEndian;
writer.WriteString("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
var text = xmldoc.ToString();
// ensure that content type is set correctly
// texture content can be either png or jpg
var replacedText = text.Replace("contenttype=\"\"", "contenttype=\"image/png\"");
writer.WriteString(replacedText);
await writer.StoreAsync();
await writer.FlushAsync();
writer.DetachStream();
return(outputStream);
}
//private uint sizeOfPixel = 4;
private async void createTile(IRandomAccessStream tileStream, Color color)
{
// Create the data writer object backed by the in-memory stream.
using (var dataWriter = new Windows.Storage.Streams.DataWriter(tileStream))
{
for (uint y = 0; y < sizeOfMapTile; y++)
{
for (uint x = 0; x < sizeOfMapTile; x++)
{
// RGBA
dataWriter.WriteByte(color.R);
dataWriter.WriteByte(color.G);
dataWriter.WriteByte(color.B);
dataWriter.WriteByte(color.A);
}
}
// Send the contents of the writer to the backing stream.
await dataWriter.StoreAsync();
// For the in-memory stream implementation we are using, the flushAsync call
// is superfluous,but other types of streams may require it.
await dataWriter.FlushAsync();
// In order to prolong the lifetime of the stream, detach it from the
// DataWriter so that it will not be closed when Dispose() is called on
// dataWriter. Were we to fail to detach the stream, the call to
// dataWriter.Dispose() would close the underlying stream, preventing
// its subsequent use by the DataReader below.
dataWriter.DetachStream();
}
}
// ---------------------------------------------------
// Hardware Configuration Helper Functions
// ---------------------------------------------------
// Retrieve Barometer Calibration data
private async void calibrateBarometer()
{
GattDeviceService gattService = serviceList[BAROMETRIC_PRESSURE];
if (gattService != null)
{
// Set Barometer configuration to 2, so that calibration data is saved
var characteristicList = gattService.GetCharacteristics(new Guid("F000AA42-0451-4000-B000-000000000000"));
if (characteristicList != null)
{
GattCharacteristic characteristic = characteristicList[0];
if (characteristic.CharacteristicProperties.HasFlag(GattCharacteristicProperties.Write))
{
var writer = new Windows.Storage.Streams.DataWriter();
writer.WriteByte((Byte)0x02);
await characteristic.WriteValueAsync(writer.DetachBuffer());
}
}
// Save Barometer calibration data
characteristicList = gattService.GetCharacteristics(new Guid("F000AA43-0451-4000-B000-000000000000"));
if (characteristicList != null)
{
GattReadResult result = await characteristicList[0].ReadValueAsync(BluetoothCacheMode.Uncached);
baroCalibrationData = new byte[result.Value.Length];
DataReader.FromBuffer(result.Value).ReadBytes(baroCalibrationData);
}
}
}
//req:
// path file exist
// m_words has words
private async void saveData(StorageFile file)
{
//Debug.Assert(path != null);
//Debug.Assert(System.IO.File.Exists(path));
Debug.Assert(m_words != null);
//StorageFile file = await StorageFile.GetFileFromPathAsync(path);
var stream = await file.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite);
var outputStream = stream.GetOutputStreamAt(0);
var dataWriter = new Windows.Storage.Streams.DataWriter(outputStream);
foreach (var w in m_words)
{
dataWriter.WriteString(w.ToString() + "\r\n");
}
await dataWriter.StoreAsync();
await outputStream.FlushAsync();
dataWriter.Dispose();
outputStream.Dispose();
stream.Dispose();
}
private void PublishLaunchApp()
{
proximityDevice = Windows.Networking.Proximity.ProximityDevice.GetDefault();
if (proximityDevice != null)
{
// The format of the app launch string is: "<args>\tWindows\t<AppName>".
// The string is tab or null delimited.
// The <args> string must have at least one character.
string launchArgs = "user=default";
// The format of the AppName is: PackageFamilyName!PRAID.
string praid = "MyAppId"; // The Application Id value from your package.appxmanifest.
string appName = Windows.ApplicationModel.Package.Current.Id.FamilyName + "!" + praid;
string launchAppMessage = launchArgs + "\tWindows\t" + appName;
var dataWriter = new Windows.Storage.Streams.DataWriter();
dataWriter.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf16LE;
dataWriter.WriteString(launchAppMessage);
publishedUriId =
proximityDevice.PublishBinaryMessage(
"NDEF:WriteTag", dataWriter.DetachBuffer(), proximityWriteTagLaunchAppMessageTransmitCallback);
}
}
public async void ProccesImage(StorageFile imageFile)
{
var data = await FileIO.ReadBufferAsync(imageFile);
// create a stream from the file
var ms = new InMemoryRandomAccessStream();
var dw = new DataWriter(ms);
dw.WriteBuffer(data);
await dw.StoreAsync();
ms.Seek(0);
// find out how big the image is, don't need this if you already know
var bm = new BitmapImage();
await bm.SetSourceAsync(ms);
// create a writable bitmap of the right size
var wb = new WriteableBitmap(bm.PixelWidth, bm.PixelHeight);
ms.Seek(0);
// load the writable bitpamp from the stream
await wb.SetSourceAsync(ms);
Bitmap bmp = (Bitmap)wb;
//var filter1 = Grayscale.CommonAlgorithms.BT709;
//bmp = filter1.Apply(bmp);
wb = (WriteableBitmap)bmp;
var file = await this.WriteableBitmapToStorageFile(wb, FileFormat.Jpeg);
}
public async Task<bool> Init()
{
var res = true;
ClearExceptions();
for (int i = 0; i < 20; i++)
{
try
{
var value = new byte[3];
value[0] = 0x1;
value[1] = (byte)(i + 1);
value[2] = (byte)(i + 1);
var buffer = new DataWriter();
buffer.WriteBytes(value);
await _initCount1To20Char.WriteValueAsync(buffer.DetachBuffer(), GattWriteOption.WriteWithoutResponse);
await Sleep(50);
}
catch (Exception exception)
{
res = false;
AddException(exception);
}
}
return res;
}
//Connects to server
public async Task connect(string address, int port)
{
if (!this.connected)
{
try
{
this.socket = new StreamSocket();
this.hostname = new HostName(address);
this.port = port;
await this.socket.ConnectAsync(this.hostname, port.ToString());
this.writer = new DataWriter(this.socket.OutputStream);
this.reader = new DataReader(this.socket.InputStream);
this.reader.InputStreamOptions = InputStreamOptions.Partial;
connected = true;
}
catch (Exception e)
{
connected = false;
Debug.WriteLine(e.Message);
}
}
else
{
await new MessageDialog("Already connected", "Information").ShowAsync();
connected = true;
}
}
protected override async void OnShareTargetActivated(ShareTargetActivatedEventArgs args)
{
if (args.ShareOperation.Data.Contains(StandardDataFormats.WebLink))
{
Uri uri = await args.ShareOperation.Data.GetWebLinkAsync();
if (null != uri)
try
{
using (var socket = new MessageWebSocket())
{
socket.Control.MessageType = SocketMessageType.Utf8;
await socket.ConnectAsync(new Uri("ws://" + settings["Host"].ToString() + ":" + settings["Port"].ToString()));
using (var writer = new DataWriter(socket.OutputStream))
{
writer.WriteString(uri.AbsoluteUri);
await writer.StoreAsync();
args.ShareOperation.ReportCompleted();
}
}
}
catch
{
show();
}
}
}
public static async Task<bool> ConnectAsync()
{
if (imageComparisonServer != null)
return true;
try
{
imageComparisonServer = new StreamSocket();
await imageComparisonServer.ConnectAsync(new HostName(ParadoxImageServerHost), ParadoxImageServerPort.ToString());
// Send initial parameters
using (var memoryStream = new MemoryStream())
{
var binaryWriter = new BinaryWriter(memoryStream);
ImageTestResultConnection.Write(binaryWriter);
var dataWriter = new DataWriter(imageComparisonServer.OutputStream);
dataWriter.WriteBytes(memoryStream.ToArray());
await dataWriter.StoreAsync();
await dataWriter.FlushAsync();
dataWriter.DetachStream();
}
return true;
}
catch (Exception)
{
imageComparisonServer = null;
return false;
}
}
private async void OnWrite(Object sender, RoutedEventArgs e)
{
// 获取本地目录的引用
StorageFolder local = ApplicationData.Current.LocalFolder;
// 创建新文件
StorageFile newFIle = await local.CreateFileAsync("demo.dat", CreationCollisionOption.ReplaceExisting);
// 打开文件流
using(IRandomAccessStream stream = await newFIle.OpenAsync(FileAccessMode.ReadWrite))
{
// 实例化 DataWriter
DataWriter dw = new DataWriter(stream);
// 设置默认编码格式
dw.UnicodeEncoding = UnicodeEncoding.Utf8;
// 写入 bool 值
dw.WriteBoolean(true);
// 写入日期值
DateTime dt = new DateTime(2010, 8, 21);
dw.WriteDateTime(dt);
// 写入字符串
string str = "测试文本";
// 计算字符串长度
uint len = dw.MeasureString(str);
// 先写入字符串的长的
dw.WriteUInt32(len);
// 再写入字符串
dw.WriteString(str);
// 以下方法必须调用
await dw.StoreAsync();
// 解除 DataWriter 与流的关联
dw.DetachStream();
dw.Dispose();
}
MessageDialog msgDlg = new MessageDialog("保存成功。");
await msgDlg.ShowAsync();
}
private async void WriteToStreamButton_Click(object sender, RoutedEventArgs e)
{
try
{
rootPage.ResetScenarioOutput(OutputTextBlock);
StorageFile file = rootPage.sampleFile;
if (file != null)
{
string userContent = InputTextBox.Text;
if (!String.IsNullOrEmpty(userContent))
{
using (StorageStreamTransaction transaction = await file.OpenTransactedWriteAsync())
{
using (DataWriter dataWriter = new DataWriter(transaction.Stream))
{
dataWriter.WriteString(userContent);
transaction.Stream.Size = await dataWriter.StoreAsync(); // reset stream size to override the file
await transaction.CommitAsync();
OutputTextBlock.Text = "The following text was written to '" + file.Name + "' using a stream:" + Environment.NewLine + Environment.NewLine + userContent;
}
}
}
else
{
OutputTextBlock.Text = "The text box is empty, please write something and then click 'Write' again.";
}
}
}
catch (FileNotFoundException)
{
rootPage.NotifyUserFileNotExist();
}
}
public async Task ConnectToDevice(DeviceInformation device)
{
this.State = ConnectionState.Connecting;
try
{
serialConnection = await SerialDevice.FromIdAsync(device.Id);
if (serialConnection != null)
{
serialConnection.BaudRate = 115200;
serialConnection.DataBits = 8;
serialConnection.Parity = SerialParity.None;
writer = new DataWriter(serialConnection.OutputStream);
reader = new DataReader(serialConnection.InputStream);
Task listen = ListenForMessagesAsync();
this.State = ConnectionState.Connected;
}
else {
Debugger.ReportToDebugger(this, "Unable to create service.\nMake sure that the 'serialcommunication' capability is declared with a function of type 'name:serialPort' in Package.appxmanifest.", Debugger.Device.Pc);
this.State = ConnectionState.Failure;
}
}
catch (TaskCanceledException ex)
{
this.State = ConnectionState.Failure;
Debugger.ReportToDebugger(this, ex.Message, Debugger.Device.Pc);
}
catch (Exception ex)
{
this.State = ConnectionState.Failure;
Debugger.ReportToDebugger(this, ex.Message, Debugger.Device.Pc);
}
}
/// <summary>
/// Extension method to SmartCardConnection class to perform a transparent exchange to the ICC
/// </summary>
/// <param name="connection">
/// SmartCardConnection object
/// </param>
/// <param name="commandData">
/// Command object to send to the ICC
/// </param>
/// <returns>Response received from the ICC</returns>
public static async Task<byte[]> TransparentExchangeAsync(this SmartCardConnection connection, byte[] commandData)
{
byte[] responseData = null;
ManageSessionResponse apduRes = await TransceiveAsync(connection, new ManageSession(new byte[2] { (byte)ManageSession.DataObjectType.StartTransparentSession, 0x00 })) as ManageSessionResponse;
if (!apduRes.Succeeded)
{
throw new Exception("Failure to start transparent session, " + apduRes.ToString());
}
using (DataWriter dataWriter = new DataWriter())
{
dataWriter.WriteByte((byte)TransparentExchange.DataObjectType.Transceive);
dataWriter.WriteByte((byte)commandData.Length);
dataWriter.WriteBytes(commandData);
TransparentExchangeResponse apduRes1 = await TransceiveAsync(connection, new TransparentExchange(dataWriter.DetachBuffer().ToArray())) as TransparentExchangeResponse;
if (!apduRes1.Succeeded)
{
throw new Exception("Failure transceive with card, " + apduRes1.ToString());
}
responseData = apduRes1.IccResponse;
}
ManageSessionResponse apduRes2 = await TransceiveAsync(connection, new ManageSession(new byte[2] { (byte)ManageSession.DataObjectType.EndTransparentSession, 0x00 })) as ManageSessionResponse;
if (!apduRes2.Succeeded)
{
throw new Exception("Failure to end transparent session, " + apduRes2.ToString());
}
return responseData;
}
private async void SendData(GattCharacteristic characteristic, string str)
{
var dataWriter = new Windows.Storage.Streams.DataWriter();
dataWriter.WriteString(str);
await characteristic.WriteValueAsync(dataWriter.DetachBuffer());
}
/// <summary>
/// Writes a string to a text file.
/// </summary>
/// <param name="text">The text to write.</param>
/// <param name="fileName">Name of the file.</param>
/// <param name="folder">The folder.</param>
/// <param name="options">
/// The enum value that determines how responds if the fileName is the same
/// as the name of an existing file in the current folder. Defaults to ReplaceExisting.
/// </param>
/// <returns></returns>
public static async Task SaveAsync(
this string text,
string fileName,
StorageFolder folder = null,
CreationCollisionOption options = CreationCollisionOption.ReplaceExisting)
{
folder = folder ?? ApplicationData.Current.LocalFolder;
var file = await folder.CreateFileAsync(
fileName,
options);
using (var fs = await file.OpenAsync(FileAccessMode.ReadWrite))
{
using (var outStream = fs.GetOutputStreamAt(0))
{
using (var dataWriter = new DataWriter(outStream))
{
if (text != null)
dataWriter.WriteString(text);
await dataWriter.StoreAsync();
dataWriter.DetachStream();
}
await outStream.FlushAsync();
}
}
}
private async void ButtonAction2_Click(object sender, RoutedEventArgs e)
{
DevicesInformation = string.Empty;
foreach (var rsCharacteristic in _dicCharacteristics)
{
DevicesInformation += $" Try to write to {rsCharacteristic.Value.CharName}{Environment.NewLine}";
bool writeOk = true;
try
{
var charToTest = rsCharacteristic.Value.Characteristic;
byte[] arr = { 4, 1, 2, 0, 1, 0 };
var writer = new DataWriter();
writer.WriteBytes(arr);
await charToTest.WriteClientCharacteristicConfigurationDescriptorAsync(GattClientCharacteristicConfigurationDescriptorValue.Indicate);
await charToTest.WriteValueAsync(writer.DetachBuffer());
DevicesInformation += $" - OK{Environment.NewLine}";
}
catch
{
DevicesInformation += $" - ERROR{Environment.NewLine}";
writeOk = false;
}
var msg = $"{rsCharacteristic.Value.CharName}, {writeOk}, {rsCharacteristic.Value.Characteristic.CharacteristicProperties}, {rsCharacteristic.Value.Characteristic.Uuid}";
Debug.WriteLine(msg);
await Task.Delay(TimeSpan.FromMilliseconds(100));
}
}
public void Open()
{
OpenConnection();
dataReader = new DataReader(streamSocket.InputStream);
dataWriter = new DataWriter(streamSocket.OutputStream);
readable = writeable = true;
}
public object Convert(object value, Type targetType, object parameter, string language)
{
if (value != null && value is byte[])
{
//WriteableBitmap bitmap = new WriteableBitmap(100, 100);
//System.IO.Stream bitmapStream = null;
//bitmapStream = bitmap.PixelBuffer.AsStream();
//bitmapStream.Position = 0;
//bitmapStream.Write(value as byte[], 0, (value as byte[]).Length);
//bitmapStream.Flush();
InMemoryRandomAccessStream randomAccessStream = new InMemoryRandomAccessStream();
DataWriter writer = new DataWriter(randomAccessStream.GetOutputStreamAt(0));
writer.WriteBytes(value as byte[]);
var x = writer.StoreAsync().AsTask().Result;
BitmapImage image = new BitmapImage();
image.SetSource(randomAccessStream);
return image;
}
return null;
}
public object Convert(object value, Type targetType, object parameter, string language)
{
if (value != null)
{
byte[] bytes = (byte[])value;
BitmapImage myBitmapImage = new BitmapImage();
if (bytes.Count() > 0)
{
InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream();
DataWriter writer = new DataWriter(stream.GetOutputStreamAt(0));
writer.WriteBytes(bytes);
writer.StoreAsync().GetResults();
myBitmapImage.SetSource(stream);
}
else
{
myBitmapImage.UriSource = new Uri("ms-appx:///Assets/firstBackgroundImage.jpg");
}
return myBitmapImage;
}
else
{
return new BitmapImage();
}
}
private async void OnLoadingFile(object sender, GestureEventArgs e)
{
var city = new City
{
Name = "Leipzig",
State = "Saxony",
Country = "Germany",
Population = 550000
};
string json = JsonConvert.SerializeObject(city);
var cityFile =
await ApplicationData.Current
.LocalFolder.CreateFileAsync(
"leipzig.city",
CreationCollisionOption.ReplaceExisting);
using (var stream = await cityFile.OpenAsync(FileAccessMode.ReadWrite))
{
using (var writer = new DataWriter(stream))
{
writer.WriteString(json);
await writer.StoreAsync();
}
}
Launcher.LaunchFileAsync(cityFile);
}
public static async void init(TiSettings settings) {
if (!settings.ContainsKey("logToken") || settings["logToken"].Length == 0) {
return;
}
logToken = settings["logToken"];
multicastSocket = new DatagramSocket();
multicastSocket.MessageReceived += multicastSocket_MessageReceived;
HostName hostname = new HostName("239.6.6.6");
try {
await multicastSocket.BindServiceNameAsync("8666");
multicastSocket.JoinMulticastGroup(hostname);
IOutputStream stream = await multicastSocket.GetOutputStreamAsync(hostname, "8666");
DataWriter writer = new DataWriter(stream);
writer.WriteString("TI_WP8_LOGGER");
await writer.StoreAsync();
writer.DetachStream();
stream.Dispose();
} catch (Exception ex) {
if (SocketError.GetStatus(ex.HResult) == SocketErrorStatus.Unknown) {
throw;
}
Debug.WriteLine(ex.ToString());
}
}
// WebSockets Button
private async void Button_Click(object sender, RoutedEventArgs e)
{
try
{
//creates a new MessageWebSocket and connects to WebSocket server and sends data to server
//Make a local copy
MessageWebSocket webSocket = messageWebSocket;
//Have we connected yet?
if (webSocket == null)
{
Uri server = new Uri(ServerAddressField.Text.Trim());
webSocket = new MessageWebSocket();
webSocket.Control.MessageType = SocketMessageType.Utf8;
webSocket.MessageReceived += MessageReceived;
webSocket.Closed += Closed;
await webSocket.ConnectAsync(server);
messageWebSocket = webSocket;
messageWriter = new DataWriter(webSocket.OutputStream);
}
//InputField is a textbox in the xaml
string message = InputField.Text;
messageWriter.WriteString(message);
await messageWriter.StoreAsync();
}
catch (Exception ex)
{
String.Format("There is an error in connection");
}
}
async void datagramSocket_MessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args)
{
i++;
DataReader dataReader = args.GetDataReader();
uint length = dataReader.UnconsumedBufferLength;
string content = dataReader.ReadString(length);
Deployment.Current.Dispatcher.BeginInvoke(() =>
msgList.Children.Add(new TextBlock { Text = "服务器收到的消息：" + content }));
//HostName hostName = new HostName("localhost");
//DatagramSocket datagramSocket = new DatagramSocket();
//IOutputStream outputStream = await datagramSocket.GetOutputStreamAsync(hostName, "22112");
DataWriter writer = new DataWriter(sender.OutputStream);
writer.WriteString(content + "|" + i);
try
{
await writer.StoreAsync();
msgList.Children.Add(new TextBlock { Text = "服务器发送的消息：" + content + "|" + i });
}
catch (Exception err)
{
if (SocketError.GetStatus(err.HResult) == SocketErrorStatus.AddressAlreadyInUse)
{
}
}
}
public async void Send(string data)
{
UInt32 bytesWritten = 0;
try
{
if (_serialPort != null)
{
// Create the DataWriter object and attach to OutputStream
_dataWriteObject = new DataWriter(_serialPort.OutputStream);
//Launch the WriteAsync task to perform the write
byte[] bytes = Encoding.ASCII.GetBytes(data);
bytesWritten = await WriteAsync(bytes);
}
}
catch (Exception)
{
}
finally
{
// Cleanup once complete
if (_dataWriteObject != null)
{
_dataWriteObject.DetachStream();
_dataWriteObject = null;
}
}
}
public async Task<BitmapImage> Base64ToBitmapImage(string base64String)
{
BitmapImage img = new BitmapImage();
if (string.IsNullOrEmpty(base64String))
return img;
using (var ims = new InMemoryRandomAccessStream())
{
byte[] bytes = Convert.FromBase64String(base64String);
base64String = "";
using (DataWriter dataWriter = new DataWriter(ims))
{
dataWriter.WriteBytes(bytes);
bytes = null;
await dataWriter.StoreAsync();
ims.Seek(0);
await img.SetSourceAsync(ims); //not in RC
return img;
}
}
}
private async void LoginButton_Click(object sender, RoutedEventArgs e)
{
if (saveLogin)
{
configSF = await storageFolder.CreateFileAsync("config.txt", Windows.Storage.CreationCollisionOption.ReplaceExisting);
var stream = await configSF.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite);
using (var outputStream = stream.GetOutputStreamAt(0))
{
using (var dataWriter = new Windows.Storage.Streams.DataWriter(outputStream))
{
string combo = Username.Text + " " + Password.Password;
IBuffer comboB = await SampleDataProtectionStream(strDescriptor, combo, encoding);
dataWriter.WriteBuffer(comboB);
await dataWriter.StoreAsync();
await outputStream.FlushAsync();
}
}
stream.Dispose();
}
else
{
configSF = await storageFolder.CreateFileAsync("config.txt", Windows.Storage.CreationCollisionOption.ReplaceExisting);
}
}
private async void WriteCharacteristicValue_Click(object sender, RoutedEventArgs args)
{
WriteCharacteristicValueButton.IsEnabled = false;
try
{
var heartRateControlPointCharacteristic = HeartRateService.Instance.Service.GetCharacteristics(
GattCharacteristicUuids.HeartRateControlPoint)[0];
DataWriter writer = new DataWriter();
writer.WriteByte(1);
GattCommunicationStatus status = await heartRateControlPointCharacteristic.WriteValueAsync(
writer.DetachBuffer());
if (status == GattCommunicationStatus.Success)
{
rootPage.NotifyUser("Expended Energy successfully reset.", NotifyType.StatusMessage);
}
else
{
rootPage.NotifyUser("Your device is unreachable, most likely the device is out of range, " +
"or is running low on battery, please make sure your device is working and try again.",
NotifyType.StatusMessage);
}
}
catch (Exception e)
{
rootPage.NotifyUser("Error: " + e.Message, NotifyType.ErrorMessage);
}
WriteCharacteristicValueButton.IsEnabled = true;
}
public async void StoreData()
{
var stream = await _dataFile.OpenAsync(FileAccessMode.ReadWrite, StorageOpenOptions.AllowReadersAndWriters);
using (var outputStream = stream.GetOutputStreamAt(0))
{
using (var dataWriter = new Windows.Storage.Streams.DataWriter(outputStream))
{
const string delinieater = ";";
foreach (double[] data in _data)
{
foreach (double d in data)
{
dataWriter.WriteDouble(d);
dataWriter.WriteString(delinieater);
}
}
await dataWriter.FlushAsync();
}
}
stream.Dispose();
_dataLineCount += _data.Count();
if (_dataLineCount >= LINE_LIMIT)
{
await CreateDataFile();
}
_data = new List <double[]>();
}
public SocketHandler(StreamSocket socket)
{
this.socket = socket;
this.reader = new DataReader(this.socket.InputStream);
this.writer = new DataWriter(this.socket.OutputStream);
}
//public static async Task<bool> FileExist()
//{
// try
// {
// var folders = ApplicationData.Current.LocalFolder;
// var file = await folders.GetFileAsync(PersonalDataFileName);
// var buildingFile = await folders.GetFileAsync(BuildingDataFileName);
// if (file.Path != null)
// return false;
// else
// return true;
// }
// catch
// {
// return true;
// }
//}
//public static void SavePersonalDataToJson(AccountInfo accountInfo)
//{
// string jsonContents = JsonConvert.SerializeObject(accountInfo);
// JObject o = (JObject)JToken.FromObject(accountInfo);
//}
//public static async void SavePersonalDataToJson(AccountInfo account)
//{
// // Serialize our Product class into a string
// // Changed to serialze the List
// // Get the app data folder and create or replace the file we are storing the JSON in.
// StorageFolder localFolder = ApplicationData.Current.LocalFolder;
// StorageFile textFile = await localFolder.CreateFileAsync(PersonalDataFileName, CreationCollisionOption.ReplaceExisting);
// // Open the file...
// string jsonContents = JsonConvert.SerializeObject(account);
// using (IRandomAccessStream mysteream = await textFile.OpenAsync(FileAccessMode.ReadWrite))
// {
// using (DataWriter textWriter = new DataWriter(mysteream))
// {
// textWriter.WriteString(jsonContents);
// await textWriter.StoreAsync();
// }
// }
//}
public static async Task <bool> SavePersonalDataToJson(List <AccountInfo> list)
{
// Serialize our Product class into a string
// Changed to serialze the List
// Get the app data folder and create or replace the file we are storing the JSON in.
if (personalTextFile == null)
{
personalTextFile = await StorageFolder.CreateFileAsync(PersonalDataFileName, CreationCollisionOption.ReplaceExisting);
}
// Open the file...
string jsonContents = JsonConvert.SerializeObject(UserToUserData(list));
var stream = await personalTextFile.OpenAsync(FileAccessMode.ReadWrite);
using (var outputStream = stream.GetOutputStreamAt(0))
{
using (var dataWriter = new Windows.Storage.Streams.DataWriter(outputStream))
{
dataWriter.WriteString(jsonContents);
await dataWriter.StoreAsync();
await outputStream.FlushAsync();
}
}
stream.Dispose();
return(true);
}
public static void Connect(string address, string port)
{
if (!connected)
{
clientSocket = new StreamSocket();
try
{
serverHost = new HostName(address);
serverPort = port;
serverHostnameString = address;
writer = new DataWriter(clientSocket.OutputStream);
clientSocket.ConnectAsync(serverHost, serverPort);
connected = true;
}
catch (Exception)
{
clientSocket.Dispose();
clientSocket = null;
throw new ConnectionErrorException();
}
}
else
{
clientSocket.Dispose();
clientSocket = null;
connected = false;
GamepadClient.Connect(address, port);
}
}
// Write function for adding control points to a server
private async Task HandleSensorControlPoint(string data)
{
if (!string.IsNullOrEmpty(data))
{
// Get current service from base class.
var service = await GetService();
// Get current characteristic from current service using the selected values from the base class.
var characteristic = service.GetCharacteristics(this.SelectedService.Guid)[this.SelectedIndex];
//Create an instance of a data writer which will write to the relevent buffer.
DataWriter writer = new DataWriter();
byte[] toWrite = System.Text.Encoding.UTF8.GetBytes(data);
writer.WriteBytes(toWrite);
// Attempt to write the data to the device, and whist doing so get the status.
GattCommunicationStatus status = await characteristic.WriteValueAsync(writer.DetachBuffer());
// Displays a message box to tell user if the write operation was successful or not.
if (status == GattCommunicationStatus.Success)
{
MessageHelper.DisplayBasicMessage("Sensor control point has been written.");
}
else
{
MessageHelper.DisplayBasicMessage("There was a problem writing the sensor control value, Please try again later.");
}
}
}
private async Task <int> SendAsync(byte[] inbuffer)
{
using (var writer = new Windows.Storage.Streams.DataWriter(socket.OutputStream))
{
writer.WriteBytes(inbuffer);
await writer.StoreAsync();
writer.DetachStream();
}
// hopefully true...
return(inbuffer.Length);
}
private async Task <bool> SendPowerOffCommand()
{
var writer = new Windows.Storage.Streams.DataWriter();
short val = CMD_OFF;
writer.WriteInt16(val);
GattCommunicationStatus writeResult = await _writeCharacteristic.WriteValueAsync(writer.DetachBuffer());
bool success = writeResult == GattCommunicationStatus.Success;
return(success);
}
private async void cutTile(IRandomAccessStream stream, int pixeloffsetX, int pixeloffsetY, int levelOfDetail)
{
// Create the data writer object backed by the in-memory stream.
using (var dataWriter = new Windows.Storage.Streams.DataWriter(stream))
{
//dataWriter.dataWriter.ByteOrder = Windows.Storage.Streams.ByteOrder.LittleEndian;
for (int y = 0; y < sizeOfMapTile; y++)
{
for (int x = 0; x < sizeOfMapTile; x++)
{
double lat, lon = 0.0;
Microsoft.MapPoint.TileSystem.PixelXYToLatLong(pixeloffsetX + x, pixeloffsetY + y, levelOfDetail, out lat, out lon);
BasicGeoposition point = new BasicGeoposition {
Latitude = lat, Longitude = lon
};
if (PathCache.pointInPolygon(point.Longitude, point.Latitude))
{
// RGBA
dataWriter.WriteByte(ColorIn.R);
dataWriter.WriteByte(ColorIn.G);
dataWriter.WriteByte(ColorIn.B);
dataWriter.WriteByte(ColorIn.A);
}
else
{
// RGBA
dataWriter.WriteByte(ColorOut.R);
dataWriter.WriteByte(ColorOut.G);
dataWriter.WriteByte(ColorOut.B);
dataWriter.WriteByte(ColorOut.A);
}
}
}
// Send the contents of the writer to the backing stream.
await dataWriter.StoreAsync();
// For the in-memory stream implementation we are using, the flushAsync call
// is superfluous,but other types of streams may require it.
await dataWriter.FlushAsync();
// In order to prolong the lifetime of the stream, detach it from the
// DataWriter so that it will not be closed when Dispose() is called on
// dataWriter. Were we to fail to detach the stream, the call to
// dataWriter.Dispose() would close the underlying stream, preventing
// its subsequent use by the DataReader below.
dataWriter.DetachStream();
}
}
private async Task <Windows.Storage.Streams.IRandomAccessStream> toStream(Windows.Storage.Streams.IBuffer ibuffer)
{
var stream = new Windows.Storage.Streams.InMemoryRandomAccessStream();
var outputStream = stream.GetOutputStreamAt(0);
var datawriter = new Windows.Storage.Streams.DataWriter(outputStream);
datawriter.WriteBuffer(ibuffer);
await datawriter.StoreAsync();
await outputStream.FlushAsync();
return(stream);
}
void InitializeServiceSdpAttributes(RfcommServiceProvider provider)
{
Windows.Storage.Streams.DataWriter writer = new Windows.Storage.Streams.DataWriter();
// First write the attribute type
writer.WriteByte(SERVICE_VERSION_ATTRIBUTE_TYPE);
// Then write the data
writer.WriteUInt32(MINIMUM_SERVICE_VERSION);
IBuffer data = writer.DetachBuffer();
provider.SdpRawAttributes.Add(SERVICE_VERSION_ATTRIBUTE_ID, data);
}
/// <summary>
/// Send a message to the server.
/// This message is specified in the JsonObject message.
/// The byteorder of the send message is LittleEndian and the encoding is Utf8.
/// </summary>
/// <param name="message">The message to be send.</param>
/// <returns>A boolean that indicates that the message was succesfully send.</returns>
public async Task <bool> SendMessage(JsonObject message)
{
//Check if the connector is connected. If not, call the Connect() function.
if (!isConnected)
{
await Connect();
}
//Write the message to the server.
//Code used from https://docs.microsoft.com/en-us/uwp/api/windows.storage.streams.datawriter
try
{
using (var dataWriter = new Windows.Storage.Streams.DataWriter(socket.OutputStream))
{
dataWriter.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
dataWriter.ByteOrder = Windows.Storage.Streams.ByteOrder.LittleEndian;
// Parse the input stream and write each element separately.
//Get the string version of the json object.
var stringToSend = message.ToString();
//Get the length of the stream, so the server knows how much data was send.
uint inputElementSize = dataWriter.MeasureString(stringToSend);
dataWriter.WriteUInt32(inputElementSize);
dataWriter.WriteString(stringToSend);
Debug.WriteLine("Wrote" + stringToSend);
Debug.WriteLine("Lenght:" + inputElementSize);
// Send the contents of the writer to the backing stream.
await dataWriter.StoreAsync();
// For the in-memory stream implementation we are using, the flushAsync call
// is superfluous,but other types of streams may require it.
await dataWriter.FlushAsync();
// In order to prolong the lifetime of the stream, detach it from the
// DataWriter so that it will not be closed when Dispose() is called on
// dataWriter. Were we to fail to detach the stream, the call to
// dataWriter.Dispose() would close the underlying stream, preventing
// its subsequent use by the DataReader below.
dataWriter.DetachStream();
return(true);
}
}
catch
{
//TODO on error?
throw;
}
}
/// <summary>
/// Restores the applications data using a backup from the current user's OneDrive.
/// <para>Note: Application requires restart after restoring data</para>
/// </summary>
/// <param name="itemId">Unique item identifier within a DriveItem (i.e., a folder/file facet).</param>
/// <param name="filename">Name of the datafile.</param>
/// <returns></returns>
public static async Task RestoreFileFromOneDriveAsync(string itemId, string dataFilename)
{
try
{
// Local storage folder
Windows.Storage.StorageFolder storageFolder =
Windows.Storage.ApplicationData.Current.LocalFolder;
// Our local ktdatabase.db file
Windows.Storage.StorageFile originalDataFile =
await storageFolder.GetFileAsync(dataFilename);
// Stream for the backed up data file
var backedUpFileStream = await GraphClient.Me.Drive.Items[itemId].ItemWithPath(dataFilename).Content
.Request()
.GetAsync();
// Backed up file
var backedUpFile = await storageFolder.CreateFileAsync("temp", CreationCollisionOption.ReplaceExisting);
var newStream = await backedUpFile.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite);
// Write data to new file
using (var outputStream = newStream.GetOutputStreamAt(0))
{
using (var dataWriter = new Windows.Storage.Streams.DataWriter(outputStream))
{
var buffer = backedUpFileStream.ToByteArray();
dataWriter.WriteBytes(buffer);
await dataWriter.StoreAsync();
await outputStream.FlushAsync();
}
}
// Copy and replace local file
await backedUpFile.CopyAsync(storageFolder, dataFilename, NameCollisionOption.ReplaceExisting);
}
catch (ServiceException ex)
{
if (ex.StatusCode == HttpStatusCode.Forbidden)
{
Console.WriteLine($"Access Denied: {ex.Message}");
}
Console.WriteLine($"Service Exception, Error uploading file to signed-in users one drive: {ex.Message}");
// return null;
}
}
public async void WriteToSocketUsingReader(IBuffer buffer)
{
using (var dataWriter = new Windows.Storage.Streams.DataWriter(socket.OutputStream))
{
dataWriter.ByteOrder = Windows.Storage.Streams.ByteOrder.LittleEndian;
dataWriter.WriteUInt32(buffer.Length);
dataWriter.WriteBuffer(buffer);
await dataWriter.StoreAsync();
await dataWriter.FlushAsync();
dataWriter.DetachStream();
}
}
private async void btnColor_Click(object sender, RoutedEventArgs e)
{
//Change the color of the NeoPixel by writing the hex color bytes to the Write characteristic
//that is currently being monitored by our Flora sketch
Button btnColor = (Button)sender;
var color = ((SolidColorBrush)btnColor.Background).Color;
var writer = new Windows.Storage.Streams.DataWriter();
writer.WriteBytes(new byte[] { color.R, color.G, color.B });
txtProgress.Text = "Writing color to Writable GATT characteristic ...";
await _writeCharacteristic.WriteValueAsync(writer.DetachBuffer());
txtProgress.Text = "Writable GATT characteristic written";
}
public static async Task TurnOnSensor(SensorChars sensorCharacteristics)
{
SensorServicesCls.SensorIndexes sensor = sensorCharacteristics.Sensor_Index;
Debug.WriteLine("Begin turn on sensor: " + sensor.ToString());
// Turn on sensor
try
{
if (sensor >= 0 && sensor != SensorServicesCls.SensorIndexes.KEYS && sensor != SensorServicesCls.SensorIndexes.IO_SENSOR && sensor != SensorServicesCls.SensorIndexes.REGISTERS)
{
if (sensorCharacteristics.Charcteristics.Keys.Contains(SensorServicesCls.CharacteristicTypes.Enable))
{
GattCharacteristic characteristic = sensorCharacteristics.Charcteristics[SensorServicesCls.CharacteristicTypes.Enable];
if (characteristic != null)
{
if (characteristic.CharacteristicProperties.HasFlag(GattCharacteristicProperties.Write))
{
var writer = new Windows.Storage.Streams.DataWriter();
if (sensor == SensorServicesCls.SensorIndexes.MOVEMENT)
{
byte[] bytes = new byte[] { 0x7f, 0x00 };
writer.WriteBytes(bytes);
}
else
{
writer.WriteByte((Byte)0x01);
}
var status = await characteristic.WriteValueAsync(writer.DetachBuffer());
}
}
}
else
{
}
}
//IncProgressCounter();
}
catch (Exception ex)
{
Debug.WriteLine("Error: TurnOnSensor() : " + sensor.ToString() + " " + ex.Message);
}
Debug.WriteLine("End turn on sensor: " + sensor.ToString());
}
private async Task PlaceIconAsync(string tag, double probability, Rect boundingBox)
{
if (probability < 0.4)
{
foreach (var stroke in _sessionStrokes)
{
_allStrokes.Add(stroke);
}
}
else
{
var icon = await GetIconFileAsync(tag);
if (icon == null)
{
return;
}
var bytes = await FileIO.ReadBufferAsync(icon);
var ms = new InMemoryRandomAccessStream();
var dw = new Windows.Storage.Streams.DataWriter(ms);
dw.WriteBuffer(bytes);
await dw.StoreAsync();
ms.Seek(0);
var bm = new BitmapImage();
await bm.SetSourceAsync(ms);
var wb = new WriteableBitmap(bm.PixelWidth, bm.PixelHeight);
ms.Seek(0);
await wb.SetSourceAsync(ms);
var newBitmap = wb.Resize((int)boundingBox.Width, (int)boundingBox.Height, WriteableBitmapExtensions.Interpolation.Bilinear);
var image = new Image();
image.Source = newBitmap;
Canvas.SetTop(image, boundingBox.Top);
Canvas.SetLeft(image, boundingBox.Left);
iconCanvas.Children.Add(image);
}
}
//
public async static void WriteTextFileAsync(string filename, string content)
{
var storageFolder = ApplicationData.Current.LocalFolder;
var textFile = await storageFolder.CreateFileAsync(filename, CreationCollisionOption.OpenIfExists);
var textStream = await textFile.OpenAsync(FileAccessMode.ReadWrite);
using (var outputStream = textStream.GetOutputStreamAt(textStream.Size))
{
using (var dataWriter = new Windows.Storage.Streams.DataWriter(outputStream))
{
dataWriter.WriteString("\n" + content);
await dataWriter.StoreAsync();
await outputStream.FlushAsync();
}
}
textStream.Dispose();
}
public static async Task WriteFile(string filename, string contents)
{
var localFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
var folder = await localFolder.CreateFolderAsync("DataCache", Windows.Storage.CreationCollisionOption.OpenIfExists);
var file = await folder.CreateFileAsync(filename, Windows.Storage.CreationCollisionOption.ReplaceExisting);
var fs = await file.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite);
fs.Seek(fs.Size);
var outStream = fs.GetOutputStreamAt(0);
var dataWriter = new Windows.Storage.Streams.DataWriter(outStream);
dataWriter.WriteString(contents);
await dataWriter.StoreAsync();
dataWriter.DetachStream();
await outStream.FlushAsync();
}
private async Task updateImage(Image cameraImage, string url)
{
// Download the image into memory as a stream
System.Net.Http.HttpClient client = new System.Net.Http.HttpClient();
System.Net.Http.HttpResponseMessage imageResponse = await client.GetAsync(url);
InMemoryRandomAccessStream randomAccess =
new Windows.Storage.Streams.InMemoryRandomAccessStream();
DataWriter writer =
new Windows.Storage.Streams.DataWriter(randomAccess.GetOutputStreamAt(0));
writer.WriteBytes(await imageResponse.Content.ReadAsByteArrayAsync());
await writer.StoreAsync();
BitmapImage bit = new BitmapImage();
await bit.SetSourceAsync(randomAccess);
cameraImage.Source = bit;
}
public async void SaveASync(T Obj, string FileName)
{
FileName = FileName + ".xml";
try
{
if (Obj != null)
{
StorageFile file = null;
StorageFolder folder = GetFolder(storageType);
file = await folder.CreateFileAsync(FileName, CreationCollisionOption.ReplaceExisting);
DataContractJsonSerializer ser = new DataContractJsonSerializer(Obj.GetType());
MemoryStream ms = new MemoryStream();
ser.WriteObject(ms, Obj);
var bytes = ms.ToArray();
var contents = UTF8Encoding.UTF8.GetString(bytes, 0, bytes.Length);
using (var writeStream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
//Stream outStream = Task.Run(() => writeStream.AsStreamForWrite()).Result;
//serializer.Serialize(outStream, Obj);
using (var outStream = writeStream.GetOutputStreamAt(0))
{
using (var dataWriter = new Windows.Storage.Streams.DataWriter(outStream))
{
dataWriter.WriteString(contents);
await dataWriter.StoreAsync();
dataWriter.DetachStream();
await outStream.FlushAsync();
}
}
}
}
}
catch (Exception)
{
throw;
}
}
public async void setSensorPeriod(int period)
{
GattDeviceService gattService = GattService;
if (SensorIndex != SensorIndexes.KEYS && SensorIndex != SensorIndexes.IO_SENSOR && gattService != null)
{
var characteristicList = gattService.GetCharacteristics(new Guid(UUIDBase[(int)SensorIndex] + SENSOR_PERIOD_GUID_SUFFFIX));
if (characteristicList != null)
{
GattCharacteristic characteristic = characteristicList[0];
if (characteristic.CharacteristicProperties.HasFlag(GattCharacteristicProperties.Write))
{
var writer = new Windows.Storage.Streams.DataWriter();
// Accelerometer period = [Input * 10]ms
writer.WriteByte((Byte)(period / 10));
await characteristic.WriteValueAsync(writer.DetachBuffer());
}
}
}
}
