How To Scan QRCode For UWP (2)

这篇随笔主要介绍照相预览功能，重要使用的是MediaCapture对象，MediaCapture对象还可以用来处理录音和录制视频，本文只讨论照相功能。

1：查找摄像头

后置摄像头优先，找不到后置摄像头就返回找到的可用的摄像头列表的第一个。

 /// <summary>
         /// Queries the available video capture devices to try and find one mounted on the desired panel.
         /// </summary>
         /// <param name="desiredPanel">The panel on the device that the desired camera is mounted on.</param>
         /// <returns>A DeviceInformation instance with a reference to the camera mounted on the desired panel if available,
         ///          any other camera if not, or null if no camera is available.</returns>
         private static async Task<DeviceInformation> FindCameraDeviceByPanelAsync(Windows.Devices.Enumeration.Panel desiredPanel)
         {
             // Get available devices for capturing pictures.
             var allVideoDevices = await DeviceInformation.FindAllAsync(DeviceClass.VideoCapture);

             // Get the desired camera by panel.
             DeviceInformation desiredDevice = allVideoDevices.FirstOrDefault(x => x.EnclosureLocation != null && x.EnclosureLocation.Panel == desiredPanel);

             // If there is no device mounted on the desired panel, return the first device found.
             return desiredDevice ?? allVideoDevices.FirstOrDefault();
         }

2：初始Camera

首先需要创建一个MediaCapture实例，MediaCapture类位于Windows.Media.Capture命名空间。然后需要允许App访问Camera，需要修改Package.appxmanifest文件，选择Capabilities Tab 勾选中 Microphone  & Webcam。 调用MediaCapture.InitializeAsync方法并指定要初始化上一步找到的Camera。

如果MediaCapture使用的过程中抛出了Error，此时就需要释放MediaCapture资源，可以在MediaCapture的Failed事件来处理。

此外还使用了isInitialized 标志位来判断是否已经成功初始化了Camera。

3：预览

需要调用MediaCapture.StartPreviewAsync()，在预览过程中使用了DisplayRequest对象RequestActive方法来防止设备屏幕休眠。
同样使用了isPreviewing来判断Camera是否处于预览状态。
经过三个步骤后，就可以正常预览Camera了。

MediaCapture对象的StopPreviewAsync方法用来停止预览，停止预览后，设备就可以允许睡眠了，需要调用DisplayRequest对象RequestRelease。

4：其他

当App转换为Suspending状态时，先使用SuspendingOperation.GetDeferral()请求延迟挂起操作，释放完MediaCapture资源，最后调用SuspendingDeferral.Complete() 通知操作系统App已经准好被挂起了。当App转换为Resuming状态时，需要再次开启Camera。
可以分别处理Application.Current.Suspending跟Application.Current.Resuming事件。

