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 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();
}
}
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 Task SaveBitmap(RenderTargetBitmap rtb, SoftwareBitmap swBmp)
{
FileSavePicker filePicker = new Windows.Storage.Pickers.FileSavePicker();
filePicker.SuggestedStartLocation = PickerLocationId.PicturesLibrary;
filePicker.FileTypeChoices.Add("JPG file", new List <string>()
{
".jpg"
});
StorageFile file = await filePicker.PickSaveFileAsync();
if (file != null)
{
using (var stream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
IBuffer buffer = await rtb.GetPixelsAsync();
Windows.Storage.Streams.DataReader dataReader = Windows.Storage.Streams.DataReader.FromBuffer(buffer);
byte[] generatedImage = new byte[buffer.Length];
dataReader.ReadBytes(generatedImage);
var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.BmpEncoderId, stream);
encoder.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied, (uint)rtb.PixelWidth, (uint)rtb.PixelHeight, swBmp.DpiX, swBmp.DpiY, generatedImage);
await encoder.FlushAsync();
}
}
}
/// <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 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;
}
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();
}
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);
}
private static async Task<byte[]> ConvertIRandomAccessStreamByte(IRandomAccessStream stream)
{
DataReader read = new DataReader(stream.GetInputStreamAt(0));
await read.LoadAsync((uint)stream.Size);
byte[] temp = new byte[stream.Size];
read.ReadBytes(temp);
return temp;
}
public string Receive()
{
IInputStream istream = this.streamSocket.InputStream;
var dataReader = new DataReader(istream);
byte[] msgSizeByteArray = new byte[4];
dataReader.LoadAsync(4).AsTask().Wait();
dataReader.ReadBytes(msgSizeByteArray);
int msgSize = Helpers.byteArrayToInt(msgSizeByteArray);
byte[] msgByteArray = new byte[msgSize];
dataReader.LoadAsync((uint) msgSize).AsTask().Wait();
dataReader.ReadBytes(msgByteArray);
string message = Helpers.byteArrayToString(msgByteArray);
return message;
}
/// <summary>
/// Returns a byte array with the content of the stream.
/// </summary>
/// <param name="stream">stream to get bytes for</param>
/// <returns>awaitable byte array</returns>
public static async Task<byte[]> GetPhotoBits(IRandomAccessStream stream)
{
Debug.Assert(stream != null, "GetPhotoBits should not be called with a null stream.");
var reader = new DataReader(stream.GetInputStreamAt(0));
var bytes = new byte[stream.Size];
await reader.LoadAsync((uint)stream.Size);
reader.ReadBytes(bytes);
return bytes;
}
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();
}
}
/// <summary>
/// Uploads an activity.
/// </summary>
/// <param name="file">The path to the activity file on your local hard disk.</param>
/// <param name="dataFormat">The format of the file.</param>
/// <param name="activityType">The type of the activity.</param>
/// <returns>The status of the upload.</returns>
public async Task<UploadStatus> UploadActivityAsync(StorageFile file, DataFormat dataFormat, ActivityType activityType = ActivityType.Ride)
{
String format = String.Empty;
switch (dataFormat)
{
case DataFormat.Fit:
format = "fit";
break;
case DataFormat.FitGZipped:
format = "fit.gz";
break;
case DataFormat.Gpx:
format = "gpx";
break;
case DataFormat.GpxGZipped:
format = "gpx.gz";
break;
case DataFormat.Tcx:
format = "tcx";
break;
case DataFormat.TcxGZipped:
format = "tcx.gz";
break;
}
HttpClient client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", String.Format("Bearer {0}", Authentication.AccessToken));
MultipartFormDataContent content = new MultipartFormDataContent();
byte[] fileBytes = null;
using (IRandomAccessStreamWithContentType stream = await file.OpenReadAsync())
{
fileBytes = new byte[stream.Size];
using (DataReader reader = new DataReader(stream))
{
await reader.LoadAsync((uint)stream.Size);
reader.ReadBytes(fileBytes);
}
}
var byteArrayContent = new ByteArrayContent(fileBytes);
content.Add(byteArrayContent, "file", file.Name);
HttpResponseMessage result = await client.PostAsync(
String.Format("https://www.strava.com/api/v3/uploads?data_type={0}&activity_type={1}",
format,
activityType.ToString().ToLower()),
content);
String json = await result.Content.ReadAsStringAsync();
return Unmarshaller<UploadStatus>.Unmarshal(json);
}
public async static Task<Byte[]> GetByteFromFileAsync(this IRandomAccessStream stream)
{
using (var dataReader = new DataReader(stream))
{
var bytes = new byte[stream.Size];
await dataReader.LoadAsync((uint)stream.Size);
dataReader.ReadBytes(bytes);
return bytes;
}
}
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[]> IRandomAccessStreamToByteArr(IRandomAccessStream irStream)
{
DataReader reader = new Windows.Storage.Streams.DataReader(irStream.GetInputStreamAt(0));
await reader.LoadAsync((uint)irStream.Size);
byte[] pixels = new byte[irStream.Size];
reader.ReadBytes(pixels);
return pixels;
}
public async Task<byte[]> GetPhotoBytesAsync(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 Task RenderThumbnailAsync(StorageFile thumb, int scaleWidht, int scaleHeight)
{
ImageStream inputStream = await composition.GetThumbnailAsync(TimeSpan.Zero, scaleWidht, scaleHeight, VideoFramePrecision.NearestFrame);
using (DataReader reader = new DataReader(inputStream.GetInputStreamAt(0)))
{
await reader.LoadAsync((uint)inputStream.Size);
byte[] buffer = new byte[(uint)inputStream.Size];
reader.ReadBytes(buffer);
await FileIO.WriteBytesAsync(thumb, buffer);
}
}
private async void UpdateButton_Click(object sender, RoutedEventArgs e)
{
MyThingObj data = new MyThingObj();
byte[] fileBytes = null;
if (file != null)
{
using (IRandomAccessStreamWithContentType stream = await file.OpenReadAsync())
{
fileBytes = new byte[stream.Size];
using (DataReader reader = new DataReader(stream))
{
await reader.LoadAsync((uint)stream.Size);
reader.ReadBytes(fileBytes);
}
}
}
else
{
data.image = existItemList[0].image;
}
data.rfid = rfid.Text;
data.name = itemName.Text;
data.image = fileBytes;
data.lastUpdatedAt = DateTime.Now;
data.createdAt = existItemList[0].createdAt;
data.type = type.Text;
data.status = "1";
data.location = existItemList[0].location;
data.id = int.Parse(id.Text);
HttpWebRequest Addrequest = (HttpWebRequest)WebRequest.Create("http://mythingapi.azurewebsites.net/api/MyThings/"+id.Text);
Addrequest.Method = "PUT";
Addrequest.ContentType = "application/json;charset=utf-8";
Addrequest.Accept = "application/json;charset=utf-8";
Addrequest.BeginGetRequestStream((ar) =>
{
System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding();
byte[] bytes = encoding.GetBytes(JsonConvert.SerializeObject(data));
Stream arStream = Addrequest.EndGetRequestStream(ar);
arStream.Write(bytes, 0, bytes.Length);
Addrequest.BeginGetResponse((arRes) =>
{
HttpWebResponse thingresponse = (HttpWebResponse)Addrequest.EndGetResponse(arRes);
}, Addrequest);
}, Addrequest);
}
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 static async Task<byte[]> ReadFromFile(IStorageFile file)
{
var stream = await file.OpenAsync(FileAccessMode.Read);
var reader = new DataReader(stream.GetInputStreamAt(0));
var streamSize = (uint) stream.Size;
await reader.LoadAsync(streamSize);
var buffer = new byte[streamSize];
reader.ReadBytes(buffer);
return buffer;
}
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);
}
private async Task SaveVideo(IRandomAccessStream videoStream)
{
StorageFile videoFile = await ApplicationData.Current.LocalFolder.CreateFileAsync("MyCam.mp4");
using (DataReader reader = new DataReader(videoStream.GetInputStreamAt(0)))
{
await reader.LoadAsync((uint)videoStream.Size);
byte[] data = new byte[(int)videoStream.Size];
reader.ReadBytes(data);
await FileIO.WriteBytesAsync(videoFile, data);
}
}
private async Task<uint> OpenFile(string fileName)
{
StorageFolder myStorageFolder = KnownFolders.DocumentsLibrary;
myFile = await myStorageFolder.GetFileAsync("ECHelper Files\\" + fileName+".ech");
readStream = await myFile.OpenAsync(FileAccessMode.Read);
fileReader = new DataReader(readStream);
count = await fileReader.LoadAsync((uint)readStream.Size);
data = new byte[count];
fileReader.ReadBytes(data);
return count;
}
public async static Task<byte[]> getBytes(Stream stream)
{
IInputStream inputStream = stream.AsInputStream();
DataReader dataReader = new DataReader(inputStream);
await dataReader.LoadAsync((uint)stream.Length);
byte[] buffer = new byte[(int)stream.Length];
dataReader.ReadBytes(buffer);
return buffer;
}
private async void PickAFileButton_Click(object sender, RoutedEventArgs e)
{
FileOpenPicker openPicker = new FileOpenPicker();
// openPicker.ViewMode = PickerViewMode.Thumbnail;
openPicker.SuggestedStartLocation = PickerLocationId.PicturesLibrary;
openPicker.FileTypeFilter.Add(".jpg");
openPicker.FileTypeFilter.Add(".jpeg");
openPicker.FileTypeFilter.Add(".png");
StorageFile file = await openPicker.PickSingleFileAsync();
Login.MasterPage.Loading(true, this);
// Ensure a file was selected
if (file != null)
{
bool islogin = WinAppLibrary.Utilities.SPDocument.IsLogin ? true : await (new WinAppLibrary.Utilities.SPDocument()).SignInSharepoint(Login.UserAccount.SPURL, Login.UserAccount.SPUser, Login.UserAccount.SPPassword);
if (islogin)
{
try
{
// Ensure the stream is disposed once the image is loaded
using (IRandomAccessStream fileStream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read))
{
var reader = new DataReader(fileStream.GetInputStreamAt(0));
var bytes = new byte[fileStream.Size];
await reader.LoadAsync((uint)fileStream.Size);
reader.ReadBytes(bytes);
var stream = new MemoryStream(bytes);
await (new WinAppLibrary.Utilities.SPDocument()).SaveJpegContent(Login.UserAccount.SPURL + "/" + WinAppLibrary.Utilities.SPCollectionName.Drawing + "/", "131016AssemblyIWP_test.jpg", stream);
// Set the image source to the selected bitmap
BitmapImage bitmapImage = new BitmapImage();
//bitmapImage.DecodePixelHeight = decodePixelHeight;
//bitmapImage.DecodePixelWidth = decodePixelWidth;
await bitmapImage.SetSourceAsync(fileStream);
Img3D.Source = bitmapImage;
}
}
catch (Exception ex)
{
}
}
else
WinAppLibrary.Utilities.Helper.SimpleMessage("Your account for sharepoint is not valid. Please login again.", "Caution!");
Login.MasterPage.Loading(false, this);
}
}
public async Task<byte[]> ToArrayAsync(StorageFile storageFile)
{
var stream = await storageFile.OpenReadAsync();
using (var dataReader = new DataReader(stream))
{
var bytes = new byte[stream.Size];
await dataReader.LoadAsync((uint)stream.Size);
dataReader.ReadBytes(bytes);
return bytes;
}
}
public static async Task<byte[]> ConvertImagetoByte(StorageFile image)
{
IRandomAccessStream fileStream = await image.OpenAsync(FileAccessMode.Read);
var reader = new DataReader(fileStream.GetInputStreamAt(0));
await reader.LoadAsync((uint)fileStream.Size);
var pixels = new byte[fileStream.Size];
reader.ReadBytes(pixels);
return pixels;
}
//public IAsyncOperation<string> CapturePicture()
//{
// return getStringHelper().AsAsyncOperation();
//}
//private async Task<string> getStringHelper()
//{
// var dialog = new CameraCaptureUI();
// var file = await dialog.CaptureFileAsync(CameraCaptureUIMode.Photo);
// // Do something useful w/ the file
// byte[] imageStream = await ToByteArrayAsync(file);
// string base64String = Convert.ToBase64String(imageStream);
// return base64String;
//}
private static async Task<byte[]> ToByteArrayAsync(StorageFile file)
{
using (IRandomAccessStream stream = await file.OpenReadAsync())
{
using (DataReader reader = new DataReader(stream.GetInputStreamAt(0)))
{
await reader.LoadAsync((uint)stream.Size);
byte[] Bytes = new byte[stream.Size];
reader.ReadBytes(Bytes);
return Bytes;
}
}
}
/// <summary>
/// Get a byte[] from the serial port.
/// </summary>
/// <returns>The byte[] that has been sent by the other application</returns>
protected byte[] GetBytes(DataReader dataReader)
{
//var d = dataReader.LoadAsync(1024);
var buffer = new byte[1024];
while (dataReader.UnconsumedBufferLength > 0)
{
dataReader.ReadBytes(buffer);
}
return buffer;
}
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();
}
}
//stream to base64
public static async Task<string> streamToString(IRandomAccessStream fileStream)
{
string Base64String = "";
var reader = new DataReader(fileStream.GetInputStreamAt(0));
await reader.LoadAsync((uint)fileStream.Size);
byte[] byteArray = new byte[fileStream.Size];
reader.ReadBytes(byteArray);
Base64String = Convert.ToBase64String(byteArray);
//string s = ByteToString(byteArray);
return Base64String;
}
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);
}
private static async Task<byte[]> ReadFile(StorageFile file)
{
byte[] fileBytes = null;
using (IRandomAccessStreamWithContentType stream = await file.OpenReadAsync())
{
fileBytes = new byte[stream.Size];
using (DataReader reader = new DataReader(stream))
{
await reader.LoadAsync((uint)stream.Size);
reader.ReadBytes(fileBytes);
}
}
return fileBytes;
}
public async Task<byte[]> ImageInitialize(IRandomAccessStream stream)
{
var size = stream.Size;
byte[] bytes = new byte[size];
var reader = new DataReader(stream.GetInputStreamAt(0));
await reader.LoadAsync((uint)size);
reader.ReadBytes(bytes);
return bytes;
}
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<byte[]> ReadFile(StorageFile file)
{
byte[] fileBytes;
using (var stream = await file.OpenReadAsync())
{
fileBytes = new byte[stream.Size];
using (var reader = new DataReader(stream))
{
await reader.LoadAsync((uint)stream.Size);
reader.ReadBytes(fileBytes);
}
}
return fileBytes;
}
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;
}
}
}
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);
}
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);
}
private void OnDataReadCompletion(uint bytesRead, Streams.DataReader reader)
{
if (reader == null)
{
return;
}
uint unreadLength = reader.UnconsumedBufferLength;
if (unreadLength == 0)
{
return;
}
byte[] buffer = new byte[unreadLength];
reader.ReadBytes(buffer);
StringBuilder stringBuffer = new StringBuilder();
stringBuffer.Append(Encoding.UTF8.GetString(buffer, 0, buffer.Length));
Debug.WriteLine("Configuration Brute: " + stringBuffer.ToString());
var packet = new ConfigurationPacket
{
Timestamp = DateTime.UtcNow.Ticks,
Data = buffer
};
if (UpdateConfiguration(packet))
{
if (_DroneClient.RequestedState == RequestedState.GetConfiguration)
{
_DroneClient.RequestedState = RequestedState.None;
}
ConfigurationViewModelHelper.UpdateConfigurationSections(_DroneClient.ConfigurationSectionsViewModel, _DroneClient.Configuration);
}
}
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();
}
}
