Capturer des photos et des vidéos à l’aide de l’interface utilisateur de l’appareil photo intégré à Windows

  • Article

Cet article explique comment utiliser la classe CameraCaptureUI pour capturer des photos ou des vidéos à l’aide de l’interface utilisateur de l’appareil photo intégrée à Windows. Cette fonctionnalité est facile à utiliser. Il permet à votre application d’obtenir une photo ou une vidéo capturées par l’utilisateur avec seulement quelques lignes de code.

Si vous souhaitez fournir votre propre interface utilisateur de caméra, ou si votre scénario nécessite un contrôle plus robuste et de bas niveau de l’opération de capture, vous devez utiliser la classe MediaCapture et implémenter votre propre expérience de capture. Pour plus d’informations, voir Capture photo, vidéo et audio de base à l’aide de MediaCapture.

Notes

Vous ne devez pas spécifier les fonctionnalités de webcam ni de microphone dans votre fichier manifeste d’application si votre application utilise uniquement CameraCaptureUI. Si c’est le cas, votre application sera affichée dans les paramètres de confidentialité de l’appareil photo de l’appareil, mais même si l’utilisateur refuse l’accès de la caméra à votre application, cela n’empêchera pas cameraCaptureUI de capturer des médias.

Cela s’explique par le fait que l’application d’appareil photo intégrée de Windows est une application interne approuvée qui nécessite que l’utilisateur démarre la capture photo, vidéo ou audio en appuyant sur un bouton. Votre application peut échouer à la certification du Kit de certification d’application Windows lorsqu’elle est soumise au Microsoft Store si vous spécifiez les fonctionnalités de webcam ou de microphone lors de l’utilisation de CameraCaptureUI comme seul mécanisme de capture de photo.

Vous devez spécifier les fonctionnalités de webcam ou de microphone dans votre fichier manifeste d’application si vous utilisez MediaCapture pour capturer des données audio, des photos ou des vidéos par programmation.

Capturer une photo avec CameraCaptureUI

Pour utiliser l’interface utilisateur de capture de caméra, incluez l’espace de noms Windows.Media.Capture dans votre projet. Pour les opérations de fichier avec le fichier image renvoyé, incluez Windows.Storage.

using Windows.Media.Capture;
using Windows.Storage;

#include <winrt/Windows.Media.Capture.h>
#include <winrt/Windows.Media.Playback.h>
#include <winrt/Windows.Storage.h>
using namespace winrt;
using namespace Windows::Media::Capture;
using namespace Windows::Storage;

Pour capturer une photo, créez un objet CameraCaptureUI . À l’aide de la propriété PhotoSettings de l’objet, vous pouvez spécifier des propriétés pour la photo retournée, telles que le format de l’image de la photo. Par défaut, l’interface utilisateur de capture de l’appareil photo prend en charge le rognage de la photo avant son retour. Cela peut être désactivé avec la propriété AllowCropping . Cet exemple montre comment définir CroppedSizeInPixels pour demander que l’image retournée soit de 200 x 200 en pixels.

Notes

Le rognage d’images dans CameraCaptureUI n’est pas pris en charge pour les appareils de la famille d’appareils mobiles. La valeur de la propriété AllowCropping est ignorée lorsque votre application s’exécute sur ces appareils.

Appelez CaptureFileAsync et spécifiez CameraCaptureUIMode.Photo pour spécifier qu’une photo doit être capturée. La méthode renvoie une instance StorageFile contenant l’image si la capture est réussie. Si l’utilisateur annule la capture, l’objet renvoyé est null.

CameraCaptureUI captureUI = new CameraCaptureUI();
captureUI.PhotoSettings.Format = CameraCaptureUIPhotoFormat.Jpeg;
captureUI.PhotoSettings.CroppedSizeInPixels = new Size(200, 200); 

StorageFile photo = await captureUI.CaptureFileAsync(CameraCaptureUIMode.Photo);

if (photo == null)
{
    // User cancelled photo capture
    return;
}

CameraCaptureUI captureUI;
captureUI.PhotoSettings().Format(CameraCaptureUIPhotoFormat::Jpeg);
captureUI.PhotoSettings().CroppedSizeInPixels({ 200, 200 });

StorageFile photo = co_await captureUI.CaptureFileAsync(CameraCaptureUIMode::Photo);

if (!photo)
{
    // User cancelled photo capture
    co_return;
}

L’élément StorageFile qui contient la photo capturée reçoit un nom généré de manière dynamique et est enregistré dans le dossier local de votre application. Pour mieux organiser vos photos capturées, vous pouvez déplacer le fichier vers un autre dossier.

StorageFolder destinationFolder = 
    await ApplicationData.Current.LocalFolder.CreateFolderAsync("ProfilePhotoFolder", 
        CreationCollisionOption.OpenIfExists);

await photo.CopyAsync(destinationFolder, "ProfilePhoto.jpg", NameCollisionOption.ReplaceExisting);
await photo.DeleteAsync();

StorageFolder destinationFolder =
    co_await ApplicationData::Current().LocalFolder().CreateFolderAsync(L"ProfilePhotoFolder",
        CreationCollisionOption::OpenIfExists);

co_await photo.CopyAsync(destinationFolder, L"ProfilePhoto.jpg", NameCollisionOption::ReplaceExisting);
co_await photo.DeleteAsync();

