Add UWP Support

windows/RNViewShot/RNViewShotModule.cs

@@ -4,8 +4,6 @@ using ReactNative.UIManager;
 using System;
 using System.IO;
 using System.Collections.Generic;
-using Windows.ApplicationModel.Core;
-using Windows.UI.Core;
 
 namespace RNViewShot
 {
@@ -20,7 +18,7 @@ namespace RNViewShot
         /// <summary>
         /// Instantiates the <see cref="RNViewShotModule"/>.
         /// </summary>
-        public RNViewShotModule(ReactContext reactContext) : base(reactContext) 
+        public RNViewShotModule(ReactContext reactContext) : base(reactContext)
         {
             this._reactContext = reactContext;
         }
@@ -40,45 +38,20 @@ namespace RNViewShot
         public void takeSnapshot(int tag, JObject options, IPromise promise)
         {
             string format = options["format"] != null ? options.Value<string>("format") : "png";
-            //Bitmap.CompressFormat compressFormat =
-            //        format.equals("png")
-            //                ? Bitmap.CompressFormat.PNG
-            //                : format.equals("jpg") || format.equals("jpeg")
-            //                ? Bitmap.CompressFormat.JPEG
-            //                : format.equals("webm")
-            //                ? Bitmap.CompressFormat.WEBP
-            //                : null;
-            //if (compressFormat == null)
-            //{
-            //    promise.reject(ErrorUnableToSnapshot, "Unsupported image format: " + format + ". Try one of: png | jpg | jpeg");
-            //    return;
-            //}
             double quality = options["quality"] != null ? options.Value<double>("quality") : 1.0;
             int? width = options["width"] != null ? options.Value<int?>("width") : null;
             int? height = options["height"] != null ? options.Value<int?>("height") : null;
             string result = options["result"] != null ? options.Value<string>("result") : "file";
-            bool snapshotContentContainer = options["snapshotContentContainer"] != null ? options.Value<bool>("snapshotContentContainer") : false;
+            string path = options["path"] != null ? options.Value<string>("path") : null;
 
-            UIManagerModule uiManager = this._reactContext.GetNativeModule<UIManagerModule>();
-            uiManager.AddUIBlock(new ViewShot(tag));
-
-            //try
-            //{
-            //    string name = options["filename"] != null ? options.Value<string>("filename") : null;
-            //    //File tmpFile = "file" == result ? createTempFile(this._reactContext, format, name) : null;
-            //    UIManagerModule uiManager = this._reactContext.GetNativeModule<UIManagerModule>();
-            //    //uiManager.addUIBlock(new ViewShot(tag, format, compressFormat, quality, width, height, tmpFile, result, snapshotContentContainer, promise));
-            //}
-            //catch (Exception e)
-            //{
-            //    promise.reject(ErrorUnableToSnapshot, "Failed to snapshot view tag " + tag);
-            //}
+            if (format != "png" && format != "jpg" && format != "jpeg")
+            {
+                promise.Reject(ViewShot.ErrorUnableToSnapshot, "Unsupported image format: " + format + ". Try one of: png | jpg | jpeg");
+                return;
+            }
 
-            //Bitmap bitmap = new Bitmap(Screen.PrimaryScreen.Bounds.Width, Screen.PrimaryScreen.Bounds.Height);
-            //Graphics graphics = Graphics.FromImage(bitmap as Image);
-            //graphics.CopyFromScreen(0, 0, 0, 0, bitmap.Size);
-            //bitmap.Save("c:\\screenshot.jpeg", ImageFormat.Jpeg);
-            promise.Resolve("Format: " + format + " Quality: " + quality);
+            UIManagerModule uiManager = this._reactContext.GetNativeModule<UIManagerModule>();
+            uiManager.AddUIBlock(new ViewShot(tag, format, quality, width, height, path, result, promise));
         }
     }
 }

windows/RNViewShot/ViewShot.cs

@@ -1,26 +1,178 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+using ReactNative.Bridge;
 using ReactNative.UIManager;
