diff --git a/plugin.xml b/plugin.xml
index 745e8122..fda49b1c 100755
--- a/plugin.xml
+++ b/plugin.xml
@@ -65,9 +65,6 @@
     <js-module src="src/windows/lib/qrScanner.js" name="qrScanner">
       <runs/>
     </js-module>
-    <js-module src="src/windows/lib/videoCapture.js" name="videoCapture">
-      <runs/>
-    </js-module>
     <js-module src="src/windows/lib/preview.js" name="preview">
       <runs/>
     </js-module>
diff --git a/src/windows/QRReader/CameraRotationHelper.cs b/src/windows/QRReader/CameraRotationHelper.cs
new file mode 100644
index 00000000..ff1ce1f3
--- /dev/null
+++ b/src/windows/QRReader/CameraRotationHelper.cs
@@ -0,0 +1,263 @@
+using System;
+using Windows.Devices.Enumeration;
+using Windows.Devices.Sensors;
+using Windows.Graphics.Display;
+using Windows.Media.Capture;
+using Windows.Storage.FileProperties;
+
+namespace QRReader
+{
+    class CameraRotationHelper
+    {
+        private EnclosureLocation _cameraEnclosureLocation;
+        private DisplayInformation _displayInformation = DisplayInformation.GetForCurrentView();
+        private SimpleOrientationSensor _orientationSensor = SimpleOrientationSensor.GetDefault();
+
+        /// <summary>
+        /// Occurs each time the simple orientation sensor reports a new sensor reading or when the display's current or native orientation changes
+        /// </summary>
+        public event EventHandler<bool> OrientationChanged;
+
+        public CameraRotationHelper(EnclosureLocation cameraEnclosureLocation)
+        {
+            _cameraEnclosureLocation = cameraEnclosureLocation;
+            if (!IsEnclosureLocationExternal(_cameraEnclosureLocation) && _orientationSensor != null)
+            {
+                _orientationSensor.OrientationChanged += SimpleOrientationSensor_OrientationChanged;
+            }
+            _displayInformation.OrientationChanged += DisplayInformation_OrientationChanged;
+        }
+
+        /// <summary>
+        /// Detects whether or not the camera is external to the device
+        /// </summary>
+        public static bool IsEnclosureLocationExternal(EnclosureLocation enclosureLocation)
+        {
+            return (enclosureLocation == null || enclosureLocation.Panel == Windows.Devices.Enumeration.Panel.Unknown);
+        }
+
+        /// <summary>
+        /// Gets the rotation to rotate ui elements
+        /// </summary>
+        public SimpleOrientation GetUIOrientation()
+        {
+            if (IsEnclosureLocationExternal(_cameraEnclosureLocation))
+            {
+                // Cameras that are not attached to the device do not rotate along with it, so apply no rotation
+                return SimpleOrientation.NotRotated;
+            }
+
+            // Return the difference between the orientation of the device and the orientation of the app display
+            var deviceOrientation = _orientationSensor?.GetCurrentOrientation() ?? SimpleOrientation.NotRotated;
+            var displayOrientation = ConvertDisplayOrientationToSimpleOrientation(_displayInformation.CurrentOrientation);
+            return SubtractOrientations(displayOrientation, deviceOrientation);
+        }
+
+        /// <summary>
+        /// Gets the rotation of the camera to rotate pictures/videos when saving to file
+        /// </summary>
+        public SimpleOrientation GetCameraCaptureOrientation()
+        {
+            if (IsEnclosureLocationExternal(_cameraEnclosureLocation))
+            {
+                // Cameras that are not attached to the device do not rotate along with it, so apply no rotation
+                return SimpleOrientation.NotRotated;
+            }
+
+            // Get the device orientation offset by the camera hardware offset
+            var deviceOrientation = _orientationSensor?.GetCurrentOrientation() ?? SimpleOrientation.NotRotated;
+            var result = SubtractOrientations(deviceOrientation, GetCameraOrientationRelativeToNativeOrientation());
+
+            // If the preview is being mirrored for a front-facing camera, then the rotation should be inverted
+            if (ShouldMirrorPreview())
+            {
+                result = MirrorOrientation(result);
+            }
+            return result;
+        }
+
+        /// <summary>
+        /// Gets the rotation of the camera to display the camera preview
+        /// </summary>
+        public SimpleOrientation GetCameraPreviewOrientation()
+        {
+            if (IsEnclosureLocationExternal(_cameraEnclosureLocation))
+            {
+                // Cameras that are not attached to the device do not rotate along with it, so apply no rotation
+                return SimpleOrientation.NotRotated;
+            }
+
+            // Get the app display rotation offset by the camera hardware offset
+            var result = ConvertDisplayOrientationToSimpleOrientation(_displayInformation.CurrentOrientation);
+            result = SubtractOrientations(result, GetCameraOrientationRelativeToNativeOrientation());
+
+            // If the preview is being mirrored for a front-facing camera, then the rotation should be inverted
+            if (ShouldMirrorPreview())
+            {
+                result = MirrorOrientation(result);
+            }
+            return result;
+        }
+
+        public static PhotoOrientation ConvertSimpleOrientationToPhotoOrientation(SimpleOrientation orientation)
+        {
+            switch (orientation)
+            {
+                case SimpleOrientation.Rotated90DegreesCounterclockwise:
+                    return PhotoOrientation.Rotate90;
+                case SimpleOrientation.Rotated180DegreesCounterclockwise:
+                    return PhotoOrientation.Rotate180;
+                case SimpleOrientation.Rotated270DegreesCounterclockwise:
+                    return PhotoOrientation.Rotate270;
+                case SimpleOrientation.NotRotated:
+                default:
+                    return PhotoOrientation.Normal;
+            }
+        }
+
+        public static int ConvertSimpleOrientationToClockwiseDegrees(SimpleOrientation orientation)
+        {
+            switch (orientation)
+            {
+                case SimpleOrientation.Rotated90DegreesCounterclockwise:
+                    return 270;
+                case SimpleOrientation.Rotated180DegreesCounterclockwise:
+                    return 180;
+                case SimpleOrientation.Rotated270DegreesCounterclockwise:
+                    return 90;
+                case SimpleOrientation.NotRotated:
+                default:
+                    return 0;
+            }
+        }
+
+        private SimpleOrientation ConvertDisplayOrientationToSimpleOrientation(DisplayOrientations orientation)
+        {
+            SimpleOrientation result;
+            switch (orientation)
+            {
+                case DisplayOrientations.Landscape:
+                    result = SimpleOrientation.NotRotated;
+                    break;
+                case DisplayOrientations.PortraitFlipped:
+                    result = SimpleOrientation.Rotated90DegreesCounterclockwise;
+                    break;
+                case DisplayOrientations.LandscapeFlipped:
+                    result = SimpleOrientation.Rotated180DegreesCounterclockwise;
+                    break;
+                case DisplayOrientations.Portrait:
+                default:
+                    result = SimpleOrientation.Rotated270DegreesCounterclockwise;
+                    break;
+            }
+
+            // Above assumes landscape; offset is needed if native orientation is portrait
+            if (_displayInformation.NativeOrientation == DisplayOrientations.Portrait)
+            {
+                result = AddOrientations(result, SimpleOrientation.Rotated90DegreesCounterclockwise);
+            }
+
+            return result;
+        }
+
+        private static SimpleOrientation MirrorOrientation(SimpleOrientation orientation)
+        {
+            // This only affects the 90 and 270 degree cases, because rotating 0 and 180 degrees is the same clockwise and counter-clockwise
+            switch (orientation)
+            {
+                case SimpleOrientation.Rotated90DegreesCounterclockwise:
+                    return SimpleOrientation.Rotated270DegreesCounterclockwise;
+                case SimpleOrientation.Rotated270DegreesCounterclockwise:
+                    return SimpleOrientation.Rotated90DegreesCounterclockwise;
+            }
+            return orientation;
+        }
+
+        private static SimpleOrientation AddOrientations(SimpleOrientation a, SimpleOrientation b)
+        {
+            var aRot = ConvertSimpleOrientationToClockwiseDegrees(a);
+            var bRot = ConvertSimpleOrientationToClockwiseDegrees(b);
+            var result = (aRot + bRot) % 360;
+            return ConvertClockwiseDegreesToSimpleOrientation(result);
+        }
+
+        private static SimpleOrientation SubtractOrientations(SimpleOrientation a, SimpleOrientation b)
+        {
+            var aRot = ConvertSimpleOrientationToClockwiseDegrees(a);
+            var bRot = ConvertSimpleOrientationToClockwiseDegrees(b);
+            // Add 360 to ensure the modulus operator does not operate on a negative
+            var result = (360 + (aRot - bRot)) % 360;
+            return ConvertClockwiseDegreesToSimpleOrientation(result);
+        }
+
+        public static VideoRotation ConvertSimpleOrientationToVideoRotation(SimpleOrientation orientation)
+        {
+            switch (orientation)
+            {
+                case SimpleOrientation.Rotated90DegreesCounterclockwise:
+                    return VideoRotation.Clockwise270Degrees;
+                case SimpleOrientation.Rotated180DegreesCounterclockwise:
+                    return VideoRotation.Clockwise180Degrees;
+                case SimpleOrientation.Rotated270DegreesCounterclockwise:
+                    return VideoRotation.Clockwise90Degrees;
+                case SimpleOrientation.NotRotated:
+                default:
+                    return VideoRotation.None;
+            }
+        }
+
+        private static SimpleOrientation ConvertClockwiseDegreesToSimpleOrientation(int orientation)
+        {
+            switch (orientation)
+            {
+                case 270:
+                    return SimpleOrientation.Rotated90DegreesCounterclockwise;
+                case 180:
+                    return SimpleOrientation.Rotated180DegreesCounterclockwise;
+                case 90:
+                    return SimpleOrientation.Rotated270DegreesCounterclockwise;
+                case 0:
+                default:
+                    return SimpleOrientation.NotRotated;
+            }
+        }
+
+        private void SimpleOrientationSensor_OrientationChanged(SimpleOrientationSensor sender, SimpleOrientationSensorOrientationChangedEventArgs args)
+        {
+            if (args.Orientation != SimpleOrientation.Faceup && args.Orientation != SimpleOrientation.Facedown)
+            {
+                // Only raise the OrientationChanged event if the device is not parallel to the ground. This allows users to take pictures of documents (FaceUp)
+                // or the ceiling (FaceDown) in portrait or landscape, by first holding the device in the desired orientation, and then pointing the camera
+                // either up or down, at the desired subject.
+                //Note: This assumes that the camera is either facing the same way as the screen, or the opposite way. For devices with cameras mounted
+                //      on other panels, this logic should be adjusted.
+                OrientationChanged?.Invoke(this, false);
+            }
+        }
+
+        private void DisplayInformation_OrientationChanged(DisplayInformation sender, object args)
+        {
+            OrientationChanged?.Invoke(this, true);
+        }
+
+        private bool ShouldMirrorPreview()
+        {
+            // It is recommended that applications mirror the preview for front-facing cameras, as it gives users a more natural experience, since it behaves more like a mirror
+            return (_cameraEnclosureLocation.Panel == Windows.Devices.Enumeration.Panel.Front);
+        }
+
+        private SimpleOrientation GetCameraOrientationRelativeToNativeOrientation()
+        {
+            // Get the rotation angle of the camera enclosure as it is mounted in the device hardware
+            var enclosureAngle = ConvertClockwiseDegreesToSimpleOrientation((int)_cameraEnclosureLocation.RotationAngleInDegreesClockwise);
+
+            // Account for the fact that, on portrait-first devices, the built in camera sensor is read at a 90 degree offset to the native orientation
+            if (_displayInformation.NativeOrientation == DisplayOrientations.Portrait && !IsEnclosureLocationExternal(_cameraEnclosureLocation))
+            {
+                enclosureAngle = AddOrientations(SimpleOrientation.Rotated90DegreesCounterclockwise, enclosureAngle);
+            }
+
+            return enclosureAngle;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/windows/QRReader/QRReader.csproj b/src/windows/QRReader/QRReader.csproj
index b4db9bd7..c2b225b2 100644
--- a/src/windows/QRReader/QRReader.csproj
+++ b/src/windows/QRReader/QRReader.csproj
@@ -4,7 +4,7 @@
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectGuid>{2928CF9F-4255-4D8A-A7C3-70324CC137A4}</ProjectGuid>
+    <ProjectGuid>{DF132792-0542-4936-914D-4C25D779CAC8}</ProjectGuid>
     <OutputType>winmdobj</OutputType>
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>QRReader</RootNamespace>
@@ -12,7 +12,7 @@
     <DefaultLanguage>en-US</DefaultLanguage>
     <TargetPlatformIdentifier>UAP</TargetPlatformIdentifier>
     <TargetPlatformVersion>10.0.14393.0</TargetPlatformVersion>
-    <TargetPlatformMinVersion>10.0.10586.0</TargetPlatformMinVersion>
+    <TargetPlatformMinVersion>10.0.14393.0</TargetPlatformMinVersion>
     <MinimumVisualStudioVersion>14</MinimumVisualStudioVersion>
     <FileAlignment>512</FileAlignment>
     <ProjectTypeGuids>{A5A43C5B-DE2A-4C0C-9213-0A381AF9435A};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
@@ -27,7 +27,6 @@
     <DefineConstants>DEBUG;TRACE;NETFX_CORE;WINDOWS_UWP</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <PlatformTarget>AnyCPU</PlatformTarget>
@@ -109,8 +108,10 @@
     <None Include="project.json" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="Reader.cs" />
+    <Compile Include="CameraRotationHelper.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Reader.cs" />
+    <Compile Include="VideoCapture.cs" />
   </ItemGroup>
   <ItemGroup>
     <Reference Include="ZXing">
@@ -120,9 +121,6 @@
   <PropertyGroup Condition=" '$(VisualStudioVersion)' == '' or '$(VisualStudioVersion)' &lt; '14.0' ">
     <VisualStudioVersion>14.0</VisualStudioVersion>
   </PropertyGroup>
-  <PropertyGroup>
-    <StartupObject />
-  </PropertyGroup>
   <Import Project="$(MSBuildExtensionsPath)\Microsoft\WindowsXaml\v$(VisualStudioVersion)\Microsoft.Windows.UI.Xaml.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/src/windows/QRReader/QRReader.csproj.user b/src/windows/QRReader/QRReader.csproj.user
new file mode 100644
index 00000000..ca1d04b0
--- /dev/null
+++ b/src/windows/QRReader/QRReader.csproj.user
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <ProjectView>ProjectFiles</ProjectView>
+  </PropertyGroup>
+</Project>
\ No newline at end of file
diff --git a/src/windows/QRReader/VideoCapture.cs b/src/windows/QRReader/VideoCapture.cs
new file mode 100644
index 00000000..075eb4dd
--- /dev/null
+++ b/src/windows/QRReader/VideoCapture.cs
@@ -0,0 +1,187 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Windows.Devices.Enumeration;
+using Windows.Foundation;
+using Windows.Media.Capture;
+using Windows.Media.Devices;
+using Windows.UI.Core;
+
+namespace QRReader
+{
+    public struct CameraSet
+    {
+        public string Back;
+        public string Front;
+    }
+
+    public sealed class VideoCapture
+    {
+        public static IAsyncOperation<CameraSet> GetCamerasAsync()
+        {
+            return GetCameras().AsAsyncOperation();
+        }
+
+        private static async Task<CameraSet> GetCameras()
+        {
+            var cameras = await DeviceInformation.FindAllAsync(DeviceClass.VideoCapture);
+
+            if (cameras.Count == 0)
+            {
+                throw new Exception("No cameras found");
+            }
+
+            var backCamera = cameras.FirstOrDefault((camera) => camera.IsEnabled && camera.EnclosureLocation.Panel == Panel.Back);
+            var frontCamera = cameras.FirstOrDefault((camera) => camera.IsEnabled && camera.EnclosureLocation.Panel == Panel.Front);
+            
+            return new CameraSet
+            {
+                Back = backCamera?.Id ?? "",
+                Front = frontCamera?.Id ?? ""
+            };
+        }
+
+        public static IAsyncOperation<VideoCapture> CreateAsync(string cameraId)
+        {
+            return Create(cameraId).AsAsyncOperation();
+        }
+
+        private static async Task<VideoCapture> Create(string cameraId)
+        {
+            var captureSettings = new MediaCaptureInitializationSettings()
+            {
+                VideoDeviceId = cameraId,
+                StreamingCaptureMode = StreamingCaptureMode.Video
+            };
+
+            var mediaCapture = new MediaCapture();
+            await mediaCapture.InitializeAsync(captureSettings);
+            var videoCapture = new VideoCapture(mediaCapture);
+            await videoCapture.WatchForOrientationChange(mediaCapture);
+            return videoCapture;
+        }
+
+
+        public MediaCapture Capture { get; private set; }
+        public bool CanEnableLight { get; private set; }
+        public bool CanFocus { get; private set; }
+        private CoreDispatcher mainDispatcher = CoreWindow.GetForCurrentThread().Dispatcher;
+
+        private VideoCapture(MediaCapture capture)
+        {
+            var cameraController = capture.VideoDeviceController;
+
+            Capture = capture;
+            CanEnableLight = cameraController.TorchControl.Supported;
+            CanFocus = cameraController.FocusControl.Supported;
+
+            if (CanFocus && cameraController.FocusControl.SupportedFocusModes.Count > 0)
+            {
+                var focusConfig = new FocusSettings();
+                focusConfig.AutoFocusRange = AutoFocusRange.Normal;
+                focusConfig.DisableDriverFallback = false;
+                if (cameraController.FocusControl.SupportedFocusModes.Contains(FocusMode.Continuous))
+                {
+                    focusConfig.Mode = FocusMode.Continuous;
+                }
+                else if (cameraController.FocusControl.SupportedFocusModes.Contains(FocusMode.Auto))
+                {
+                    focusConfig.Mode = FocusMode.Auto;
+                }
+            }
+        }
+        
+        private async Task WatchForOrientationChange(MediaCapture capture)
+        {
+            var camera = await DeviceInformation.CreateFromIdAsync(capture.MediaCaptureSettings.VideoDeviceId);
+            var cameraRotationHelper = new CameraRotationHelper(camera.EnclosureLocation);
+            OrientationChanged(cameraRotationHelper);
+            cameraRotationHelper.OrientationChanged += CameraRotationHelper_OrientationChanged;
+        }
+
+        private async void CameraRotationHelper_OrientationChanged(object sender, bool e)
+        {
+            var helper = sender as CameraRotationHelper;
+            await mainDispatcher.RunAsync(CoreDispatcherPriority.Normal, () => OrientationChanged(helper));
+        }
+
+        private void OrientationChanged(CameraRotationHelper cameraRotationHelper)
+        {
+            var previewOrientation = cameraRotationHelper.GetCameraPreviewOrientation();
+            var videoRotation = CameraRotationHelper.ConvertSimpleOrientationToVideoRotation(previewOrientation);
+            Capture.SetPreviewRotation(videoRotation);
+        }
+
+        public void EnableLight()
+        {
+
+            if (!CanEnableLight)
+            {
+                return;
+            }
+
+            Capture.VideoDeviceController.TorchControl.Enabled = true;
+            if (Capture.VideoDeviceController.TorchControl.PowerSupported)
+            {
+                Capture.VideoDeviceController.TorchControl.PowerPercent = 90;
+            }
+        }
+
+        public void DisableLight()
+        {
+            if (!CanEnableLight)
+            {
+                return;
+            }
+            
+            if (Capture.VideoDeviceController.TorchControl.Enabled)
+            {
+                Capture.VideoDeviceController.TorchControl.Enabled = false;
+            }
+        }
+
+        public void Focus()
+        {
+            const int INITIAL_FOCUS_DELAY = 200;
+            const int OPERATION_IS_IN_PROGRESS = -2147024567;
+
+            if (CanFocus)
+            {
+                var focusControl = Capture.VideoDeviceController.FocusControl;
+                if (focusControl.FocusState != MediaCaptureFocusState.Searching)
+                {
+                    Task.Run(async () =>
+                    {
+                        await Task.Delay(INITIAL_FOCUS_DELAY);
+                        try
+                        {
+                            await focusControl.FocusAsync();
+                        }
+                        catch (Exception exc)
+                        {
+                            if(exc.HResult != OPERATION_IS_IN_PROGRESS)
+                            {
+                                System.Diagnostics.Debug.WriteLine(exc.ToString());
+                                throw exc;
+                            }
+                        }
+                    });
+                }
+            }
+        }
+
+        private bool isDestroyed = false;
+
+        public async void Destroy()
+        {
+            if (isDestroyed) return;
+            isDestroyed = true;
+            await mainDispatcher.RunAsync(CoreDispatcherPriority.Normal, async () => {
+                await Capture.StopPreviewAsync();
+                Capture.Dispose();
+            });
+        }
+    }
+}
diff --git a/src/windows/QRReader/project.json b/src/windows/QRReader/project.json
index 3eb9d28b..92d14561 100644
--- a/src/windows/QRReader/project.json
+++ b/src/windows/QRReader/project.json
@@ -13,4 +13,4 @@
     "win10-x64": {},
     "win10-x64-aot": {}
   }
-}
+}
\ No newline at end of file
diff --git a/src/windows/QRReader/project.lock.json b/src/windows/QRReader/project.lock.json
index 53169258..6c89dd34 100644
--- a/src/windows/QRReader/project.lock.json
+++ b/src/windows/QRReader/project.lock.json
@@ -15501,4 +15501,4 @@
     ],
     "UAP,Version=v10.0": []
   }
