protected async System.Threading.Tasks.Task TakeSnapshotAsync <T>(T list, string fieldName) where T : ObservableCollection <ImageCapture> { try { CameraCaptureUI ccui = new CameraCaptureUI(); var storagefile = await ccui.CaptureFileAsync(CameraCaptureUIMode.Photo); if (storagefile != null) { var ms = await RenderDataStampOnSnap.RenderStaticTextToBitmap(storagefile); var msrandom = new MemoryRandomAccessStream(ms); Byte[] bytes = new Byte[ms.Length]; await ms.ReadAsync(bytes, 0, (int)ms.Length); // StorageFile file = await KnownFolders.PicturesLibrary.CreateFileAsync("Image.png", Windows.Storage.CreationCollisionOption.GenerateUniqueName); StorageFile file = await ApplicationData.Current.TemporaryFolder.CreateFileAsync(DateTime.Now.Ticks.ToString() + storagefile.Name, CreationCollisionOption.ReplaceExisting); using (var strm = await file.OpenStreamForWriteAsync()) { await strm.WriteAsync(bytes, 0, bytes.Length); strm.Flush(); } var ic = new ImageCapture { ImagePath = file.Path, ImageBinary = Convert.ToBase64String(bytes), CaseServiceRecId = ((BaseModel)this.Model).VehicleInsRecID, FileName = string.Format("{0}_{1}", fieldName, list.Count + 1) }; list.Add(ic); var imageTable = await SqliteHelper.Storage.LoadTableAsync <ImageCapture>(); var dbIC = imageTable.SingleOrDefault(x => x.CaseServiceRecId == ic.CaseServiceRecId && x.FileName == string.Format("{0}_{1}", fieldName, list.Count + 1)); if (dbIC == null) { await SqliteHelper.Storage.InsertSingleRecordAsync <ImageCapture>(ic); } else { dbIC.ImagePath = ic.ImagePath; dbIC.ImageBinary = ic.ImageBinary; await SqliteHelper.Storage.UpdateSingleRecordAsync <ImageCapture>(dbIC); } } } catch (Exception) { throw; } }
public static async Task <BitmapImage> ConvertByteToImage(byte[] imageBytes) { if (imageBytes != null) { MemoryStream stream = new MemoryStream(imageBytes); var randomAccessStream = new MemoryRandomAccessStream(stream); BitmapImage bitmapImage = new BitmapImage(); await bitmapImage.SetSourceAsync(randomAccessStream); return(bitmapImage); } else { return(Item.DefaultIcon); } }
public ImageMarkupPageViewModel() { this.Snapshots = new ObservableCollection <ImageCapture>(); DoneCommand = DelegateCommand.FromAsyncHandler(async() => { try { var caseNumber = ApplicationData.Current.LocalSettings.Values["CaseNumber"].ToString(); foreach (var item in this.Snapshots) { var image = await StorageFile.GetFileFromPathAsync(item.ImagePath); var curMarkupImageFile = await ApplicationData.Current.RoamingFolder.TryGetItemAsync("markupimage_" + caseNumber + this.Snapshots.IndexOf(item)) as StorageFile; if (image != null && curMarkupImageFile != null) { var ms = await RenderDataStampOnSnap.InterpolateImageMarkup(image, curMarkupImageFile); var msrandom = new MemoryRandomAccessStream(ms); Byte[] bytes = new Byte[ms.Length]; await ms.ReadAsync(bytes, 0, (int)ms.Length); // StorageFile file = await KnownFolders.PicturesLibrary.CreateFileAsync("Image.png", Windows.Storage.CreationCollisionOption.GenerateUniqueName); StorageFile file = await ApplicationData.Current.TemporaryFolder.CreateFileAsync(DateTime.Now.Ticks.ToString() + curMarkupImageFile.Name, CreationCollisionOption.ReplaceExisting); using (var strm = await file.OpenStreamForWriteAsync()) { await strm.WriteAsync(bytes, 0, bytes.Length); strm.Flush(); } await UpdateImageAsync(new ImageCapture { CaseServiceRecId = Convert.ToInt64(ApplicationData.Current.LocalSettings.Values["VehicleInsRecId"]), ImageBinary = Convert.ToBase64String(bytes), ImagePath = file.Path, FileName = item.FileName + "Marked" }); } } } catch (Exception) { throw; } }); }
async public virtual System.Threading.Tasks.Task TakePictureAsync(ImageCapture param, string fieldName) { try { CameraCaptureUI cam = new CameraCaptureUI(); var storagefile = await cam.CaptureFileAsync(CameraCaptureUIMode.Photo); if (storagefile != null) { using (MemoryStream ms = await RenderDataStampOnSnap.RenderStaticTextToBitmap(storagefile)) { using (var msrandom = new MemoryRandomAccessStream(ms)) { Byte[] bytes = new Byte[ms.Length]; await ms.ReadAsync(bytes, 0, (int)ms.Length); // StorageFile file = await KnownFolders.PicturesLibrary.CreateFileAsync("Image.png", Windows.Storage.CreationCollisionOption.GenerateUniqueName); StorageFile file = await ApplicationData.Current.TemporaryFolder.CreateFileAsync(DateTime.Now.Ticks.ToString() + storagefile.Name, CreationCollisionOption.ReplaceExisting); using (var strm = await file.OpenStreamForWriteAsync()) { await strm.WriteAsync(bytes, 0, bytes.Length); strm.Flush(); } param.ImagePath = file.Path; param.ImageBinary = Convert.ToBase64String(bytes); param.CaseServiceRecId = ((BaseModel)this.Model).VehicleInsRecID; param.FileName = fieldName; await UpdateImageAsync(param); } } } } catch (Exception) { throw; } }
public static async Task Render(this WriteableBitmap wb, FrameworkElement fe) { var ms = RenderToStream(fe); var msrandom = new MemoryRandomAccessStream(ms); await wb.SetSourceAsync(msrandom); }
private async void ReadAndSort(Windows.UI.Core.CoreDispatcher Dispatcher) { //Identify that it is ID3 if (GetString(3).Equals("ID3")) { //Unwanted space between "ID3" tag and frame name for (int i = 0; i < 7; i++) data.ReadByte(); //Loop through the rest of the file, looking directly for specific frame names, reading their properties, and scrapping the rest. while (data.UnconsumedBufferLength > 3) { //Use our Frame Name constant (4) to seek the identity of the tag (if it's one we care about). //Otherwise, we loop through the bytes we don't care about. String identity = GetString(ID3FrameNameLength); identity = new ID3FrameDictionary().GetIdentity(identity); //ID3 -- assuming no one took liberties extending this during encoding -- reserves 4 bytes following //the frame name to tell decoders byte[] byteCounter = new byte[4] { 0, 0, 0, 0 }; for (int i = 0; i < 4; i++) { byteCounter[i] = data.ReadByte(); } //Since we're dealing with encoding and dealing primarily with Hex values, all values should be unsigned. //I don't actually know is there is padding between the frame name and the value count. If there is, this following operation doesn't hurt anything //and is set in case the 4 bytes following are all possibly used. Accounted for by 64-bit integer. UInt64 intCounter = (ulong)((byteCounter[0] << (8 * 3)) + (byteCounter[1] << (8 * 2)) + (byteCounter[2] << (8 * 1)) + (byteCounter[3] << (8 * 0))); //Padding of 00 00 between the 64-bit value count and the frame value. Read through the padding. data.ReadByte(); data.ReadByte(); //Check if frame name is one we care about. (Album, Artist, Title, Cover) if (identity != null) { //APIC (Album Picture) is the only frame that we could care about that can't be interpreted as a string. if (identity.Equals("Image")) { //We get the byte array, but WinRT/Windows 8 makes the process of converting a byte array into a Random Access Stream difficult. //A custom library was made for this that converts a Stream (MemoryStream) into IRandomAccessStream, so we can create a bitmap image. MemoryStream ms = new MemoryStream(GetImage(intCounter)); MemoryRandomAccessStream randomAccessStream = new MemoryRandomAccessStream(ms); //Create new BitmapImage inside this thread, as it isn't possible to know that this variable will come out of the UI thread operation. BitmapImage bt = null; //Grab UI Thread to create a new BitmapImage instance, and to take care of operations involving the UI. await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, async () => { bt = new BitmapImage(); try { await bt.SetSourceAsync(randomAccessStream); cover.Source = bt; cover.MaxWidth = bt.PixelWidth; cover.MaxHeight = bt.PixelHeight; } catch (Exception e) { //In case setting the source throws an exception due to corrupt extraction. } }); } else { //Convert the bytes following the frame value count into a readable string. It skips over characters that aren't used in the English Language. String idValue = GetString(intCounter); fileData[identity] = idValue; Debug.WriteLine(idValue); } } else { //Read over the bytes we don't care about. If there is some sort of wrong interpretation of the intCounter value, the loop is broken //so there is no attempt of reading beyond the file's length. if (intCounter > data.UnconsumedBufferLength) break; for (uint i = 0; i < intCounter; i++) data.ReadByte(); } } } //We don't need this anymore. Let's dispose of it. data.Dispose(); }