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 = 5;

        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, 0, 0);
            rightTopBorder.BorderThickness = new Thickness(0, borderThickness, borderThickness, 0);
            leftBottomBorder.BorderThickness = new Thickness(borderThickness, 0, 0, borderThickness);
            rightBottomBorder.BorderThickness = new Thickness(0, 0, borderThickness, borderThickness);

            var borderLength = 20;
            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 / 2, ActualHeight / 2);
            scanGrid.Width = scanGrid.Height = focusRecLength;
            scanCavas.Width = scanCavas.Height = focusRecLength;

            scanStoryboard.Stop();
            scanLine.X2 = scanCavas.Width - 20;
            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();
        }
    }
}