private async Task Download(string url,StorageFile file,bool cover)
{
var http = new HttpClient();
byte[] response = { };
string betterUrl = url;
if(cover)
{
var pos = betterUrl.IndexOf(".jpg");
if (pos != -1)
betterUrl = betterUrl.Insert(pos, "l");
}
//get bytes
try
{
await Task.Run(async () => response = await http.GetByteArrayAsync(betterUrl));
}
catch (Exception)
{
await Task.Run(async () => response = await http.GetByteArrayAsync(url));
}
var fs = await file.OpenStreamForWriteAsync(); //get stream
var writer = new DataWriter(fs.AsOutputStream());
writer.WriteBytes(response); //write
await writer.StoreAsync();
await writer.FlushAsync();
writer.Dispose();
}
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;
}
}
//</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);
}
public async void PerformPeerDiscovery()
{
timer.Interval = new TimeSpan(0, 0, 5);
timer.Start();
if (socket == null)
{
socket = new DatagramSocket();
socket.MessageReceived += socket_MessageReceived;
try
{
await socket.BindEndpointAsync(null, "22002");
}
catch
{
// Swallow any already bound exceptions!
}
}
using (var outputStream = await socket.GetOutputStreamAsync(new HostName("230.0.0.1"), "22003"))
{
using (DataWriter wr = new DataWriter(outputStream))
{
wr.WriteString("**BECHARMING DISCOVERY**");
await wr.FlushAsync();
await wr.StoreAsync();
}
}
}
//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();
}
}
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 async Task SendAsync(string text)
{
try
{
// DataWriter to send message to client
var writer = new DataWriter(_socket.OutputStream);
//Encrypt message
byte[] data = Cryptographic.Encrypt(text, "123");
//Write Lenght message in buffer
writer.WriteInt32(data.Length);
//Write message in buffer
writer.WriteBytes(data);
//Send buffer
await writer.StoreAsync();
//Clear buffer
await writer.FlushAsync();
}
catch (Exception e)
{
InvokeOnError(e.Message);
}
}
public static async Task <Windows.UI.Xaml.Media.Imaging.BitmapImage> GetBitmapAsync(byte[] data)
{
if (data is null)
{
return(null);
}
var bitmapImage = new Windows.UI.Xaml.Media.Imaging.BitmapImage();
using (var stream = new Windows.Storage.Streams.InMemoryRandomAccessStream())
{
using (var writer = new Windows.Storage.Streams.DataWriter(stream))
{
writer.WriteBytes(data);
await writer.StoreAsync();
await writer.FlushAsync();
writer.DetachStream();
}
stream.Seek(0);
await bitmapImage.SetSourceAsync(stream);
}
return(bitmapImage);
}
private async Task ExecuteDiscoveryTask()
{
int repeatTime = EndpointController.REPEAT_DISCOVERY_TASK / 2;
while (running)
{
Debug.WriteLine("#> [DiscoveryCloudletMulticast]: Started Cloudlet Discovery using Multicast UDP");
retry = 0;
DatagramSocket socketSent = null;
DatagramSocket socketReplay = null;
try
{
socketSent = new DatagramSocket();
await socketSent.BindEndpointAsync(null, string.Empty);
socketSent.JoinMulticastGroup(ip);
socketReplay = new DatagramSocket();
socketReplay.MessageReceived += SocketOnMessageReceived;
await socketReplay.BindServiceNameAsync(replyCloudletPort.ToString());
using (DataWriter writer = new DataWriter(await socketSent.GetOutputStreamAsync(ip, multicastPort.ToString())))
{
while (retry < 60 && running)
{
writer.WriteString("mpos_cloudlet_req");
await writer.StoreAsync();
await writer.FlushAsync();
await Task.Delay(500);
retry++;
}
}
}
catch (IOException e)
{
Debug.WriteLine("## [DiscoveryCloudletMulticast]: Any problem with i/o in multicast system!\n" + e.ToString());
}
finally
{
socketSent.Dispose();
socketReplay.Dispose();
socketSent = null;
socketReplay = null;
}
if (running)
{
Debug.WriteLine(">> [DiscoveryCloudletMulticast]: Retry Discovery Cloudlet, in " + repeatTime + " ms");
await Task.Delay(repeatTime);
}
else
{
Debug.WriteLine("#> [DiscoveryCloudletMulticast]: Finished Discovery Cloudlet");
}
}
}
/// <summary>
/// Attempts to send a magic packet to the desination hostname, on the specified port with the specified MAC address.
/// </summary>
/// <param name="destination">Destination hostname or IP address.</param>
/// <param name="destinationPort">Destination port number.</param>
/// <param name="targetMac">Destination MAC address. Bytes can be separated by colons, dashes, or nothing.</param>
/// <returns>True if magic packet is sent successfully, false otherwise.</returns>
public async Task<bool> SendMagicPacket(Windows.Networking.HostName destination, uint destinationPort, string targetMac)
{
try
{
DatagramSocket _socket = new DatagramSocket();
using (var stream = await _socket.GetOutputStreamAsync(destination, destinationPort.ToString()))
{
//Split on common MAC separators
char? splitChar = null;
if (targetMac.Contains('-'))
splitChar = '-';
else if (targetMac.Contains(':'))
splitChar = ':';
else if (targetMac.Contains(' '))
splitChar = ' ';
//Turn MAC into array of bytes
byte[] macAsArray;
if (splitChar != null)
{
macAsArray = targetMac.Split((char)splitChar)
.Select(b => Convert.ToByte(b, 16))
.ToArray<byte>();
}
else
{
//Jump through MAC-string, reading 2 chars at a time
macAsArray = Enumerable.Range(0, targetMac.Length)
.Where(x => x % 2 == 0)
.Select(x => Convert.ToByte(targetMac.Substring(x, 2), 16)) //16 = hexadecimal
.ToArray();
}
List<byte> magicPacket = new List<byte> { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
//A WoLAN magic packet is just FF FF FF FF FF FF, then the target MAC adress repeated 16 times.
for (int i = 0; i < 16; i++)
{
magicPacket = magicPacket.Concat(macAsArray).ToList();
}
using (DataWriter writer = new DataWriter(stream))
{
writer.WriteBytes(magicPacket.ToArray<byte>());
await writer.StoreAsync();
await writer.FlushAsync();
return true;
}
}
}
catch (Exception e)
{
Debug.WriteLine(e);
return false;
}
}
private static async Task<IInputStream> GetStreamForByteArray(string content2)
{
var ras = new InMemoryRandomAccessStream();
var datawriter = new DataWriter(ras);
datawriter.WriteString(content2);
//datawriter.WriteBytes(content2);
await datawriter.StoreAsync();
await datawriter.FlushAsync();
return ras.GetInputStreamAt(0);
}
async Task Send(FayeObject o) {
if (o is FayeRequest)
(o as FayeRequest).ClientID = ClientID;
using (var writer = new DataWriter(_socket.OutputStream)) {
writer.UnicodeEncoding = UnicodeEncoding.Utf8;
var stringd = await Helpers.SerializeAsync(o);
writer.WriteString(stringd);
await writer.StoreAsync();
await writer.FlushAsync();
writer.DetachStream();
}
}
/// <summary>
/// Gets intent and entities from a text string
/// </summary>
/// <returns>Unprocessed result from a server</returns>
public async Task<string> GetAsync()
{
return await Task.Run<string>(async () =>
{
try
{
var socket = new StreamSocket();
var writer = new DataWriter(socket.OutputStream);
var reader = new DataReader(socket.InputStream);
reader.InputStreamOptions = InputStreamOptions.Partial;
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.AppendLine(String.Format("GET /message?q={0} HTTP/1.1", HttpUtility.UrlEncode(message)));
stringBuilder.AppendLine("Host: api.wit.ai");
stringBuilder.AppendLine(String.Format("Authorization: Bearer {0}", accessToken));
stringBuilder.AppendLine("");
string headers = stringBuilder.ToString();
byte[] headersPayload = Encoding.UTF8.GetBytes(headers);
await socket.ConnectAsync(new HostName("wit.ai"), "443", SocketProtectionLevel.SslAllowNullEncryption);
writer.WriteBytes(headersPayload);
WitLog.Log("Sending text...");
await writer.StoreAsync();
await writer.FlushAsync();
var count = await reader.LoadAsync(UInt16.MaxValue);
string response = reader.ReadString(count);
int bodyStartIndex = response.IndexOf("\r\n\r\n");
if (bodyStartIndex != -1)
{
string body = response.Substring(bodyStartIndex + 4);
WitLog.Log(body);
return body;
}
else
{
return null;
}
}
catch
{
return null;
}
});
}
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 System.Threading.Tasks.Task SendMessage(byte[] data)
{
using (var stream = await socket.GetOutputStreamAsync(new Windows.Networking.HostName(externalIP), externalPort))
{
using (var writer = new Windows.Storage.Streams.DataWriter(stream))
{
writer.WriteBytes(data);
await writer.StoreAsync();
await writer.FlushAsync();
}
}
}
public void Send(string message)
{
var ostream = this.streamSocket.OutputStream;
var dataWriter = new DataWriter(ostream);
byte[] msgByteArray = Helpers.stringToByteArray(message);
byte[] msgSizeByteArray = Helpers.intToByteArray(msgByteArray.Length);
dataWriter.WriteBytes(msgSizeByteArray);
dataWriter.WriteBytes(msgByteArray);
dataWriter.StoreAsync().AsTask().Wait();
dataWriter.FlushAsync().AsTask().Wait();
}
/// <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;
}
}
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();
}
}
public async Task SaveAsync(string filePath, byte[] content)
{
StorageFile file = await GetFileAsync(filePath);
using (IRandomAccessStream writeStream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
using (DataWriter dataWriter = new DataWriter(writeStream))
{
dataWriter.WriteBytes(content);
await dataWriter.StoreAsync();
await dataWriter.FlushAsync();
}
}
}
/// <summary>
/// Use for small assets
/// </summary>
/// <param name="url"></param>
/// <param name="cancelToken"></param>
/// <returns></returns>
public static async Task<IRandomAccessStream> DownloadFileAsync(LibrelioUrl url, CancellationToken cancelToken = default(CancellationToken))
{
var stream = new InMemoryRandomAccessStream();
using(var response = await new HttpClient().GetAsync(url.AbsoluteUrl))
{
var buffer = await response.Content.ReadAsStringAsync();
var dataWriter = new DataWriter(stream.GetOutputStreamAt(0));
dataWriter.WriteString(buffer);
await dataWriter.StoreAsync();
await dataWriter.FlushAsync();
}
return stream;
}
protected override async void OnResponse(object sender, XmlRpcResponseEventArgs e)
{
string fname = string.Format("{0}/{1}-{2:0000}-response-{3}.xml",
_directory, DateTime.Now.Ticks, e.RequestNum, e.ProxyID);
var file = await Directory.CreateFileAsync(fname, CreationCollisionOption.ReplaceExisting);
using (var str = await file.OpenAsync(FileAccessMode.ReadWrite))
{
using (var dw = new DataWriter(str))
{
await e.ResponseStream.CopyToAsync(str.AsStreamForWrite());
await dw.FlushAsync();
dw.DetachStream();
}
}
}
private async Task<IRandomAccessStream> ConvertToRandomAccessStream(byte[] bytes)
{
var randomAccessStream = new InMemoryRandomAccessStream();
using (var writer = new DataWriter(randomAccessStream))
{
writer.WriteBytes(bytes);
await writer.StoreAsync();
await writer.FlushAsync();
writer.DetachStream();
writer.Dispose();
}
randomAccessStream.Seek(0);
return randomAccessStream;
}
/// <summary>
/// Sets source of the BitmapImage to specified byte array.
/// </summary>
public static async Task SetSourceAsync(this BitmapImage image, byte[] data)
{
using (var stream = new InMemoryRandomAccessStream())
{
using (var writer = new DataWriter(stream))
{
writer.WriteBytes(data);
await writer.StoreAsync();
await writer.FlushAsync();
writer.DetachStream();
}
stream.Seek(0);
await image.SetSourceAsync(stream);
}
}
private async void send_data(string dataToSend)
{
Debug.Log("sending message: " + dataToSend);
using (var dataWriter = new Windows.Storage.Streams.DataWriter(streamSocket.OutputStream)){
dataWriter.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
dataWriter.ByteOrder = Windows.Storage.Streams.ByteOrder.LittleEndian;
dataWriter.WriteString(dataToSend);
await dataWriter.StoreAsync();
await dataWriter.FlushAsync();
dataWriter.DetachStream();
}
Debug.Log("message sent");
}
//手柄按钮被按以后发送信息
private async System.Threading.Tasks.Task SendControllerInfo(string message)
{
using (var stream = await socket.GetOutputStreamAsync(new Windows.Networking.HostName(local), externalPort))
{
using (var writer = new Windows.Storage.Streams.DataWriter(stream))
{
var data = Encoding.UTF8.GetBytes(message);
writer.WriteBytes(data);
await writer.StoreAsync();
await writer.FlushAsync();
Debug.Log("Sent: " + message);
}
}
}
async public void SendRawMessage(string message)
{
if (!_connected) return;
var writer = new DataWriter(_clientSocket.OutputStream);
byte[] header = BitConverter.GetBytes(message.Length);
if (BitConverter.IsLittleEndian)
Array.Reverse(header);
writer.WriteBytes(header);
writer.WriteString(message);
await writer.StoreAsync();
await writer.FlushAsync();
System.Diagnostics.Debug.WriteLine("Sent : header = " + BitConverter.ToString(header) + " | body = " + message);
writer.DetachStream();
//_clientSocket.Dispose();
//_connected = false;
}
/// <summary>
/// Use for small assets
/// </summary>
/// <param name="url"></param>
/// <param name="cancelToken"></param>
/// <returns></returns>
public static async Task<IRandomAccessStream> DownloadFileAsync(LibrelioUrl url, CancellationToken cancelToken = default(CancellationToken))
{
var stream = new InMemoryRandomAccessStream();
var client = new HttpClient();
client.DefaultRequestHeaders.Add("user-agent", "LibrelioWinRT");
using (var response = await client.GetAsync(url))
{
var buffer = await response.Content.ReadAsStringAsync();
var dataWriter = new DataWriter(stream.GetOutputStreamAt(0));
dataWriter.WriteString(buffer);
await dataWriter.StoreAsync();
await dataWriter.FlushAsync();
}
return stream;
}
public static async Task CopyStreamAsync(this IInputStream src, IOutputStream outStream, uint bufferSize = 16384)
{
using (var rd = new DataReader(src))
{
using (var wr = new DataWriter(outStream))
{
do
{
var r = await rd.LoadAsync(bufferSize);
if (r <= 0) break;
var buf = new byte[r];
rd.ReadBytes(buf);
wr.WriteBytes(buf);
await wr.FlushAsync();
} while (true);
}
}
}
private async void Test_Click(object sender, RoutedEventArgs e) {
try {
StreamSocket socket = new StreamSocket();
await socket.ConnectAsync(new HostName("192.168.0.2"), "86", SocketProtectionLevel.PlainSocket);
var writer = new DataWriter(socket.OutputStream);
uint i = writer.WriteString("test\r\n");
try {
await writer.StoreAsync();
Debug.WriteLine("StoreAsync was called");
Debug.WriteLine("MainPage Wrote {0} bytes", i);
await writer.FlushAsync();
} catch (Exception ex1) {
Debug.WriteLine(ex1.ToString());
}
} catch (Exception ex) {
Debug.WriteLine(ex.ToString());
}
}
// http://www.chrispeerman.info/loading-images-from-byte-arrays-in-windows-8-store-apps-winrt/
/// <summary>
/// Creates new BitmapImage from specified byte array.
/// </summary>
public static async Task<BitmapImage> FromByteArrayAsync(byte[] data)
{
using (var stream = new InMemoryRandomAccessStream())
{
using (var writer = new DataWriter(stream))
{
writer.WriteBytes(data);
await writer.StoreAsync();
await writer.FlushAsync();
writer.DetachStream();
}
stream.Seek(0);
var bitmap = new BitmapImage();
await bitmap.SetSourceAsync(stream);
return bitmap;
}
}
private async void TransferImage(StreamSocket socket)
{
var writer = new DataWriter(socket.OutputStream);
UpdateStatus("Übertrage Bild...");
// Anzahl der zu übertragenden Bytes übertragen
writer.WriteInt32(App.ImageBytesToTransfer.Length);
await writer.StoreAsync();
// Image-Bytes übertragen
writer.WriteBytes(App.ImageBytesToTransfer);
await writer.StoreAsync();
await writer.FlushAsync();
// Ressourcen freigeben
writer.Dispose();
UpdateStatus("Übertragung abgeschlossen");
}
/// <summary>
/// Serializes the data object and sends it to the connected RemoteSocket.
/// For more information on making an object serializable, see DataContractJsonSerializer.
/// </summary>
public async Task SendRemoteMessageAsync(object data)
{
// Connect to the remote host to ensure that the connection exists.
await ConnectToRemoteAsync();
using (var writer = new DataWriter(_remoteSocket.OutputStream))
{
byte[] serializedData = SerializeData(data);
byte[] serializedDataLength = BitConverter.GetBytes(serializedData.Length);
writer.WriteBytes(serializedDataLength);
writer.WriteBytes(serializedData);
await writer.StoreAsync();
await writer.FlushAsync();
}
// Disconnect from the remote host.
DisconnectFromRemote();
}
public object Convert(object value, System.Type type, object parameter, string language)
{
ImageSource src = null;
byte[] bytearr = value as byte[];
if (bytearr != null)
{
BitmapImage image = new BitmapImage();
using (InMemoryRandomAccessStream ms = new InMemoryRandomAccessStream())
{
using (DataWriter dataWriter = new DataWriter(ms.GetOutputStreamAt(0)))
{
dataWriter.WriteBytes(bytearr);
dataWriter.StoreAsync().AsTask().Wait();
dataWriter.FlushAsync().AsTask().Wait();
}
image.SetSource(ms);
}
src = image;
}
return src;
}
private async void TransferPicture(StreamSocket socket)
{
// DataWriter erzeugen, um Byte-Umwandlung erledigen zu lassen...
var writer = new DataWriter(socket.OutputStream);
// Anzahl der zu übertragenden Bytes übertragen
writer.WriteInt32(App.PhotoBytesToShare.Length);
await writer.StoreAsync();
// Image-Bytes übertragen
writer.WriteBytes(App.PhotoBytesToShare);
await writer.StoreAsync();
await writer.FlushAsync();
UpdateStatus("Übertragung abgeschlossen.");
// Ressourcen freigeben
writer.Dispose();
socket.Dispose();
// Beenden der Annahme von Client-Verbindungen
_listener.Dispose();
}
public static async void SaveTo ( ObservableCollection<RecentData> datas )
{
StorageFile sf = await ApplicationData.Current.LocalFolder.CreateFileAsync ( "data.dat",
Windows.Storage.CreationCollisionOption.ReplaceExisting );
FileRandomAccessStream stream = await sf.OpenAsync ( FileAccessMode.ReadWrite ) as FileRandomAccessStream;
DataWriter dw = new DataWriter ( stream );
dw.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
dw.ByteOrder = ByteOrder.LittleEndian;
dw.WriteInt32 ( datas.Count );
foreach ( RecentData data in datas )
{
dw.WriteUInt32 ( ( uint ) dw.MeasureString ( data.Source ) );
dw.WriteString ( data.Source );
dw.WriteInt32 ( data.SourceIndex );
dw.WriteInt32 ( data.TargetIndex );
}
await dw.StoreAsync ();
await dw.FlushAsync ();
stream.Dispose ();
}
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;
var text = xmldoc.ToString();
var replacedText = text.Replace("contenttype=\"\"", "contenttype=\"image/png\"");
writer.WriteString(replacedText);
await writer.StoreAsync();
await writer.FlushAsync();
writer.DetachStream();
return(outputStream);
}
public async static Task<BitmapImage> getFullImage(int pictureID)
{
var imageString = await SharedFunctions.RunHttpRequestWithStringReturn(new Uri("http://" + MainPage.mainPage.serverIP +
"/server/requestHandler.php?operation=getImage&id=" + pictureID));
using (InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream())
{
byte[] bytes = Convert.FromBase64String(imageString);
using (DataWriter writer = new DataWriter(stream))
{
writer.WriteBytes(bytes);
await writer.StoreAsync();
await writer.FlushAsync();
writer.DetachStream();
}
stream.Seek(0);
var bitmapImage = new BitmapImage();
bitmapImage.SetSource(stream);
return bitmapImage;
}
}
private async Task SendToServer(object arg = null, [CallerMemberName] string method = null)
{
var message = ClientChannelWriteHelper.FormatOutput(arg, method);
using (var socketOperation = _signalingSocketService.SocketOperation)
{
var socket = socketOperation.Socket;
if (socket != null)
{
using (var writer = new DataWriter(socket.OutputStream))
{
writer.WriteString($"{message}{Environment.NewLine}");
await writer.StoreAsync();
await writer.FlushAsync();
writer.DetachStream();
}
}
}
}
private async Task Save()
{
await _operationQueue.Queue((async () =>
{
string content = JsonConvert.SerializeObject(_playlist);
using (var writer = await (await OpenFile()).OpenTransactedWriteAsync())
{
var stream = writer.Stream;
stream.Size = 0;
stream.Seek(0);
var dw = new DataWriter(stream);
dw.WriteString(content);
await dw.StoreAsync();
await dw.FlushAsync();
dw.DetachStream();
await writer.CommitAsync();
}
}));
}
private async Task Send(string stringToSend)
{
using (DataWriter chatWriter = new DataWriter(socket.OutputStream))
{
// string ToSend = "Send Photo";
// chatWriter.WriteUInt32((uint)ToSend.Length);
chatWriter.WriteString(stringToSend);
try
{
await chatWriter.StoreAsync();
}
catch (Exception ex)
{
// MainPage.Current.NotifyUser("Error: " + ex.HResult.ToString() + " - " + ex.Message,
// NotifyType.StatusMessage);
}
await chatWriter.FlushAsync();
chatWriter.DetachStream();
}
receivedMessage = null;
await Task.Delay(2000);
receivedMessage = await Receive();
if (receivedMessage != null)
{
// await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
// async () =>
// {
//RequestAggregateBatteryReport();
MyImageSource = await ImgHelper.ReadImageFromPi(receivedMessage);
RaisePropertyChanged("MyImageSource");
// });
await CalculateShotPoint();
}
}
public async Task Send(string data)
{
byte[] dataBytes = Cryptography.TextManipulation.EncodeUTF(data);
string dataLength = dataBytes.Length.ToString();
DataWriter socketDataWriter=new DataWriter(internalSocket.OutputStream);
byte[] dataToSend = Cryptography.TextManipulation.EncodeUTF(dataLength + "MLEN" + data);
int dataSent = 0;
while(dataSent<dataToSend.Length)
{
int currentChunkSize = CHUNK_SIZE;
if (dataToSend.Length - dataSent < CHUNK_SIZE) currentChunkSize = dataToSend.Length - dataSent;
byte[] chunk = new byte[currentChunkSize];
Array.Copy(dataToSend, dataSent, chunk, 0, currentChunkSize);
socketDataWriter.WriteBytes(chunk);
await socketDataWriter.StoreAsync().AsTask(getTimeoutToken());
await socketDataWriter.FlushAsync().AsTask(getTimeoutToken());
dataSent += currentChunkSize;
repportProgress(dataSent, dataToSend.Length);
}
await socketDataWriter.StoreAsync().AsTask(getTimeoutToken());
await socketDataWriter.FlushAsync().AsTask(getTimeoutToken());
socketDataWriter.DetachStream();
}