| public LoadAsync ( uint count ) : DataReaderLoadOperation | ||
| count | uint | |
| return | DataReaderLoadOperation | |
private async void StreamSkeleton()
{
try
{
var reader = new DataReader( Client.InputStream );
reader.InputStreamOptions = InputStreamOptions.Partial;
while ( IsConnected ) {
await reader.LoadAsync( 4 );
var size = reader.ReadUInt32();
await reader.LoadAsync( size );
byte[] bytes = new byte[size];
reader.ReadBytes( bytes );
MemoryStream ms = new MemoryStream( bytes );
BinaryReader br = new BinaryReader(ms);
SkeletonFrameData frame = br.ReadSkeletonFrame();
SkeletonFrameReadyEventArgs args = new SkeletonFrameReadyEventArgs { SkeletonFrame = frame };
SkeletonFrame = frame;
Context.Send(delegate
{
if(SkeletonFrameReady != null)
SkeletonFrameReady(this, args);
}, null);
}
}
catch(IOException)
{
Disconnect();
}
}
private async void read_data()
{
ifListening = true;
// int read_msg_counter = 2;
using (var reader = new Windows.Storage.Streams.DataReader(streamSocket.InputStream)){
reader.InputStreamOptions = Windows.Storage.Streams.InputStreamOptions.ReadAhead;
reader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
reader.ByteOrder = Windows.Storage.Streams.ByteOrder.LittleEndian;
await reader.LoadAsync(4);
while (reader.UnconsumedBufferLength > 0)
{
// read_msg_counter--;
int bytesToRerad = reader.ReadInt32();
// Debug.Log("bytes to read: " + bytesToRerad);
if (bytesToRerad <= 0)
{
return;
}
await reader.LoadAsync(Convert.ToUInt32(bytesToRerad));
byte[] buffer = new byte[bytesToRerad];
reader.ReadBytes(buffer);
processReceivedData(buffer, bytesToRerad);
await reader.LoadAsync(4);
}
reader.DetachStream();
}
ifListening = false;
}
private async void ReceiveImage(StreamSocket socket)
{
UpdateStatus("Empfange Daten...");
// DataReader erzeugen, um arbeiten mit Bytes zu vereinfachen
var reader = new DataReader(socket.InputStream);
// Anzahl der Bytes abrufen, aus denen das Bild besteht
// Anzahl = int = 4 Bytes => 4 Bytes vom Socket laden
await reader.LoadAsync(4);
int imageSize = reader.ReadInt32();
// Bytearray des Bildes laden
await reader.LoadAsync((uint)imageSize);
byte[] imageBytes = new byte[imageSize];
reader.ReadBytes(imageBytes);
// Bytearray in Stream laden und anzeigen
Dispatcher.BeginInvoke(() =>
{
using (var ms = new MemoryStream(imageBytes))
{
var image = new BitmapImage();
image.SetSource(ms);
ReceivedImage.Source = image;
}
});
UpdateStatus("Bild empfangen.");
// Ressourcen freigeben
reader.Dispose();
}
private async Task<string> DoCommand(string command)
{
StringBuilder strBuilder = new StringBuilder();
using (StreamSocket clientSocket = new StreamSocket())
{
await clientSocket.ConnectAsync(new HostName("192.168.9.108"), "9001");
using (DataWriter writer = new DataWriter(clientSocket.OutputStream))
{
writer.WriteString(command);
await writer.StoreAsync();
writer.DetachStream();
}
using (DataReader reader = new DataReader(clientSocket.InputStream))
{
reader.InputStreamOptions = InputStreamOptions.Partial;
await reader.LoadAsync(8192);
while (reader.UnconsumedBufferLength > 0)
{
strBuilder.Append(reader.ReadString(reader.UnconsumedBufferLength));
await reader.LoadAsync(8192);
}
reader.DetachStream();
}
}
return (strBuilder.ToString());
}
private static async void OnConnection(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
{
ConnectionStatus = ConnectionStatus.Connected;
DataReader reader = new DataReader(args.Socket.InputStream);
try
{
while (true)
{
uint sizeFieldCount = await reader.LoadAsync(sizeof (uint));
if (sizeFieldCount != sizeof (uint))
{
return;
}
uint stringLength = reader.ReadUInt32();
uint actualStringLength = await reader.LoadAsync(stringLength);
if (stringLength != actualStringLength)
{
return;
}
Message = reader.ReadString(actualStringLength);
}
}
catch (Exception e)
{
ConnectionStatus = ConnectionStatus.Failed;
//TODO:send a connection status message with error
}
}
private async void ColorThread()
{
try
{
var reader = new DataReader( Client.InputStream );
reader.InputStreamOptions = InputStreamOptions.Partial;
reader.ByteOrder = ByteOrder.LittleEndian;
while ( IsConnected ) {
await reader.LoadAsync( 4 );
var size = reader.ReadUInt32();
await reader.LoadAsync( size );
byte[] bytes = new byte[size];
reader.ReadBytes( bytes );
MemoryStream ms = new MemoryStream( bytes );
BinaryReader br = new BinaryReader(ms);
ColorFrameReadyEventArgs args = new ColorFrameReadyEventArgs();
ColorFrameData cfd = new ColorFrameData();
cfd.Format = (ImageFormat)br.ReadInt32();
cfd.ImageFrame = br.ReadColorImageFrame();
MemoryStream msData = new MemoryStream( bytes, (int)ms.Position, (int)(ms.Length - ms.Position) );
if (cfd.Format == ImageFormat.Raw)
{
cfd.RawImage = ms.ToArray();
}
else
{
InMemoryRandomAccessStream ras = new InMemoryRandomAccessStream();
DataWriter dw = new DataWriter(ras.GetOutputStreamAt(0));
dw.WriteBytes(msData.ToArray());
await dw.StoreAsync();
// Set to the image
BitmapImage bImg = new BitmapImage();
bImg.SetSource(ras);
cfd.BitmapImage = bImg;
}
ColorFrame = cfd;
args.ColorFrame = cfd;
if (ColorFrameReady != null)
{
ColorFrameReady(this, args);
}
}
}
catch(IOException)
{
Disconnect();
}
}
private async void Listener_ConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
{
Debug.WriteLine("Connection Received on Port {0}", sender.Information.LocalPort);
StreamSocket streamSocket = args.Socket;
if (streamSocket != null)
{
DataReader reader = new DataReader(streamSocket.InputStream);
try
{
// Read first 4 bytes (length of the subsequent string).
uint sizeFieldCount = await reader.LoadAsync(sizeof(uint));
if (sizeFieldCount != sizeof(uint))
{
// The underlying socket was closed before we were able to read the whole data.
return;
}
// Read the length of the 'packet'.
uint length = reader.ReadUInt32();
uint actualLength = await reader.LoadAsync(length);
if (length != actualLength)
{
// The underlying socket was closed before we were able to read the whole data.
return;
}
string name = reader.ReadString(actualLength);
Speaker speaker = new Speaker()
{
Name = name,
Address = streamSocket.Information.RemoteAddress.DisplayName,
Status = "Connected",
Socket = streamSocket
};
await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
() =>
{
Speakers.Add(speaker);
});
reader.DetachStream();
Debug.WriteLine("New speaker added " + name);
}
catch (Exception e)
{
Debug.WriteLine("Error in connection received: " + e);
}
}
}
private async void DepthThread()
{
try {
short[] depthShort = null;
var reader = new DataReader( Client.InputStream );
reader.InputStreamOptions = InputStreamOptions.Partial;
while ( IsConnected ) {
await reader.LoadAsync( 4 );
var size = reader.ReadUInt32();
await reader.LoadAsync( size );
byte[] bytes = new byte[size];
reader.ReadBytes( bytes );
MemoryStream ms = new MemoryStream( bytes );
BinaryReader br = new BinaryReader( ms );
DepthFrameData dfd = new DepthFrameData();
dfd.PlayerIndexBitmask = br.ReadInt32();
dfd.PlayerIndexBitmaskWidth = br.ReadInt32();
DepthImageFrame frame = br.ReadDepthImageFrame();
dfd.ImageFrame = frame;
int dataLength = (int)(ms.Length - ms.Position);
if ( depthShort == null || depthShort.Length != dataLength / 2 )
depthShort = new short[dataLength / 2];
Buffer.BlockCopy( bytes, (int)br.BaseStream.Position, depthShort, 0, dataLength );
dfd.DepthData = depthShort;
DepthFrame = dfd;
DepthFrameReadyEventArgs args = new DepthFrameReadyEventArgs();
args.DepthFrame = dfd;
Context.Send( delegate
{
if ( DepthFrameReady != null )
DepthFrameReady( this, args );
}, null );
}
}
catch ( IOException ) {
Disconnect();
}
}
public async Task WaitForData()
{
var mainPageViewModel = MainPageViewModel.GetInstance();
using (var dr = new DataReader(ServerProxy.TcpSocket.InputStream))
{
while (mainPageViewModel.ConnectionStatus)
{
var stringHeader = await dr.LoadAsync(4);
if (stringHeader == 0)
{
mainPageViewModel.ConnectionStatus = false;
return;
}
int messageLength = dr.ReadInt32();
uint numBytes = await dr.LoadAsync((uint)messageLength);
var packetBaseBuffer = new byte[numBytes];
dr.ReadBytes(packetBaseBuffer);
var packetBase = new PacketBase();
using (var stream = new MemoryStream(packetBaseBuffer))
{
try
{
var reader = new BinaryReader(stream);
packetBase.Read(reader);
}
catch (Exception e)
{
#if DEBUG
throw;
#endif
}
}
var incomingMessage = IncomingMessageFactory.GetMessage(
packetBase.Data as PacketV1);
incomingMessage.HandleMessage();
}
}
}
public static async Task<AppModel> DeserializeAppData()
{
StorageFolder localFolder = ApplicationData.Current.LocalFolder;
AppModel appModel = null;
try
{
// Getting JSON from file if it exists, or file not found exception if it does not
StorageFile textFile = await localFolder.GetFileAsync("app.json");
using (IRandomAccessStream textStream = await textFile.OpenReadAsync())
{
// Read text stream
using (DataReader textReader = new DataReader(textStream))
{
//get size
uint textLength = (uint)textStream.Size;
await textReader.LoadAsync(textLength);
// read it
string jsonContents = textReader.ReadString(textLength);
// deserialize back to our product!
appModel = JsonConvert.DeserializeObject<AppModel>(jsonContents);
}
}
}
catch (Exception ex)
{
throw;
}
return appModel;
}
public static async Task<bool> LoadFrom ( ObservableCollection<RecentData> datas )
{
try
{
StorageFile sf = await ApplicationData.Current.LocalFolder.GetFileAsync ( "data.dat" );
FileRandomAccessStream stream = await sf.OpenAsync ( FileAccessMode.Read ) as FileRandomAccessStream;
DataReader dr = new DataReader ( stream );
dr.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
dr.ByteOrder = ByteOrder.LittleEndian;
await dr.LoadAsync ( ( uint ) stream.Size );
int len = dr.ReadInt32 ();
for ( int i = 0; i < len; i++ )
{
RecentData data = new RecentData ();
uint srclen = dr.ReadUInt32 ();
data.Source = dr.ReadString ( srclen );
data.SourceIndex = dr.ReadInt32 ();
data.TargetIndex = dr.ReadInt32 ();
datas.Add ( data );
}
stream.Dispose ();
}
catch { return false; }
return true;
}
public async Task <string> ReadLogFile(string fileName)
{
if (fileName != this.FQP)
{
int index = fileName.IndexOf(DIRECTORY_NAME);
fileName = fileName.Substring(index);
var file = await Windows.Storage.ApplicationData.Current.LocalFolder.CreateFileAsync(fileName, CreationCollisionOption.OpenIfExists);
if (file == null)
{
return("");
}
return(await Windows.Storage.FileIO.ReadTextAsync(file));
}
if (_logFile != null)
{
using (var inputStream = _stream.GetInputStreamAt(0))
{
Windows.Storage.Streams.DataReader reader = new Windows.Storage.Streams.DataReader(inputStream);
await reader.LoadAsync((uint)_stream.Size);
string data = reader.ReadString((uint)_stream.Size);
reader.DetachStream();
return(data);
}
}
return("");
}
public async void LoadSettings()
{
try
{
string contents;
StorageFolder localFolder = ApplicationData.Current.LocalFolder;
StorageFile textFile = await localFolder.GetFileAsync("settingV2");
using (IRandomAccessStream textStream = await textFile.OpenReadAsync())
{
using (DataReader textReader = new DataReader(textStream))
{
uint textLength = (uint)textStream.Size;
await textReader.LoadAsync(textLength);
contents = textReader.ReadString(textLength);
}
}
string[] lines = contents.Split('\n');
bool.TryParse(lines[0], out AutoJoinChat);
bool.TryParse(lines[1], out LockLandscape);
bool.TryParse(lines[2], out LiveTilesEnabled);
}
catch { }
}
public static async Task<IRandomAccessStream> ConvertToRandomAccessStream(Stream source)
{
Stream streamToConvert = null;
if (!source.CanRead)
throw new Exception("The source cannot be read.");
if (!source.CanSeek)
{
var memStream = new MemoryStream();
await source.CopyToAsync(memStream);
streamToConvert = memStream;
}
else
{
streamToConvert = source;
}
var reader = new DataReader(streamToConvert.AsInputStream());
streamToConvert.Position = 0;
await reader.LoadAsync((uint) streamToConvert.Length);
var buffer = reader.ReadBuffer((uint) streamToConvert.Length);
var randomAccessStream = new InMemoryRandomAccessStream();
var outputStream = randomAccessStream.GetOutputStreamAt(0);
await outputStream.WriteAsync(buffer);
await outputStream.FlushAsync();
return randomAccessStream;
}
/// <summary>
/// Read string content from file.
/// </summary>
/// <param name="path">Location of file, separate by //.</param>
/// <param name="rootFolder"> </param>
/// <returns>Content of file.</returns>
public async Task<string> ReadFromFileAsync(string path, StorageFolder rootFolder = null)
{
if (path == null)
{
return null;
}
try
{
var file = await GetFileToReadAsync(path, rootFolder);
if (file == null)
{
return null;
}
var readStream = await file.OpenAsync(FileAccessMode.Read);
var inputStream = readStream.GetInputStreamAt(0);
var dataReader = new DataReader(inputStream);
var numBytesLoaded = await dataReader.LoadAsync((uint)readStream.Size);
var content = dataReader.ReadString(numBytesLoaded);
dataReader.DetachStream();
dataReader.Dispose();
inputStream.Dispose();
readStream.Dispose();
return content;
}
catch
{
return null;
}
}
async private void OpenGraphFile_Click(object sender, RoutedEventArgs e)
{
var picker = new FileOpenPicker();
picker.FileTypeFilter.Add(".txt");
picker.ViewMode = PickerViewMode.Thumbnail;
picker.SettingsIdentifier = "GraphPicker";
picker.CommitButtonText = "Select Files";
var selectedFile = await picker.PickSingleFileAsync();
using (IRandomAccessStream stream = await selectedFile.OpenReadAsync())
{
using (DataReader reader = new DataReader(stream))
{
uint length = (uint)stream.Size;
await reader.LoadAsync(length);
string[] s = reader.ReadString(length).Split('\r');
string[][] str = new string[s.Length][];
for (int i = 0; i < s.Length; i++)
str[i] = s[i].Replace('\n', ' ').Split(' ');
int n = int.Parse(s[0]);
int[,] adjMatrix = new int[n, n];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
adjMatrix[i, j] = int.Parse(str[i + 1][j + 1]);
adjMatrix[0, 0] += 0;
graph = new Graph(adjMatrix, n);
}
}
}
/// <summary>
/// Receive message through bluetooth.
/// </summary>
protected async Task<byte[]> ReceiveMessages(DataReader dataReader)
{
try
{
// Read the message.
List<Byte> all = new List<byte>();
while (true)
{
var bytesAvailable = await dataReader.LoadAsync(1000);
var byteArray = new byte[bytesAvailable];
dataReader.ReadBytes(byteArray);
if (byteArray.Length > 0 && byteArray[0] != byte.MinValue)
{
if (OnDataRead != null) OnDataRead(byteArray);
return byteArray;
}
Thread.Sleep(100);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
return null;
}
private async void ReadBlock_Click(object sender, RoutedEventArgs e)
{
var fx2Device = DeviceList.Current.GetSelectedDevice();
if (fx2Device == null)
{
rootPage.NotifyUser("Fx2 device not connected or accessible", NotifyType.ErrorMessage);
return;
}
var button = (Button)sender;
button.IsEnabled = false;
var dataReader = new DataReader(fx2Device.InputStream);
// load the data reader from the stream. For purposes of this
// sample, assume all messages read are < 64 bytes
int counter = readCounter++;
LogMessage("Read {0} begin", counter);
await dataReader.LoadAsync(64);
// Get the message string out of the buffer
var message = dataReader.ReadString(dataReader.UnconsumedBufferLength);
LogMessage("Read {0} end: {1}", counter, message);
button.IsEnabled = true;
}
async Task<bool> onewireReset(string deviceId)
{
try
{
if (serialPort != null)
serialPort.Dispose();
serialPort = await SerialDevice.FromIdAsync(deviceId);
// Configure serial settings
serialPort.WriteTimeout = TimeSpan.FromMilliseconds(1000);
serialPort.ReadTimeout = TimeSpan.FromMilliseconds(1000);
serialPort.BaudRate = 9600;
serialPort.Parity = SerialParity.None;
serialPort.StopBits = SerialStopBitCount.One;
serialPort.DataBits = 8;
serialPort.Handshake = SerialHandshake.None;
dataWriteObject = new DataWriter(serialPort.OutputStream);
dataWriteObject.WriteByte(0xF0);
await dataWriteObject.StoreAsync();
dataReaderObject = new DataReader(serialPort.InputStream);
await dataReaderObject.LoadAsync(1);
byte resp = dataReaderObject.ReadByte();
if (resp == 0xFF)
{
System.Diagnostics.Debug.WriteLine("Nothing connected to UART");
return false;
}
else if (resp == 0xF0)
{
System.Diagnostics.Debug.WriteLine("No 1-wire devices are present");
return false;
}
else
{
System.Diagnostics.Debug.WriteLine("Response: " + resp);
serialPort.Dispose();
serialPort = await SerialDevice.FromIdAsync(deviceId);
// Configure serial settings
serialPort.WriteTimeout = TimeSpan.FromMilliseconds(1000);
serialPort.ReadTimeout = TimeSpan.FromMilliseconds(1000);
serialPort.BaudRate = 115200;
serialPort.Parity = SerialParity.None;
serialPort.StopBits = SerialStopBitCount.One;
serialPort.DataBits = 8;
serialPort.Handshake = SerialHandshake.None;
dataWriteObject = new DataWriter(serialPort.OutputStream);
dataReaderObject = new DataReader(serialPort.InputStream);
return true;
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("Exception: " + ex.Message);
return false;
}
}
private async void save_Video(object sender, RoutedEventArgs e)
{
// Adding try catch block in case of occurence of an exception
try
{
// Creating object of FileSavePicker and adding few values to the properties of the object.
FileSavePicker fs = new FileSavePicker();
fs.FileTypeChoices.Add("Video", new List<string>() { ".mp4",".3gp" });
fs.DefaultFileExtension = ".mp4";
fs.SuggestedFileName = "Video" + DateTime.Today.ToString();
fs.SuggestedStartLocation = PickerLocationId.VideosLibrary;
// Using storagefile object defined earlier in above method to save the file using filesavepicker.
fs.SuggestedSaveFile = sf;
// Saving the file
var s = await fs.PickSaveFileAsync();
if (s != null)
{
using (var dataReader = new DataReader(rs.GetInputStreamAt(0)))
{
await dataReader.LoadAsync((uint)rs.Size);
byte[] buffer = new byte[(int)rs.Size];
dataReader.ReadBytes(buffer);
await FileIO.WriteBytesAsync(s, buffer);
}
}
}
catch (Exception ex)
{
var messageDialog = new MessageDialog("Something went wrong.");
await messageDialog.ShowAsync();
}
}
public static async Task<DiscoveryServiceCache> LoadAsync()
{
StorageFolder localFolder = ApplicationData.Current.LocalFolder;
try
{
_lock.EnterReadLock();
StorageFile textFile = await localFolder.GetFileAsync(FileName);
using (IRandomAccessStream textStream = await textFile.OpenReadAsync())
{
using (DataReader textReader = new DataReader(textStream))
{
uint textLength = (uint)textStream.Size;
await textReader.LoadAsync(textLength);
return Load(textReader);
}
}
}
catch (Exception ex)
{
}
finally
{
_lock.ExitReadLock();
}
return null;
}
public void ReadAllText(string filename, Action<string> completed)
{
StorageFolder localFolder =
ApplicationData.Current.LocalFolder;
IAsyncOperation<StorageFile> createOp =
localFolder.GetFileAsync(filename);
createOp.Completed = (asyncInfo1, asyncStatus1) =>
{
IStorageFile storageFile = asyncInfo1.GetResults();
IAsyncOperation<IRandomAccessStreamWithContentType>
openOp = storageFile.OpenReadAsync();
openOp.Completed = (asyncInfo2, asyncStatus2) =>
{
IRandomAccessStream stream = asyncInfo2.GetResults();
DataReader dataReader = new DataReader(stream);
uint length = (uint)stream.Size;
DataReaderLoadOperation loadOp =
dataReader.LoadAsync(length);
loadOp.Completed = (asyncInfo3, asyncStatus3) =>
{
string text = dataReader.ReadString(length);
dataReader.Dispose();
completed(text);
};
};
};
}
public async Task<IEnumerable<Event>> Read()
{
List<Event> events = null;
StorageFolder localFolder = ApplicationData.Current.LocalFolder;
try
{
StorageFile textFile = await localFolder.GetFileAsync("SavedContent");
events = new List<Event>();
using (IRandomAccessStream textStream = await textFile.OpenReadAsync())
{
using (DataReader textReader = new DataReader(textStream))
{
uint textLength = (uint)textStream.Size;
await textReader.LoadAsync(textLength);
string jsonContents = textReader.ReadString(textLength);
events = JsonConvert.DeserializeObject<IList<Event>>(jsonContents) as List<Event>;
}
return events;
}
}
catch (Exception ex)
{
return null;
}
}
async void OnFileOpenButtonClick(object sender, RoutedEventArgs args) {
FileOpenPicker picker = new FileOpenPicker();
picker.FileTypeFilter.Add(".txt");
StorageFile storageFile = await picker.PickSingleFileAsync();
// If user presses Cancel, result is null
if (storageFile == null)
return;
Exception exception = null;
try {
using (IRandomAccessStream stream = await storageFile.OpenReadAsync()) {
using (DataReader dataReader = new DataReader(stream)) {
uint length = (uint)stream.Size;
await dataReader.LoadAsync(length);
txtbox.Text = dataReader.ReadString(length);
}
}
}
catch (Exception exc) {
exception = exc;
}
if (exception != null) {
MessageDialog msgdlg = new MessageDialog(exception.Message, "File Read Error");
await msgdlg.ShowAsync();
}
}
private async void ReadFromStreamButton_Click(object sender, RoutedEventArgs e)
{
StorageFile file = rootPage.sampleFile;
if (file != null)
{
try
{
using (IRandomAccessStream readStream = await file.OpenAsync(FileAccessMode.Read))
{
using (DataReader dataReader = new DataReader(readStream))
{
UInt64 size = readStream.Size;
if (size <= UInt32.MaxValue)
{
UInt32 numBytesLoaded = await dataReader.LoadAsync((UInt32)size);
string fileContent = dataReader.ReadString(numBytesLoaded);
rootPage.NotifyUser(String.Format("The following text was read from '{0}' using a stream:{1}{2}", file.Name, Environment.NewLine, fileContent), NotifyType.StatusMessage);
}
else
{
rootPage.NotifyUser(String.Format("File {0} is too big for LoadAsync to load in a single chunk. Files larger than 4GB need to be broken into multiple chunks to be loaded by LoadAsync.", file.Name), NotifyType.ErrorMessage);
}
}
}
}
catch (FileNotFoundException)
{
rootPage.NotifyUserFileNotExist();
}
}
else
{
rootPage.NotifyUserFileNotExist();
}
}
private async void Read()
{
_reader = new DataReader(_socket.InputStream);
try
{
while (true)
{
uint sizeFieldCount = await _reader.LoadAsync(sizeof(uint));
//if desconneted
if (sizeFieldCount != sizeof(uint))
return;
uint stringLenght = _reader.ReadUInt32();
uint actualStringLength = await _reader.LoadAsync(stringLenght);
//if desconneted
if (stringLenght != actualStringLength)
return;
if (OnDataRecived != null)
OnDataRecived(_reader.ReadString(actualStringLength));
}
}
catch (Exception ex)
{
if (OnError != null)
OnError(ex.Message);
}
}
public async static Task<IRandomAccessStream> AsRandomAccessStreamAsync(this Stream stream)
{
Stream streamToConvert = null;
if (!stream.CanRead)
{
throw new Exception("Cannot read the source stream-");
}
if (!stream.CanSeek)
{
MemoryStream memoryStream = new MemoryStream();
await stream.CopyToAsync(memoryStream);
streamToConvert = memoryStream;
}
else
{
streamToConvert = stream;
}
DataReader dataReader = new DataReader(streamToConvert.AsInputStream());
streamToConvert.Position = 0;
await dataReader.LoadAsync((uint)streamToConvert.Length);
IBuffer buffer = dataReader.ReadBuffer((uint)streamToConvert.Length);
InMemoryRandomAccessStream randomAccessStream = new InMemoryRandomAccessStream();
IOutputStream outputstream = randomAccessStream.GetOutputStreamAt(0);
await outputstream.WriteAsync(buffer);
await outputstream.FlushAsync();
return randomAccessStream;
}
private async Task<string> readHTTPMessage(DataReader dr)
{
// Make sure we are allowed to return early
dr.InputStreamOptions = InputStreamOptions.Partial;
// This is the value we will return
string ret = "";
// This is the amount of data ready to be read in
uint readyLen;
while (true)
{
// Wait until we've got a kilobyte, or the stream closed
readyLen = await dr.LoadAsync(1024 * 1024);
// Check to see if we actually have any data
if (readyLen > 0)
{
// Read in that string, append it to ret
ret += dr.ReadString(readyLen);
// Check for the "\r\n\r\n" at the end of messages
if (ret.Substring(ret.Length - 4, 4) == "\r\n\r\n")
break;
}
else
{
// If not, the connection is closed!
return ret;
}
}
// Finally, return that string
return ret;
}
private async void ProtectData()
{
if (await storageFolder.TryGetItemAsync("config.txt") != null) // if user file exists
{
configSF = await storageFolder.GetFileAsync("config.txt");
var stream = await configSF.OpenAsync(Windows.Storage.FileAccessMode.Read);
ulong size = stream.Size;
using (var inputStream = stream.GetInputStreamAt(0))
{
using (var dataReader = new Windows.Storage.Streams.DataReader(inputStream))
{
uint numBytesLoaded = await dataReader.LoadAsync((uint)size);
IBuffer textBuffer = dataReader.ReadBuffer(numBytesLoaded);
string text = await SampleDataUnprotectStream(textBuffer, encoding);
if (text.Length != 0 && text.IndexOf(" ") > 0)
{
Username.Text = text.Substring(0, text.IndexOf(" "));
Password.Password = text.Substring(text.IndexOf(" ") + 1);
saveLogin = true;
SavePasswordCheckBox.IsChecked = true;
}
}
}
}
}
private async void ReadFromStreamButton_Click(object sender, RoutedEventArgs e)
{
try
{
rootPage.ResetScenarioOutput(OutputTextBlock);
StorageFile file = rootPage.sampleFile;
if (file != null)
{
using (IRandomAccessStream readStream = await file.OpenAsync(FileAccessMode.Read))
{
using (DataReader dataReader = new DataReader(readStream))
{
UInt64 size = readStream.Size;
if (size <= UInt32.MaxValue)
{
UInt32 numBytesLoaded = await dataReader.LoadAsync((UInt32)size);
string fileContent = dataReader.ReadString(numBytesLoaded);
OutputTextBlock.Text = "The following text was read from '" + file.Name + "' using a stream:" + Environment.NewLine + Environment.NewLine + fileContent;
}
else
{
OutputTextBlock.Text = "File " + file.Name + " is too big for LoadAsync to load in a single chunk. Files larger than 4GB need to be broken into multiple chunks to be loaded by LoadAsync.";
}
}
}
}
}
catch (FileNotFoundException)
{
rootPage.NotifyUserFileNotExist();
}
}
private async Task<RfidReaderResult> Read()
{
RfidReaderResult retvalue = new RfidReaderResult();
var dataReader = new DataReader(_rfidReader.InputStream);
try
{
SetStatus("Awaiting Data from RFID Reader");
var numBytesRecvd = await dataReader.LoadAsync(1024);
retvalue.Result = new byte[numBytesRecvd];
if (numBytesRecvd > 0)
{
SetStatus("Data successfully read from RFID Reader");
dataReader.ReadBytes(retvalue.Result);
retvalue.IsSuccessful = true;
retvalue.Message = "Data successfully read from RFID Reader";
}
}
catch (Exception ex)
{
retvalue.IsSuccessful = false;
retvalue.Message = ex.Message;
}
finally
{
if (dataReader != null)
{
dataReader.DetachStream();
dataReader = null;
}
}
return retvalue;
}
byte [] LoadModel(Windows.Storage.StorageFolder folder, string path)
{
try
{
var task = folder.GetFileAsync(path).AsTask();
task.Wait();
var streamTask = task.Result.OpenReadAsync().AsTask();
streamTask.Wait();
using (var stream = streamTask.Result)
{
using (var reader = new Windows.Storage.Streams.DataReader(stream))
{
var len = stream.Size;
reader.LoadAsync((uint)len).AsTask().Wait();
byte[] content = new byte[len];
reader.ReadBytes(content);
return(content);
}
}
} catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
System.Diagnostics.Debug.WriteLine(ex.StackTrace);
}
return(null);
}
public async void OnOpen()
{
try
{
var picker = new FileOpenPicker()
{
SuggestedStartLocation = PickerLocationId.DocumentsLibrary
};
picker.FileTypeFilter.Add(".txt");
StorageFile file = await picker.PickSingleFileAsync();
if (file != null)
{
IRandomAccessStreamWithContentType stream = await file.OpenReadAsync();
using (var reader = new DataReader(stream))
{
await reader.LoadAsync((uint)stream.Size);
text1.Text = reader.ReadString((uint)stream.Size);
}
}
}
catch (Exception ex)
{
var dlg = new MessageDialog(ex.Message, "Error");
await dlg.ShowAsync();
}
}
private async void OnRead(Object sender, RoutedEventArgs e)
{
StorageFolder local = ApplicationData.Current.LocalFolder;
StorageFile file = await local.GetFileAsync("demo.dat");
if(file != null)
{
string strres = "读到的内容：\n";
using(IRandomAccessStream stream = await file.OpenReadAsync())
{
DataReader dr = new DataReader(stream);
dr.UnicodeEncoding = UnicodeEncoding.Utf8;
await dr.LoadAsync((uint)stream.Size);
bool b = dr.ReadBoolean();
strres += b.ToString() + "\n";
DateTimeOffset dt = dr.ReadDateTime();
strres += dt.ToString("yyyy-M-d") + "\n";
uint len = dr.ReadUInt32();
if(len > 0)
{
strres += dr.ReadString(len);
}
dr.Dispose();
}
tbResult.Text = strres;
}
}
public static async Task <byte[]> AsByteArrayAsync(this IRandomAccessStream iRandomAccessStream)
{
IRandomAccessStream fileStream = iRandomAccessStream;
var reader = new Windows.Storage.Streams.DataReader(fileStream.GetInputStreamAt(0));
await reader.LoadAsync((uint)fileStream.Size);
byte[] pixels = new byte[fileStream.Size];
reader.ReadBytes(pixels);
return(pixels);
}
public static async Task <byte[]> GetBytesAsync(this storage.StorageFile file)
{
sStream.IRandomAccessStream fileStream = await file.OpenAsync(storage.FileAccessMode.Read);
var reader = new sStream.DataReader(fileStream.GetInputStreamAt(0));
await reader.LoadAsync((uint)fileStream.Size);
byte[] bytes = new byte[fileStream.Size];
reader.ReadBytes(bytes);
return(bytes);
}
public static async Task <byte[]> GetBytesFromStorageFile(StorageFile file)
{
IRandomAccessStream fileStream = await file.OpenAsync(FileAccessMode.Read);
var reader = new Windows.Storage.Streams.DataReader(fileStream.GetInputStreamAt(0));
await reader.LoadAsync((uint)fileStream.Size);
byte[] pixels = new byte[fileStream.Size];
reader.ReadBytes(pixels);
return(pixels);
}
public async void StartReader(ConnectedPeer connectedPeer)
{
try
{
using (var socketReader = new Windows.Storage.Streams.DataReader(connectedPeer._socket.InputStream))
{
// Read the message sent by the remote peer
uint bytesRead = await socketReader.LoadAsync(sizeof(uint));
if (bytesRead > 0)
{
uint strLength = (uint)socketReader.ReadUInt32();
bytesRead = await socketReader.LoadAsync(strLength);
if (bytesRead > 0)
{
String message = socketReader.ReadString(strLength);
OnRaiseMessageEvent(new MessageEventArgs("Got message: " + message));
StartReader(connectedPeer); // Start another reader
}
else
{
OnRaiseSocketErrorEvent(new SocketEventArgs("The remote side closed the socket"));
}
}
else
{
OnRaiseSocketErrorEvent(new SocketEventArgs("The remote side closed the socket"));
}
socketReader.DetachStream();
}
}
catch (Exception e)
{
if (!connectedPeer._socketClosed)
{
OnRaiseSocketErrorEvent(new SocketEventArgs("Reading from socket failed: " + e.Message));
}
}
}
public async Task <T> LoadASync(string FileName)
{
FileName = FileName + ".xml";
try
{
StorageFile file = null;
StorageFolder folder = GetFolder(storageType);
file = await folder.GetFileAsync(FileName);
//using (var readStream = await file.OpenAsync(FileAccessMode.Read))
//{
// Windows.Storage.Streams.DataReader reader = new Windows.Storage.Streams.DataReader(readStream);
// await reader.LoadAsync((uint)readStream.Size);
// string data = reader.ReadString((uint)readStream.Size);
// if (data == null)
// {
// }
//}
using (var readStream = await file.OpenAsync(FileAccessMode.Read))
{
//Stream inStream = Task.Run(() => readStream.AsStreamForRead()).Result;
//return (T)serializer.Deserialize(inStream);
var inStream = readStream.GetInputStreamAt(0);
Windows.Storage.Streams.DataReader reader = new Windows.Storage.Streams.DataReader(inStream);
await reader.LoadAsync((uint)readStream.Size);
string data = reader.ReadString((uint)readStream.Size);
reader.DetachStream();
MemoryStream ms = new MemoryStream(UTF8Encoding.UTF8.GetBytes(data));
DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(T));
T result = (T)ser.ReadObject(ms);
return(result);
}
}
catch (FileNotFoundException)
{
//file not existing is perfectly valid so simply return the default
return(default(T));
//throw;
}
catch (Exception)
{
//Unable to load contents of file
throw;
}
}
internal async void InitPreviewImage()
{
if (this.Source == null)
{
return;
}
using (var fileStream = await this.Source.OpenReadAsync())
{
InMemoryRandomAccessStream memoryStream = new InMemoryRandomAccessStream();
using (var readStream = fileStream.GetInputStreamAt(0))
{
var reader = new Windows.Storage.Streams.DataReader(readStream);
await reader.LoadAsync((uint)fileStream.Size);
byte[] bytes = new byte[fileStream.Size];
reader.ReadBytes(bytes);
var writeStream = memoryStream.GetOutputStreamAt(0).AsStreamForWrite();
writeStream.WriteAsync(bytes, 0, (int)fileStream.Size);
await writeStream.FlushAsync();
}
this.modifiedBitmapStream = memoryStream.CloneStream();
this.previewBitmapStream = this.modifiedBitmapStream;
}
var decoder = await BitmapDecoder.CreateAsync(this.previewBitmapStream);
// this.originalBitmapStream = await this.Source.OpenReadAsync();
// this.previewBitmapStream = await this.Source.OpenReadAsync();
var properties = await this.Source.Properties.GetImagePropertiesAsync();
System.Threading.SynchronizationContext.Current.Post((args) =>
{
System.Threading.SynchronizationContext.Current.Post((args2) =>
{
this.previewBitmap = new WriteableBitmap((int)properties.Width, (int)properties.Height);
this.originalBitmap = new WriteableBitmap((int)properties.Width, (int)properties.Height);
this.previewBitmap.SetSource(this.modifiedBitmapStream);
this.originalBitmap.SetSource(this.modifiedBitmapStream);
this.previewBitmap.Invalidate();
this.originalBitmap.Invalidate();
this.ModifiedImage = this.previewBitmap;
}, null);
}, null);
}
public static async Task <byte[]> AsByteArrayAsync(this StorageFile file, string ReplaceLocalFileNameWithExtension, uint ImageWidthHeight)
{
var imgThumbnail = await file.GetThumbnailAsync(ThumbnailMode.PicturesView, ImageWidthHeight, ThumbnailOptions.ResizeThumbnail);
BitmapImage bitmapImage = new BitmapImage();
bitmapImage.DecodePixelHeight = (int)ImageWidthHeight;
bitmapImage.DecodePixelWidth = (int)ImageWidthHeight;
bitmapImage.SetSource(imgThumbnail);
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(imgThumbnail.CloneStream());
SoftwareBitmap softwareBitmap = await decoder.GetSoftwareBitmapAsync();
var LocalFolder = ApplicationData.Current.LocalFolder;
StorageFile file_Save = await LocalFolder.CreateFileAsync(ReplaceLocalFileNameWithExtension, CreationCollisionOption.ReplaceExisting);
BitmapEncoder encoder = await BitmapEncoder.CreateAsync(Windows.Graphics.Imaging.BitmapEncoder.JpegEncoderId, await file_Save.OpenAsync(FileAccessMode.ReadWrite));
encoder.SetSoftwareBitmap(softwareBitmap);
encoder.BitmapTransform.InterpolationMode = BitmapInterpolationMode.Linear;
encoder.BitmapTransform.ScaledHeight = ImageWidthHeight;
encoder.BitmapTransform.ScaledWidth = ImageWidthHeight;
encoder.BitmapTransform.Bounds = new BitmapBounds()
{
Width = ImageWidthHeight,
Height = ImageWidthHeight,
};
await encoder.FlushAsync();
IRandomAccessStream fileStream = await file_Save.OpenAsync(FileAccessMode.ReadWrite);
var reader = new Windows.Storage.Streams.DataReader(fileStream.GetInputStreamAt(0));
await reader.LoadAsync((uint)fileStream.Size);
byte[] pixels = new byte[fileStream.Size];
reader.ReadBytes(pixels);
return(pixels);
}
private async void LoadImage(object sender, RoutedEventArgs e)
{
FileOpenPicker open = new FileOpenPicker();
open.SuggestedStartLocation = PickerLocationId.PicturesLibrary;
open.ViewMode = PickerViewMode.Thumbnail;
// Filter to include a sample subset of file types
open.FileTypeFilter.Clear();
open.FileTypeFilter.Add(".bmp");
open.FileTypeFilter.Add(".png");
open.FileTypeFilter.Add(".jpeg");
open.FileTypeFilter.Add(".jpg");
StorageFile file = await open.PickSingleFileAsync();
if (file != null)
{
// Ensure the stream is disposed once the image is loaded
using (IRandomAccessStream fileStream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read))
{
// Set the image source to the selected bitmap
/* BitmapImage bitmapImage = new BitmapImage();
* bitmapImage.DecodePixelHeight = 250;
* bitmapImage.DecodePixelWidth = 250;
*
* await bitmapImage.SetSourceAsync(fileStream);
* _image = bitmapImage;*/
var reader = new Windows.Storage.Streams.DataReader(fileStream.GetInputStreamAt(0));
await reader.LoadAsync((uint)fileStream.Size);
byte[] pixels = new byte[fileStream.Size];
reader.ReadBytes(pixels);
_image = pixels;
}
}
}
public override void save(java.io.InputStream image, java.io.OutputStream response, string format, int width, int height, float quality)
{
CanvasBitmapFileFormat fileFormat = CanvasBitmapFileFormat.Png;
if (format.Equals(FORMAT_JPEG))
{
fileFormat = CanvasBitmapFileFormat.Jpeg;
}
CodenameOneImage img = (CodenameOneImage)SilverlightImplementation.instance.createImage(image);
CodenameOneImage scaledImage = (CodenameOneImage)SilverlightImplementation.instance.scale(img, width, height);
InMemoryRandomAccessStream ms = new InMemoryRandomAccessStream();
scaledImage.image.SaveAsync(ms, fileFormat, quality).AsTask().ConfigureAwait(false).GetAwaiter().GetResult();
ms.Seek(0);
byte[] buf = new byte[ms.Size];
var dr = new Windows.Storage.Streams.DataReader(ms);
dr.LoadAsync((uint)ms.Size).AsTask().ConfigureAwait(false).GetAwaiter().GetResult();
dr.ReadBytes(buf);
response.write(buf);
}
protected override void saveImage(com.codename1.ui.Image image, java.io.OutputStream response, string format, float quality)
{
CanvasBitmapFileFormat fileFormat = CanvasBitmapFileFormat.Png;
if (format.Equals(FORMAT_JPEG))
{
fileFormat = CanvasBitmapFileFormat.Jpeg;
}
CodenameOneImage img = (CodenameOneImage)image.getImage();
CanvasBitmap cb = img.image;
InMemoryRandomAccessStream ms = new InMemoryRandomAccessStream();
cb.SaveAsync(ms, fileFormat, quality).AsTask().ConfigureAwait(false).GetAwaiter().GetResult();;
ms.Seek(0);
byte[] buf = new byte[ms.Size];
var dr = new Windows.Storage.Streams.DataReader(ms);
dr.LoadAsync((uint)ms.Size).AsTask().ConfigureAwait(false).GetAwaiter().GetResult();;
dr.ReadBytes(buf);
response.write(buf);
}
private async static Task <bool> SaveStreamTo3MF(Windows.Storage.Streams.IRandomAccessStream stream)
{
// set back
stream.Seek(0);
using (var dataReader = new Windows.Storage.Streams.DataReader(stream))
{
var dataLoad = await dataReader.LoadAsync((uint)stream.Size);
if (dataLoad > 0)
{
var buffer = dataReader.ReadBuffer((uint)stream.Size);
StorageFolder localFolder = ApplicationData.Current.LocalFolder;
var outputfile = await localFolder.CreateFileAsync("output.3mf", CreationCollisionOption.ReplaceExisting);
await Windows.Storage.FileIO.WriteBufferAsync(outputfile, buffer);
var options = new Windows.System.LauncherOptions();
options.TargetApplicationPackageFamilyName = "Microsoft.3DBuilder_8wekyb3d8bbwe";
}
}
return(true);
}
private async Task TryPostJsonAsync()
{
try
{
// Construct the HttpClient and Uri. This endpoint is for test purposes only.
//var myFilter = new Windows.Web.Http.Filters.HttpBaseProtocolFilter();
//myFilter.AllowUI = false;
//Windows.Web.Http.Filters.HttpBaseProtocolFilter filter = new Windows.Web.Http.Filters.HttpBaseProtocolFilter();
//Windows.Storage.StorageFolder storageFolder = KnownFolders.DocumentsLibrary;
fileOpenPicker.FileTypeFilter.Add(".json");
/*fileOpenPicker.FileTypeFilter.Add(".txt");
* Windows.Storage.StorageFile credentialsFile = await fileOpenPicker.PickSingleFileAsync();
* string text = await Windows.Storage.FileIO.ReadTextAsync(credentialsFile);
* string username = text.Split(',')[0];
* string password = text.Split(',')[1];
* string domain = text.Split(',')[2];*/
HttpClientHandler handler = new HttpClientHandler();
handler.Credentials = new NetworkCredential("", "", "");
System.Net.Http.HttpClient httpClient = new System.Net.Http.HttpClient(handler);
httpClient.DefaultRequestHeaders.Clear();
httpClient.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
Uri uri = new Uri("https://prodigalcompany.com/npjTest/SurveyStuff/testSurveyFile.json");
// Construct the JSON to post.
//fileOpenPicker.FileTypeChoices.Add("JSON", new List<string>() { ".json" });
IStorageFile jsonFile = await fileOpenPicker.PickSingleFileAsync();
IRandomAccessStream stream = await jsonFile.OpenAsync(FileAccessMode.Read);
System.Net.Http.MultipartFormDataContent postContent = new MultipartFormDataContent();
if (stream != null)
{
using (var dataReader = new Windows.Storage.Streams.DataReader(stream))
{
uint numBytesLoaded = await dataReader.LoadAsync((uint)stream.Size);
string jsonText = dataReader.ReadString(numBytesLoaded);
System.Net.Http.StringContent streamContent = new System.Net.Http.StringContent(jsonText);
streamContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json");
postContent.Add(streamContent);
System.Net.Http.HttpResponseMessage httpResponseMessage = await httpClient.PostAsync(
"https://prodigalcompany.com/npjTest/SurveyStuff/testSurveyFile.json",
postContent);
// Make sure the post succeeded, and write out the response.
httpResponseMessage.EnsureSuccessStatusCode();
var httpResponseBody = await httpResponseMessage.Content.ReadAsStringAsync();
Debug.WriteLine(httpResponseBody);
}
}
else
{
Debug.WriteLine("stream is NULL.");
}
//HttpStringContent content = await jsonFile.OpenReadAsync();
// Post the JSON and wait for a response.
}
catch (Exception ex)
{
// Write out any exceptions.
Debug.WriteLine(ex);
}
}
async void beginexecblock()
{
if ((await Windows.Storage.ApplicationData.Current.RoamingFolder.GetFilesAsync()).Count == 0)
{
await ApplicationData.Current.RoamingFolder.CreateFileAsync("testfile.txt");
ApplicationData.Current.SignalDataChanged();
Windows.UI.Popups.MessageDialog tdlg = new Windows.UI.Popups.MessageDialog("Roaming file creation success", "Sync status");
await tdlg.ShowAsync();
}
try
{
DateTime started = DateTime.Now;
RenderContext mtext = new RenderContext();
maincontext = mtext;
StorageFolder folder = Windows.ApplicationModel.Package.Current.InstalledLocation;
StorageFile file = await folder.GetFileAsync("DXInteropLib\\VertexShader.cso");
var stream = (await file.OpenAsync(FileAccessMode.Read));
Windows.Storage.Streams.DataReader mreader = new Windows.Storage.Streams.DataReader(stream.GetInputStreamAt(0));
byte[] dgram = new byte[file.Size];
await mreader.LoadAsync((uint)dgram.Length);
mreader.ReadBytes(dgram);
file = await folder.GetFileAsync("DXInteropLib\\PixelShader.cso");
stream = await file.OpenAsync(FileAccessMode.Read);
mreader = new Windows.Storage.Streams.DataReader(stream.GetInputStreamAt(0));
byte[] mgram = new byte[file.Size];
await mreader.LoadAsync((uint)file.Size);
mreader.ReadBytes(mgram);
try
{
defaultshader = mtext.CreateShader(dgram, mgram);
mtext.InitializeLayout(dgram);
defaultshader.Apply();
mtext.OnRenderFrame += onrenderframe;
}
catch (Exception er)
{
Windows.UI.Popups.MessageDialog mdlg = new Windows.UI.Popups.MessageDialog(er.ToString(), "Fatal error");
mdlg.ShowAsync().Start();
}
IStorageFile[] files = (await folder.GetFilesAsync()).ToArray();
bool founddata = false;
foreach (IStorageFile et in files)
{
if (et.FileName.Contains("rawimage.dat"))
{
stream = await et.OpenAsync(FileAccessMode.Read);
founddata = true;
}
}
int width;
int height;
byte[] rawdata;
if (!founddata)
{
file = await folder.GetFileAsync("TestProgram\\test.png");
stream = await file.OpenAsync(FileAccessMode.Read);
var decoder = await Windows.Graphics.Imaging.BitmapDecoder.CreateAsync(stream);
var pixeldata = await decoder.GetPixelDataAsync(Windows.Graphics.Imaging.BitmapPixelFormat.Rgba8, Windows.Graphics.Imaging.BitmapAlphaMode.Straight, new Windows.Graphics.Imaging.BitmapTransform(), Windows.Graphics.Imaging.ExifOrientationMode.IgnoreExifOrientation, Windows.Graphics.Imaging.ColorManagementMode.DoNotColorManage);
width = (int)decoder.PixelWidth;
height = (int)decoder.PixelHeight;
rawdata = pixeldata.DetachPixelData();
file = await folder.CreateFileAsync("rawimage.dat");
stream = (await file.OpenAsync(FileAccessMode.ReadWrite));
var realstream = stream.GetOutputStreamAt(0);
DataWriter mwriter = new DataWriter(realstream);
mwriter.WriteInt32(width);
mwriter.WriteInt32(height);
mwriter.WriteBytes(rawdata);
await mwriter.StoreAsync();
await realstream.FlushAsync();
}
else
{
DataReader treader = new DataReader(stream.GetInputStreamAt(0));
await treader.LoadAsync((uint)stream.Size);
rawdata = new byte[stream.Size - (sizeof(int) * 2)];
width = treader.ReadInt32();
height = treader.ReadInt32();
treader.ReadBytes(rawdata);
}
Texture2D mtex = maincontext.createTexture2D(rawdata, width, height);
List <VertexPositionNormalTexture> triangle = new List <VertexPositionNormalTexture>();
triangle.Add(new VertexPositionNormalTexture(new Vector3(-.5f, -.5f, 0), new Vector3(1, 1, 1), new Vector2(0, 0)));
triangle.Add(new VertexPositionNormalTexture(new Vector3(0, 0.5f, 0), new Vector3(1, 1, 1), new Vector2(1, 0)));
triangle.Add(new VertexPositionNormalTexture(new Vector3(.5f, -0.5f, 0), new Vector3(1, 1, 1), new Vector2(1, 1)));
byte[] gpudata = VertexPositionNormalTexture.Serialize(triangle.ToArray());
VertexBuffer mbuffer = maincontext.createVertexBuffer(gpudata, VertexPositionNormalTexture.Size);
mbuffer.Apply(VertexPositionNormalTexture.Size);
vertcount = 3;
Windows.UI.Popups.MessageDialog tdlg = new Windows.UI.Popups.MessageDialog("Unit tests successfully completed\nShader creation: Success\nTexture load: Success\nVertex buffer creation: Success\nTime:" + (DateTime.Now - started).ToString(), "Results");
tdlg.ShowAsync().Start();
}
catch (Exception er)
{
Windows.UI.Popups.MessageDialog tdlg = new Windows.UI.Popups.MessageDialog(er.ToString(), "Fatal error");
tdlg.ShowAsync().Start();
}
}
private async Task <string> ExecuteCommandLineString(string CommandString)
{
const string CommandLineProcesserExe = "c:\\windows\\system32\\cmd.exe";
const uint CommandStringResponseBufferSize = 8192;
string currentDirectory = "C:\\";
StringBuilder textOutput = new StringBuilder((int)CommandStringResponseBufferSize);
uint bytesLoaded = 0;
if (string.IsNullOrWhiteSpace(CommandString))
{
return("");
}
var commandLineText = CommandString.Trim();
var standardOutput = new Windows.Storage.Streams.InMemoryRandomAccessStream();
var standardError = new Windows.Storage.Streams.InMemoryRandomAccessStream();
var options = new Windows.System.ProcessLauncherOptions {
StandardOutput = standardOutput,
StandardError = standardError
};
try {
var args = "/C \"cd \"" + currentDirectory + "\" & " + commandLineText + "\"";
var result = await Windows.System.ProcessLauncher.RunToCompletionAsync(CommandLineProcesserExe, args, options);
//First write std out
using (var outStreamRedirect = standardOutput.GetInputStreamAt(0)) {
using (var dataReader = new Windows.Storage.Streams.DataReader(outStreamRedirect)) {
while ((bytesLoaded = await dataReader.LoadAsync(CommandStringResponseBufferSize)) > 0)
{
textOutput.Append(dataReader.ReadString(bytesLoaded));
}
new System.Threading.ManualResetEvent(false).WaitOne(10);
if ((bytesLoaded = await dataReader.LoadAsync(CommandStringResponseBufferSize)) > 0)
{
textOutput.Append(dataReader.ReadString(bytesLoaded));
}
}
}
//Then write std err
using (var errStreamRedirect = standardError.GetInputStreamAt(0)) {
using (var dataReader = new Windows.Storage.Streams.DataReader(errStreamRedirect)) {
while ((bytesLoaded = await dataReader.LoadAsync(CommandStringResponseBufferSize)) > 0)
{
textOutput.Append(dataReader.ReadString(bytesLoaded));
}
new System.Threading.ManualResetEvent(false).WaitOne(10);
if ((bytesLoaded = await dataReader.LoadAsync(CommandStringResponseBufferSize)) > 0)
{
textOutput.Append(dataReader.ReadString(bytesLoaded));
}
}
}
return(textOutput.ToString());
} catch (UnauthorizedAccessException uex) {
return("ERROR - " + uex.Message + "\n\nCmdNotEnabled");
} catch (Exception ex) {
return("ERROR - " + ex.Message + "\n");
}
}