+using System;
+using System.IO;
+using System.Runtime.InteropServices.WindowsRuntime;
+using System.Threading.Tasks;
+using Windows.Graphics.Display;
+using Windows.Graphics.Imaging;
+using Windows.Storage;
+using Windows.Storage.Streams;
+using Windows.UI.Xaml;
+using Windows.UI.Xaml.Media;
+using Windows.UI.Xaml.Media.Imaging;
 
 namespace RNViewShot
 {
     public class ViewShot : IUIBlock
     {
+        public const string ErrorUnableToSnapshot = "E_UNABLE_TO_SNAPSHOT";
         private int tag;
+        private string extension;
+        private double quality;
+        private int? width;
+        private int? height;
+        private string path;
+        private string result;
+        private IPromise promise;
 
-        public ViewShot(int tag)
+        public ViewShot(
+            int tag,
+            string extension,
+            double quality,
+            int? width,
+            int? height,
+            string path,
+            string result,
+            IPromise promise)
         {
             this.tag = tag;
+            this.extension = extension;
+            this.quality = quality;
+            this.width = width;
+            this.height = height;
+            this.path = path;
+            this.result = result;
+            this.promise = promise;
         }
 
-        public void Execute(NativeViewHierarchyManager nvhm)
+        public async void Execute(NativeViewHierarchyManager nvhm)
         {
-            var view = nvhm.ResolveView(this.tag);
+            var view = nvhm.ResolveView(tag) as FrameworkElement;
+            if (view == null)
+            {
+                promise.Reject(ErrorUnableToSnapshot, "No view found with reactTag: " + tag);
+                return;
+            }
+
+            try
+            {
+                if ("file" == result)
+                {
+                    using (InMemoryRandomAccessStream ras = new InMemoryRandomAccessStream())
+                    {
+                        await CaptureView(view, ras);
+                        StorageFile file = await GetStorageFile();
+                        using (var fileStream = await file.OpenAsync(FileAccessMode.ReadWrite))
+                        {
+                            await RandomAccessStream.CopyAndCloseAsync(ras.GetInputStreamAt(0), fileStream.GetOutputStreamAt(0));
+                            promise.Resolve(file.Path);
+                        }
+                    }
+                }
+                else if ("base64" == result)
+                {
+                    using (InMemoryRandomAccessStream ras = new InMemoryRandomAccessStream())
+                    {
+                        await CaptureView(view, ras);
+                        byte[] imageBytes = new byte[ras.Size];
+                        await ras.AsStream().ReadAsync(imageBytes, 0, imageBytes.Length);
+                        string data = Convert.ToBase64String(imageBytes);
+                        promise.Resolve(data);
+                    }
+                }
+                else if ("data-uri" == result)
+                {
+                    using (InMemoryRandomAccessStream ras = new InMemoryRandomAccessStream())
+                    {
+                        await CaptureView(view, ras);
+                        byte[] imageBytes = new byte[ras.Size];
+                        await ras.AsStream().ReadAsync(imageBytes, 0, imageBytes.Length);
+                        string data = Convert.ToBase64String(imageBytes);
+                        data = "data:image/" + extension + ";base64," + data;
+                        promise.Resolve(data);
+                    }
+                }
+                else
+                {
+                    promise.Reject(ErrorUnableToSnapshot, "Unsupported result: " + result + ". Try one of: file | base64 | data-uri");
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine(ex.ToString());
+                promise.Reject(ErrorUnableToSnapshot, "Failed to capture view snapshot");
+            }
+        }
+
+        private async Task<BitmapEncoder> CaptureView(FrameworkElement view, IRandomAccessStream stream)
+        {
+            int w = (int)view.ActualWidth;
+            int h = (int)view.ActualHeight;
+
+            if (w <= 0 || h <= 0)
+            {
+                throw new InvalidOperationException("Impossible to snapshot the view: view is invalid");
+            }
+
+            RenderTargetBitmap targetBitmap = new RenderTargetBitmap();
+            await targetBitmap.RenderAsync(view, w, h);
+
+            BitmapEncoder encoder;
+            if (extension != "png")
+            {
+                var propertySet = new BitmapPropertySet();
+                var qualityValue = new BitmapTypedValue(quality, Windows.Foundation.PropertyType.Single);
+                propertySet.Add("ImageQuality", qualityValue);
+                encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, stream, propertySet);
+            }
+            else
+            {
+                encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, stream);
+            }
 
-            string depObj = view.ToString();
+            var displayInformation = DisplayInformation.GetForCurrentView();
+            var pixelBuffer = await targetBitmap.GetPixelsAsync();
+
+            encoder.SetPixelData(
+                BitmapPixelFormat.Bgra8,
+                BitmapAlphaMode.Ignore,
+                (uint)targetBitmap.PixelWidth,
+                (uint)targetBitmap.PixelHeight,
+                displayInformation.LogicalDpi,
+                displayInformation.LogicalDpi,
+                pixelBuffer.ToArray());                
+
+
+            if (width != null && height != null && (width != w || height != h))
+            {
+                encoder.BitmapTransform.ScaledWidth = (uint)width;
+                encoder.BitmapTransform.ScaledWidth = (uint)height;
+            }
+
+            if (encoder == null)
+            {
+                throw new InvalidOperationException("Impossible to snapshot the view");
+            }
+
+            await encoder.FlushAsync();
+
+            return encoder;            
+        }
+
+        private async Task<StorageFile> GetStorageFile()
+        {
+            StorageFolder storageFolder = ApplicationData.Current.LocalFolder;
+            if (string.IsNullOrEmpty(path))
+            {
+                string fileName = Guid.NewGuid().ToString();
+                fileName = Path.ChangeExtension(fileName, extension);
+                return await storageFolder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting);
+            }
+            else
+            {
+                return await storageFolder.CreateFileAsync(path, CreationCollisionOption.ReplaceExisting);
+            }
         }
     }
 }