-}
+}
\ No newline at end of file
diff --git a/src/windows/QRScanner.sln b/src/windows/QRScanner.sln
index f45d7039..667358b4 100644
--- a/src/windows/QRScanner.sln
+++ b/src/windows/QRScanner.sln
@@ -8,11 +8,9 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "lib", "lib", "{5FB68B78-269
 		lib\preview.css = lib\preview.css
 		lib\preview.js = lib\preview.js
 		lib\qrScanner.js = lib\qrScanner.js
-		lib\qrScannerProxy.js = lib\qrScannerProxy.js
-		lib\videoCapture.js = lib\videoCapture.js
 	EndProjectSection
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "QRReader", "QRReader\QRReader.csproj", "{2928CF9F-4255-4D8A-A7C3-70324CC137A4}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "QRReader", "QRReader\QRReader.csproj", "{DF132792-0542-4936-914D-4C25D779CAC8}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -26,24 +24,27 @@ Global
 		Release|x86 = Release|x86
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{2928CF9F-4255-4D8A-A7C3-70324CC137A4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{2928CF9F-4255-4D8A-A7C3-70324CC137A4}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{2928CF9F-4255-4D8A-A7C3-70324CC137A4}.Debug|ARM.ActiveCfg = Debug|ARM
-		{2928CF9F-4255-4D8A-A7C3-70324CC137A4}.Debug|ARM.Build.0 = Debug|ARM
-		{2928CF9F-4255-4D8A-A7C3-70324CC137A4}.Debug|x64.ActiveCfg = Debug|x64
-		{2928CF9F-4255-4D8A-A7C3-70324CC137A4}.Debug|x64.Build.0 = Debug|x64
-		{2928CF9F-4255-4D8A-A7C3-70324CC137A4}.Debug|x86.ActiveCfg = Debug|x86
-		{2928CF9F-4255-4D8A-A7C3-70324CC137A4}.Debug|x86.Build.0 = Debug|x86
-		{2928CF9F-4255-4D8A-A7C3-70324CC137A4}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{2928CF9F-4255-4D8A-A7C3-70324CC137A4}.Release|Any CPU.Build.0 = Release|Any CPU
-		{2928CF9F-4255-4D8A-A7C3-70324CC137A4}.Release|ARM.ActiveCfg = Release|ARM
-		{2928CF9F-4255-4D8A-A7C3-70324CC137A4}.Release|ARM.Build.0 = Release|ARM
-		{2928CF9F-4255-4D8A-A7C3-70324CC137A4}.Release|x64.ActiveCfg = Release|x64
-		{2928CF9F-4255-4D8A-A7C3-70324CC137A4}.Release|x64.Build.0 = Release|x64
-		{2928CF9F-4255-4D8A-A7C3-70324CC137A4}.Release|x86.ActiveCfg = Release|x86
-		{2928CF9F-4255-4D8A-A7C3-70324CC137A4}.Release|x86.Build.0 = Release|x86
+		{DF132792-0542-4936-914D-4C25D779CAC8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{DF132792-0542-4936-914D-4C25D779CAC8}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{DF132792-0542-4936-914D-4C25D779CAC8}.Debug|ARM.ActiveCfg = Debug|ARM
+		{DF132792-0542-4936-914D-4C25D779CAC8}.Debug|ARM.Build.0 = Debug|ARM
+		{DF132792-0542-4936-914D-4C25D779CAC8}.Debug|x64.ActiveCfg = Debug|x64
+		{DF132792-0542-4936-914D-4C25D779CAC8}.Debug|x64.Build.0 = Debug|x64
+		{DF132792-0542-4936-914D-4C25D779CAC8}.Debug|x86.ActiveCfg = Debug|x86
+		{DF132792-0542-4936-914D-4C25D779CAC8}.Debug|x86.Build.0 = Debug|x86
+		{DF132792-0542-4936-914D-4C25D779CAC8}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{DF132792-0542-4936-914D-4C25D779CAC8}.Release|Any CPU.Build.0 = Release|Any CPU
+		{DF132792-0542-4936-914D-4C25D779CAC8}.Release|ARM.ActiveCfg = Release|ARM
+		{DF132792-0542-4936-914D-4C25D779CAC8}.Release|ARM.Build.0 = Release|ARM
+		{DF132792-0542-4936-914D-4C25D779CAC8}.Release|x64.ActiveCfg = Release|x64
+		{DF132792-0542-4936-914D-4C25D779CAC8}.Release|x64.Build.0 = Release|x64
+		{DF132792-0542-4936-914D-4C25D779CAC8}.Release|x86.ActiveCfg = Release|x86
+		{DF132792-0542-4936-914D-4C25D779CAC8}.Release|x86.Build.0 = Release|x86
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
+	GlobalSection(NestedProjects) = preSolution
+		{DF132792-0542-4936-914D-4C25D779CAC8} = {5FB68B78-2694-42FA-8E56-1AB779DDCE9F}
+	EndGlobalSection
 EndGlobal
diff --git a/src/windows/lib/preview.js b/src/windows/lib/preview.js
index 2d271e22..45fbe7a6 100644
--- a/src/windows/lib/preview.js
+++ b/src/windows/lib/preview.js
@@ -42,15 +42,6 @@ exports.setVideoUrl = function (videoUrl) {
   _.preview.capturePreview.src = videoUrl;
 }
 
-exports.setMirroring = function (isMirrored) {
-  ensurePreviewInitialized();
-  if (isMirrored) {
-    _.preview.capturePreviewFrame.style.transform = 'scaleY(-1)';
-  } else {
-    _.preview.capturePreviewFrame.style.transform = '';
-  }
-}
-
 exports.show = function () {
   ensurePreviewInitialized();
   if (!_.preview.capturePreviewFrame) {
@@ -94,4 +85,4 @@ exports.destroy = function () {
   }
 }
 
-module.exports = exports;
+module.exports = exports;
\ No newline at end of file
diff --git a/src/windows/lib/qrScanner.js b/src/windows/lib/qrScanner.js
index 7b6d76ca..c79c5181 100644
--- a/src/windows/lib/qrScanner.js
+++ b/src/windows/lib/qrScanner.js
@@ -1,8 +1,6 @@
-const videoCapture = require('./videoCapture');
 const preview = require('./preview');
-
 const barcodeReader = new QRReader.Reader();
-
+const VideoCapture = QRReader.VideoCapture;
 const Promise = WinJS.Promise;
 
 const errorTypes = {
@@ -52,6 +50,7 @@ function resetStatusFlags() {
 function reset() {
   document.body.removeEventListener('click', onPreviewClick);
   preview.destroy();
+  if (currentVideoCapture) currentVideoCapture.destroy();
   currentVideoCapture = null;
   availableCameras = null;
   resetStatusFlags();
@@ -68,7 +67,7 @@ function generateStatusResponse() {
 function init() {
   if (!statusFlags.prepared) {
     document.body.addEventListener('click', onPreviewClick);
-    return videoCapture.getCameras().then(function (cameras) {
+    return VideoCapture.getCamerasAsync().then(function (cameras) {
       if (cameras.back && cameras.front) {
         statusFlags.canChangeCamera = true;
       }
@@ -101,16 +100,15 @@ function initCamera(cameraType) {
     }
   }
   preview.setVideoUrl('');
-  return videoCapture.get(cameraType ? availableCameras.front.id : availableCameras.back.id).then(function (videoCapture) {
+  return VideoCapture.createAsync(cameraType ? availableCameras.front : availableCameras.back).then(function (videoCapture) {
     currentVideoCapture = videoCapture;
 
-    let videoUrl = currentVideoCapture.url;
+    let videoUrl = URL.createObjectURL(currentVideoCapture.capture);
 
     if (statusFlags.showing) {
       preview.pause();
     }
     preview.setVideoUrl(videoUrl);
-    preview.setMirroring(cameraType === cameraTypes.FRONT);
     if (statusFlags.showing) {
       preview.resume();
     }
@@ -119,7 +117,8 @@ function initCamera(cameraType) {
     statusFlags.currentCamera = cameraType;
 
   }, function (error) {
-    if (error.message.indexOf('Access is denied') > -1) {
+    const ACCESS_DENIED = -2147024891;
+    if (error.number === ACCESS_DENIED) {
       statusFlags.denied = true;
       return Promise.wrapError(errorTypes.CAMERA_ACESS_DENIED);
     }
@@ -283,4 +282,4 @@ for (let property in qrScanner) {
 
 module.exports = exports;
 
-cordova.commandProxy.add("QRScanner", exports);
+cordova.commandProxy.add("QRScanner", exports);
\ No newline at end of file
diff --git a/src/windows/lib/videoCapture.js b/src/windows/lib/videoCapture.js
deleted file mode 100644
index 17f14904..00000000
--- a/src/windows/lib/videoCapture.js
+++ /dev/null
@@ -1,192 +0,0 @@
-const Capture = Windows.Media.Capture;
-const FocusMode = Windows.Media.Devices.FocusMode;
-const Promise = WinJS.Promise;
-
-let currentVideoCapture;
-
-function create(videoDeviceId) {
-
-  let captureSettings = new Capture.MediaCaptureInitializationSettings();
-  captureSettings.streamingCaptureMode = Capture.StreamingCaptureMode.video;
-  captureSettings.videoDeviceId = videoDeviceId;
-
-  let capture = new Windows.Media.Capture.MediaCapture();
-  let displayInformation = Windows.Graphics.Display.DisplayInformation.getForCurrentView();
-
-  return capture.initializeAsync(captureSettings).then(function () {
-    adjustCaptureOrientation(displayInformation);
-    displayInformation.addEventListener("orientationchanged", onOrientationChange);
-
-    let ctrl = capture.videoDeviceController;
-    let canFocus = ctrl.focusControl && ctrl.focusControl.supported;
-
-    if (canFocus && ctrl.focusControl.configure && ctrl.focusControl.supportedFocusModes) {
-
-      function supportsFocusMode(mode) {
-        return ctrl.focusControl.supportedFocusModes.indexOf(mode).returnValue;
-      }
-
-      var focusConfig = new Windows.Media.Devices.FocusSettings();
-      focusConfig.autoFocusRange = Windows.Media.Devices.AutoFocusRange.normal;
-      focusConfig.disableDriverFallback = false;
-      if (supportsFocusMode(FocusMode.continuous)) {
-        focusConfig.mode = FocusMode.continuous;
-      } else if (supportsFocusMode(FocusMode.auto)) {
-        focusConfig.mode = FocusMode.auto;
-      }
-    }
-
-    function onOrientationChange(e) {
-      adjustCaptureOrientation(e.target);
-    }
-
-    function adjustCaptureOrientation(displayInformation) {
-
-      let orientationDegrees = displayOrientationToDegrees(displayInformation.currentOrientation)
-
-      if (capture.getPreviewMirroring()) {
-        orientationDegrees = 360 - orientationDegrees;
-      }
-      capture.setPreviewRotation(degreesToCaptureRotation(orientationDegrees));
-    }
-
-    function displayOrientationToDegrees(displayOrientation) {
-      switch (displayOrientation) {
-        case Windows.Graphics.Display.DisplayOrientations.portrait:
-          return 90;
-          break;
-        case Windows.Graphics.Display.DisplayOrientations.landscapeFlipped:
-          return 180;
-          break;
-        case Windows.Graphics.Display.DisplayOrientations.portraitFlipped:
-          return 270;
-          break;
-        case Windows.Graphics.Display.DisplayOrientations.landscape:
-        default:
-          return 0;
-          break;
-      }
-    }
-
-    function degreesToCaptureRotation(degrees) {
-      switch (degrees) {
-        case 0:
-          return Windows.Media.Capture.VideoRotation.none;
-        case 270:
-          return Windows.Media.Capture.VideoRotation.clockwise270Degrees;
-        case 180:
-          return Windows.Media.Capture.VideoRotation.clockwise180Degrees;
-        case 90:
-        default:
-          return Windows.Media.Capture.VideoRotation.clockwise90Degrees;
-      }
-    }
-
-    let videoCapture = {
-      videoDeviceId: videoDeviceId,
-      url: URL.createObjectURL(capture)
-    };
-
-    videoCapture.capture = capture;
-
-    videoCapture.canEnableLight = ctrl.torchControl && ctrl.torchControl.supported;
-
-    videoCapture.enableLight = function () {
-      if (!videoCapture.canEnableLight || !ctrl) {
-        return false;
-      }
-
-      function lightEnabler(lightControl) {
-        if (lightControl && lightControl.supported) {
-          lightControl.enabled = true;
-          if (lightControl.powerSupported) {
-            lightControl.powerPercent = 90;
-          }
-          return true;
-        }
-        return false;
-      }
-
-      return lightEnabler(ctrl.torchControl);
-    }
-
-    videoCapture.disableLight = function () {
-      if (!videoCapture.canEnableLight || !ctrl) {
-        return;
-      }
-
-      let tc = ctrl.torchControl;
-
-      if (tc.enabled) {
-        tc.enabled = false;
-      }
-    }
-
-    videoCapture.focus = function () {
-      const OPERATION_IS_IN_PROGRESS = -2147024567;
-      const INITIAL_FOCUS_DELAY = 200;
-
-      if (canFocus) {
-        let focusControl = capture.videoDeviceController.focusControl;
-        if (focusControl.focusState !== Windows.Media.Devices.MediaCaptureFocusState.searching) {
-          Promise.timeout(INITIAL_FOCUS_DELAY).done(function () {
-            focusControl.focusAsync().onerror = function (error) {
-              if (error.number !== OPERATION_IS_IN_PROGRESS) {
-                console.error(error);
-              }
-            };
-          });
-
-
-        }
-      }
-    }
-
-    videoCapture.destroy = function () {
-      displayInformation.removeEventListener("orientationchanged", onOrientationChange);
-      return Promise.wrap();
-    }
-
-    currentVideoCapture = videoCapture;
-    return videoCapture;
-  });
-
-}
-
-function getCameras() {
-  var Devices = Windows.Devices.Enumeration;
-
-  return Devices.DeviceInformation.findAllAsync(Devices.DeviceClass.videoCapture)
-    .then(function (cameras) {
-
-      if (!cameras || cameras.length === 0) {
-        throw new Error("No cameras found");
-      }
-
-      let backCameras = cameras.filter(function (camera) {
-        return camera.enclosureLocation && camera.enclosureLocation.panel === Devices.Panel.back;
-      });
-      let frontCameras = cameras.filter(function (camera) {
-        return camera.enclosureLocation && camera.enclosureLocation.panel === Devices.Panel.front;
-      });
-
-      let camerasFound = {};
-
-      if (backCameras.length > 0) camerasFound.back = backCameras[0];
-      if (frontCameras.length > 0) camerasFound.front = frontCameras[0];
-
-      return camerasFound;
-    });
-}
-
-module.exports = {
-  get: function (videoDeviceId) {
-    if (currentVideoCapture) {
-      return currentVideoCapture.destroy().then(function () {
-        return create(videoDeviceId);
-      });
-    }
-    return create(videoDeviceId);
-  },
-  getCameras: getCameras
-};