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

Cet article explique comment utiliser la classe CameraCaptureUI pour capturer des photos ou des vidéos à l’aide de l’interface utilisateur de la caméra intégrée à Windows. Cette fonctionnalité est facile à utiliser. Il permet à votre application d’obtenir une photo ou une vidéo capturée 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, consultez La capture photo, vidéo et audio de base avec MediaCapture.

Remarque

Vous ne devez pas spécifier les fonctionnalités de webcam ni de microphone dans le fichier manifeste de votre application si votre application utilise uniquement CameraCaptureUI. Si vous le faites, votre application s’affiche dans les paramètres de confidentialité de l’appareil photo, mais même si l’utilisateur refuse l’accès à l’appareil photo à votre application, cela n’empêche pas cameraCaptureUI de capturer des médias.

Cela est dû au fait que l’application de caméra intégrée Windows est une application tierce approuvée qui oblige l’utilisateur à lancer la photo, l’audio et la capture vidéo avec une pression sur un bouton. Votre application peut échouer à la certification du Kit de certification des applications 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 photos.

Vous devez spécifier les fonctionnalités de webcam ou de microphone dans votre fichier manifeste d’application si vous utilisez MediaCapture pour capturer l’audio, les photos ou la vidéo 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 effectuer des opérations de fichier avec le fichier image retourné, 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. En utilisant 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.

Remarque

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 retourne une instance StorageFile contenant l’image si la capture réussit. Si l’utilisateur annule la capture, l’objet retourné 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;
}

Le StorageFile contenant la photo capturée reçoit un nom généré dynamiquement et 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 universelle différentes.

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 la bitmap logicielle dans votre page XAML, incluez l’espace de noms 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 nécessite que la source de l’image soit au format BGRA8 avec alpha prémultiplié ou aucun 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 la bitmap logicielle à la source. Enfin, définissez la propriété Source du contrôle Image 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. En utilisant 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 Vidéo pour capturer une vidéo. La méthode retourne une instance StorageFile contenant la vidéo si la capture réussit. 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 avec le fichier vidéo capturé dépend du scénario de votre application. Le reste de cet article vous montre 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’affiche 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 caméra, 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();

Rubriques connexes

• Appareil photo
• Capture photo, vidéo et audio de base à l’aide de MediaCapture
• CameraCaptureUI