Pour utiliser votre photo dans votre application, vous pouvez créer un objet SoftwareBitmap qui peut être utilisé avec plusieurs fonctionnalités d’application Windows universelles.

Tout d’abord, incluez l’espace de noms Windows.Graphics.Imaging dans votre projet.

using Windows.Storage.Streams;
using Windows.Graphics.Imaging;

#include <winrt/Windows.Graphics.Imaging.h>
#include <winrt/Windows.Storage.Streams.h>
using namespace Windows::Graphics::Imaging;
using namespace Windows::Storage::Streams;

Appelez OpenAsync pour obtenir un flux à partir du fichier image. Appelez BitmapDecoder.CreateAsync pour obtenir un décodeur bitmap pour le flux. Ensuite, appelez GetSoftwareBitmap pour obtenir une représentation SoftwareBitmap de l’image.

IRandomAccessStream stream = await photo.OpenAsync(FileAccessMode.Read);
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);
SoftwareBitmap softwareBitmap = await decoder.GetSoftwareBitmapAsync();

IRandomAccessStream stream = co_await photo.OpenAsync(FileAccessMode::Read);
BitmapDecoder decoder = co_await BitmapDecoder::CreateAsync(stream);
SoftwareBitmap softwareBitmap = co_await decoder.GetSoftwareBitmapAsync();

Pour afficher l’image dans votre interface utilisateur, déclarez un contrôle Image dans votre page XAML.

<Image x:Name="imageControl" Width="200" Height="200"/>

<Image x:Name="imageControl" Width="200" Height="200"/>

Pour utiliser l’image bitmap logicielle dans votre page XAML, incluez l’espace de noms using Windows.UI.Xaml.Media.Imaging dans votre projet.

using Windows.UI.Xaml.Media.Imaging;

#include <winrt/Windows.UI.Xaml.Media.Imaging.h>
using namespace Windows::UI::Xaml::Media::Imaging;

Le contrôle Image exige que la source d’image soit au format BGRA8 avec alpha prémultiplié ou aucune alpha. Appelez la méthode statique SoftwareBitmap.Convert pour créer une image bitmap logicielle au format souhaité. Ensuite, créez un objet SoftwareBitmapSource et appelez-le SetBitmapAsync pour affecter l’image bitmap logicielle à la source. Enfin, définissez le contrôle Image et sa propriété Source pour afficher la photo capturée dans l’interface utilisateur.

SoftwareBitmap softwareBitmapBGR8 = SoftwareBitmap.Convert(softwareBitmap,
        BitmapPixelFormat.Bgra8, 
        BitmapAlphaMode.Premultiplied);

SoftwareBitmapSource bitmapSource = new SoftwareBitmapSource();
await bitmapSource.SetBitmapAsync(softwareBitmapBGR8);

imageControl.Source = bitmapSource;

SoftwareBitmap softwareBitmapBGR8 = SoftwareBitmap::Convert(softwareBitmap,
    BitmapPixelFormat::Bgra8,
    BitmapAlphaMode::Premultiplied);

SoftwareBitmapSource bitmapSource;
co_await bitmapSource.SetBitmapAsync(softwareBitmapBGR8);

imageControl().Source(bitmapSource);

Capturer une vidéo avec CameraCaptureUI

Pour capturer une vidéo, créez un objet CameraCaptureUI. À l’aide de la propriété VideoSettings de l’objet, vous pouvez spécifier des propriétés pour la vidéo retournée, telles que le format de la vidéo.

Appelez CaptureFileAsync et spécifiez Video pour capturer une vidéo. La méthode renvoie une instance StorageFile contenant la vidéo si la capture est réussie. Si vous annulez la capture, l’objet retourné est null.

CameraCaptureUI captureUI = new CameraCaptureUI();
captureUI.VideoSettings.Format = CameraCaptureUIVideoFormat.Mp4;

StorageFile videoFile = await captureUI.CaptureFileAsync(CameraCaptureUIMode.Video);

if (videoFile == null)
{
    // User cancelled photo capture
    return;
}

CameraCaptureUI captureUI;
captureUI.VideoSettings().Format(CameraCaptureUIVideoFormat::Mp4);

StorageFile videoFile = co_await captureUI.CaptureFileAsync(CameraCaptureUIMode::Video);

if (!videoFile)
{
    // User cancelled photo capture
    co_return;
}

Ce que vous faites du fichier vidéo capturé dépend du scénario pour votre application. Le reste de cet article décrit comment créer rapidement une composition multimédia à partir d’une ou plusieurs vidéos capturées et l’afficher dans votre interface utilisateur.

Tout d’abord, ajoutez un contrôle MediaPlayerElement dans lequel la composition vidéo s’affichera sur votre page XAML.

<MediaPlayerElement x:Name="mediaPlayerElement" Width="320" Height="240" AreTransportControlsEnabled="True"/>

Lorsque le fichier vidéo retourne à partir de l’interface utilisateur de capture de l’appareil photo, créez un mediaSource en appelant CreateFromStorageFile. Appelez la méthode Play du MediaPlayer par défaut associé à MediaPlayerElement pour lire la vidéo.

mediaPlayerElement.Source = MediaSource.CreateFromStorageFile(videoFile);
mediaPlayerElement.MediaPlayer.Play();

mediaPlayerElement().Source(MediaSource::CreateFromStorageFile(videoFile));
mediaPlayerElement().MediaPlayer().Play();