Udostępnij za pośrednictwem

Przechwytywanie zdjęć i wideo w aplikacji platformy UWP za pomocą wbudowanego interfejsu użytkownika aparatu systemu Windows

W tym artykule opisano sposób używania klasy CameraCaptureUI do przechwytywania zdjęć lub wideo przy użyciu interfejsu użytkownika aparatu wbudowanego w system Windows. Ta funkcja jest łatwa w użyciu. Dzięki niej aplikacja może uzyskać zrobione przez użytkownika zdjęcie lub wideo z zaledwie kilkoma wierszami kodu.

Uwaga

Klasa CameraCaptureUI w przestrzeni nazw Windows.Media.Capture jest obsługiwana tylko dla aplikacji platformy UWP. W przypadku aplikacji klasycznych korzystających z interfejsu WinUI 3 użyj nowej wersji tej funkcji w przestrzeni nazw Microsoft.Windows.Media.Capture . Aby uzyskać więcej informacji, zobacz Przechwytywanie zdjęć i wideo w aplikacji klasycznej za pomocą wbudowanego interfejsu użytkownika aparatu systemu Windows.

Jeśli chcesz udostępnić własny interfejs użytkownika aparatu lub jeśli scenariusz wymaga bardziej niezawodnej, niskiej kontroli nad operacją przechwytywania, należy użyć klasy MediaCapture i zaimplementować własne środowisko przechwytywania. Aby uzyskać więcej informacji, zobacz Podstawowe zdjęcia, wideo i przechwytywanie audio za pomocą programu MediaCapture.

Uwaga

Nie należy określać kamery internetowej ani możliwości mikrofonu w pliku manifestu aplikacji, jeśli aplikacja używa tylko CameraCaptureUI. Jeśli to zrobisz, aplikacja będzie wyświetlana w ustawieniach prywatności aparatu urządzenia, ale nawet jeśli użytkownik odmówi dostępu aparatu do aplikacji, nie uniemożliwi to CameraCaptureUI przechwytywania multimediów.

Jest to spowodowane tym, że wbudowana aplikacja aparatu systemu Windows to zaufana aplikacja pierwszej firmy, która wymaga od użytkownika zainicjowania przechwytywania zdjęć, dźwięku i wideo za pomocą naciśnięcia przycisku. Twoja aplikacja może nie przejść certyfikacji w zestawie certyfikacji aplikacji systemu Windows po przesłaniu do Microsoft Store, jeśli określisz możliwości kamery internetowej lub mikrofonu podczas korzystania z CameraCaptureUI jako jedynego mechanizmu przechwytywania zdjęć.

Należy określić możliwości kamery internetowej lub mikrofonu w pliku manifestu aplikacji, jeśli używasz MediaCapture do programowego przechwytywania dźwięku, zdjęć lub wideo.

Przechwytywanie zdjęcia za pomocą aparatu CameraCaptureUI

Aby użyć interfejsu użytkownika przechwytywania aparatu, dołącz Windows.Media.Capture przestrzeń nazw w projekcie. Aby wykonać operacje na plikach za pomocą zwróconego pliku obrazu, dołącz 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;

Aby przechwycić zdjęcie, utwórz nowy obiekt CameraCaptureUI. Za pomocą właściwości PhotoSettings obiektu można określić właściwości zwróconego zdjęcia, takie jak format obrazu zdjęcia. Domyślnie interfejs użytkownika aparatu obsługuje przycinanie zdjęcia przed jego zapisaniem. Można to wyłączyć za pomocą właściwości AllowCropping. W tym przykładzie jest ustawiony CroppedSizeInPixels, aby zażądać, aby zwrócony obraz był 200 x 200 pikseli.

Uwaga

Przycinanie obrazu w CameraCaptureUI nie jest obsługiwane w przypadku urządzeń z rodziny urządzeń przenośnych. Wartość właściwości AllowCropping jest ignorowana, gdy aplikacja jest uruchomiona na tych urządzeniach.

Wywołaj CaptureFileAsync i określ CameraCaptureUIMode.Photo, aby określić, że zdjęcie powinno zostać zrobione. Metoda zwraca wystąpienie StorageFile zawierające obraz, jeśli przechwytywanie zakończy się pomyślnie. Jeśli użytkownik anuluje przechwytywanie, zwrócony obiekt ma wartość 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;
}

StorageFile zawierający zrobione zdjęcie otrzymuje dynamicznie wygenerowaną nazwę i zapisaną w lokalnym folderze aplikacji. Aby lepiej zorganizować zrobione zdjęcia, możesz przenieść plik do innego folderu.

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();

Aby użyć zdjęcia w aplikacji, możesz utworzyć obiekt SoftwareBitmap, który może być używany z kilkoma różnymi funkcjami aplikacji uniwersalnych systemu Windows.

Najpierw uwzględnij przestrzeń nazw Windows.Graphics.Imaging w projekcie.

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;

Wywołaj openAsync, aby pobrać strumień z pliku obrazu. Wywołaj BitmapDecoder.CreateAsync, aby pobrać dekoder mapy bitowej dla strumienia. Następnie wywołaj GetSoftwareBitmap, aby uzyskać SoftwareBitmap reprezentację obrazu.

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();

Aby wyświetlić obraz w interfejsie użytkownika, zadeklaruj kontrolkę Image na stronie XAML.

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

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

Aby użyć mapy bitowej oprogramowania na stronie XAML, dołącz przestrzeń nazw Windows.UI.Xaml.Media.Imaging do projektu.

using Windows.UI.Xaml.Media.Imaging;

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

Kontrolka obrazu wymaga, aby źródło obrazu było w formacie BGRA8, z przemnożoną alfą lub bez alfy. Wywołaj metodę statyczną SoftwareBitmap.Convert, aby utworzyć nową mapę bitową oprogramowania z żądanym formatem. Następnie utwórz nowy obiekt SoftwareBitmapSource i wywołaj go SetBitmapAsync, aby przypisać mapę bitową oprogramowania do źródła. Na koniec ustaw właściwość Source kontrolki obraz, aby wyświetlić zrobione zdjęcie w interfejsie użytkownika.

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);

Przechwytywanie wideo za pomocą aparatu CameraCaptureUI

Aby przechwycić film wideo, utwórz nowy obiekt CameraCaptureUI. Korzystając z właściwości VideoSettings obiektu, można określić właściwości zwróconego filmu wideo, takie jak format wideo.

Wywołaj CaptureFileAsync i określ video, aby przechwycić wideo. Metoda zwraca wystąpienie StorageFile zawierające wideo, jeśli przechwytywanie zakończy się pomyślnie. Jeśli anulujesz przechwytywanie, zwrócony obiekt ma wartość 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;
}

To, co robisz z przechwyconym plikiem wideo, zależy od scenariusza aplikacji. W pozostałej części tego artykułu pokazano, jak szybko utworzyć kompozycję multimediów na podstawie co najmniej jednego przechwyconego filmu wideo i pokazać go w interfejsie użytkownika.

Najpierw dodaj kontrolkę MediaPlayerElement, w której kompozycja wideo będzie wyświetlana na stronie XAML.

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

Gdy plik wideo powróci z interfejsu użytkownika do przechwytywania aparatu, utwórz nowy MediaSource, wywołując CreateFromStorageFile. Wywołaj metodę Play domyślnej MediaPlayer skojarzonej z MediaPlayerElement, aby odtworzyć wideo.

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

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