附上代码：

 using System;
 using System.Linq;
 using System.Threading.Tasks;
 using Windows.ApplicationModel;
 using Windows.Devices.Enumeration;
 using Windows.Media.Capture;
 using Windows.System.Display;
 using Windows.UI.Core;
 using Windows.UI.Popups;
 using Windows.UI.Xaml;
 using Windows.UI.Xaml.Controls;
 using Windows.UI.Xaml.Navigation;

 // The Blank Page item template is documented at http://go.microsoft.com/fwlink/?LinkId=402352&clcid=0x409

 namespace ScanQRCode
 {
     /// <summary>
     /// An empty page that can be used on its own or navigated to within a Frame.
     /// </summary>
     public sealed partial class MainPage : Page
     {
         const int borderThickness = ;

         private MediaCapture mediaCapture;
         private bool isInitialized = false;
         private bool isPreviewing = false;

         // Prevent the screen from sleeping while the camera is running.
         private readonly DisplayRequest displayRequest = new DisplayRequest();

         public MainPage()
         {
             this.InitializeComponent();

             // Useful to know when to initialize/clean up the camera
             Application.Current.Suspending += Application_Suspending;
             Application.Current.Resuming += Application_Resuming;
         }

         /// <summary>
         /// Occures on app suspending. Stops camera if initialized.
         /// </summary>
         /// <param name="sender"></param>
         /// <param name="e"></param>
         private async void Application_Suspending(object sender, SuspendingEventArgs e)
         {
             // Handle global application events only if this page is active.
             if (Frame.CurrentSourcePageType == typeof(MainPage))
             {
                 var deferral = e.SuspendingOperation.GetDeferral();

                 await CleanupCameraAsync();

                 deferral.Complete();
             }
         }

         /// <summary>
         /// Occures on app resuming. Initializes camera if available.
         /// </summary>
         /// <param name="sender"></param>
         /// <param name="o"></param>
         private async void Application_Resuming(object sender, object o)
         {
             // Handle global application events only if this page is active
             if (Frame.CurrentSourcePageType == typeof(MainPage))
             {
                 await StartCameraAsync();
             }
         }

         private void InitFocusRec()
         {
             leftTopBorder.BorderThickness = new Thickness(borderThickness, borderThickness, , );
             rightTopBorder.BorderThickness = new Thickness(, borderThickness, borderThickness, );
             leftBottomBorder.BorderThickness = new Thickness(borderThickness, , , borderThickness);
             rightBottomBorder.BorderThickness = new Thickness(, , borderThickness, borderThickness);

             var borderLength = ;
             leftTopBorder.Width = leftTopBorder.Height = borderLength;
             rightTopBorder.Width = rightTopBorder.Height = borderLength;
             leftBottomBorder.Width = leftBottomBorder.Height = borderLength;
             rightBottomBorder.Width = rightBottomBorder.Height = borderLength;

             var focusRecLength = Math.Min(ActualWidth / , ActualHeight / );
             scanGrid.Width = scanGrid.Height = focusRecLength;
             scanCavas.Width = scanCavas.Height = focusRecLength;

             scanStoryboard.Stop();
             scanLine.X2 = scanCavas.Width - ;
             scanAnimation.To = scanCavas.Height;

             scanStoryboard.Begin();
         }

         private void Page_SizeChanged(object sender, SizeChangedEventArgs e)
         {
             InitFocusRec();
         }

         protected override async void OnNavigatedTo(NavigationEventArgs e)
         {
             await StartCameraAsync();
         }

         private async Task StartCameraAsync()
         {
             if (!isInitialized)
             {
                 await InitializeCameraAsync();
             }

             if (isInitialized)
             {
                 PreviewControl.Visibility = Visibility.Visible;
             }
         }

         /// <summary>
         /// Queries the available video capture devices to try and find one mounted on the desired panel.
         /// </summary>
         /// <param name="desiredPanel">The panel on the device that the desired camera is mounted on.</param>
         /// <returns>A DeviceInformation instance with a reference to the camera mounted on the desired panel if available,
         ///          any other camera if not, or null if no camera is available.</returns>
         private static async Task<DeviceInformation> FindCameraDeviceByPanelAsync(Windows.Devices.Enumeration.Panel desiredPanel)
         {
             // Get available devices for capturing pictures.
             var allVideoDevices = await DeviceInformation.FindAllAsync(DeviceClass.VideoCapture);

             // Get the desired camera by panel.
             DeviceInformation desiredDevice = allVideoDevices.FirstOrDefault(x => x.EnclosureLocation != null && x.EnclosureLocation.Panel == desiredPanel);

             // If there is no device mounted on the desired panel, return the first device found.
             return desiredDevice ?? allVideoDevices.FirstOrDefault();
         }

         /// Initializes the MediaCapture
         /// </summary>
         private async Task InitializeCameraAsync()
         {
             if (mediaCapture == null)
             {
                 // Attempt to get the back camera if one is available, but use any camera device if not.
                 var cameraDevice = await FindCameraDeviceByPanelAsync(Windows.Devices.Enumeration.Panel.Back);

                 if (cameraDevice == null)
                 {
                     //No camera device!
                     return;
                 }

                 // Create MediaCapture and its settings.
                 mediaCapture = new MediaCapture();

                 // Register for a notification when something goes wrong
                 mediaCapture.Failed += MediaCapture_Failed;

                 var settings = new MediaCaptureInitializationSettings { VideoDeviceId = cameraDevice.Id };

                 // Initialize MediaCapture
                 try
                 {
                     await mediaCapture.InitializeAsync(settings);
                     isInitialized = true;
                 }
                 catch (UnauthorizedAccessException)
                 {
                     await ShowMessage("Denied access to the camera.");
                 }
                 catch (Exception ex)
                 {
                     await ShowMessage("Exception when init MediaCapture. " + ex.Message);
                 }

                 // If initialization succeeded, start the preview.
                 if (isInitialized)
                 {
                     await StartPreviewAsync();
                 }
             }
         }

         /// <summary>
         /// Starts the preview after making a request to keep the screen on and unlocks the UI.
         /// </summary>
         private async Task StartPreviewAsync()
         {
             // Prevent the device from sleeping while the preview is running.
             displayRequest.RequestActive();

             // Set the preview source in the UI.
             PreviewControl.Source = mediaCapture;
             // Start the preview.
             try
             {
                 await mediaCapture.StartPreviewAsync();
                 isPreviewing = true;
             }
             catch (Exception ex)
             {
                 await ShowMessage("Exception starting preview." + ex.Message);
             }
         }

         /// <summary>
         /// Handles MediaCapture failures. Cleans up the camera resources.
         /// </summary>
         /// <param name="sender"></param>
         /// <param name="errorEventArgs"></param>
         private async void MediaCapture_Failed(MediaCapture sender, MediaCaptureFailedEventArgs errorEventArgs)
         {
             await CleanupCameraAsync();
         }

         /// <summary>
         /// Cleans up the camera resources (after stopping the preview if necessary) and unregisters from MediaCapture events.
         /// </summary>
         private async Task CleanupCameraAsync()
         {
             if (isInitialized)
             {
                 if (isPreviewing)
                 {
                     // The call to stop the preview is included here for completeness, but can be
                     // safely removed if a call to MediaCapture.Dispose() is being made later,
                     // as the preview will be automatically stopped at that point
                     await StopPreviewAsync();
                 }

                 isInitialized = false;
             }

             if (mediaCapture != null)
             {
                 mediaCapture.Failed -= MediaCapture_Failed;
                 mediaCapture.Dispose();
                 mediaCapture = null;
             }
         }

         /// <summary>
         /// Stops the preview and deactivates a display request, to allow the screen to go into power saving modes, and locks the UI
         /// </summary>
         /// <returns></returns>
         private async Task StopPreviewAsync()
         {
             try
             {
                 isPreviewing = false;
                 await mediaCapture.StopPreviewAsync();
             }
             catch (Exception ex)
             {
                 // Use the dispatcher because this method is sometimes called from non-UI threads.
                 await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async () =>
                 {
                     await ShowMessage("Exception stopping preview. " + ex.Message);
                 });
             }

             // Use the dispatcher because this method is sometimes called from non-UI threads.
             await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
             {
                 PreviewControl.Source = null;

                 // Allow the device to sleep now that the preview is stopped.
                 displayRequest.RequestRelease();
             });
         }

         private async Task ShowMessage(string message)
         {
             var messageDialog = new MessageDialog(message);
             await messageDialog.ShowAsync();
         }
     }
 }