Udostępnij za pośrednictwem

Widok Kamery

Zapewnia CameraView możliwość nawiązywania połączenia z aparatem, wyświetlania podglądu z aparatu, robienia zdjęć i nagrywania filmów wideo. CameraView oferuje również funkcje umożliwiające sterowanie błyskiem i latarką, dostosowywanie powiększenia, zapisywanie przechwyconych multimediów do pliku oraz różne haki dla zdarzeń.

Poniższe sekcje będą przyrostowo opierać się na sposobie używania obiektu CameraView w aplikacji .NET MAUI. Polegają one na użyciu obiektu CameraViewModel. będą ustawione jako BindingContext przykładu CameraViewPage.

Inicjowanie specyficzne dla platformy

Element CameraView jest częścią CommunityToolkit.Maui.Camera pakietu nuget. Aby skorzystać z CameraView, najpierw zapoznaj się z sekcją Wprowadzenie. Wymagana jest następująca konfiguracja specyficzna dla platformy.

Do pliku Platforms/Android/AndroidManifest.xml należy dodać następujące uprawnienia:

<uses-permission android:name="android.permission.CAMERA" />

Jeśli planujesz nagrywać wideo, zażądaj uprawnień mikrofonu:

<uses-permission android:name="android.permission.RECORD_AUDIO" />

Należy go dodać wewnątrz <manifest> elementu . Poniżej przedstawiono bardziej kompletny przykład:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android">
    <application android:allowBackup="true" android:icon="@mipmap/appicon" android:roundIcon="@mipmap/appicon_round" android:supportsRtl="true" />

    <uses-permission android:name="android.permission.CAMERA" />

    <!--Optional. Only for video recording-->
    <uses-permission android:name="android.permission.RECORD_AUDIO" />

</manifest>

Podstawowy sposób użycia

Element CameraView można dodać do aplikacji .NET MAUI w następujący sposób.

Zażądaj uprawnień

Deweloperzy muszą ręcznie zażądać uprawnień.Aparat i/lub uprawnienia.Mikrofon:

var cameraPermissionsRequest = await Permissions.RequestAsync<Permissions.Camera>();

Jeśli planujesz nagrywać wideo, zażądaj uprawnień mikrofonu:

var microphonePermissionsRequest = await Permissions.RequestAsync<Permissions.Microphone>();

Dołączanie przestrzeni nazw XAML

Aby można było używać zestawu narzędzi w języku XAML, należy dodać następujące xmlns elementy do strony lub widoku:

xmlns:toolkit="http://schemas.microsoft.com/dotnet/2022/maui/toolkit"

Dlatego następuje:

<ContentPage
    x:Class="CommunityToolkit.Maui.Sample.Pages.MyPage"
    xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml">

</ContentPage>

Zostanie zmodyfikowana tak, aby zawierała następujące xmlns elementy:

<ContentPage
    x:Class="CommunityToolkit.Maui.Sample.Pages.MyPage"
    xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
    xmlns:toolkit="http://schemas.microsoft.com/dotnet/2022/maui/toolkit">

</ContentPage>

<ContentPage
    x:Class="CommunityToolkit.Maui.Sample.Pages.CameraViewPage"
    xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
    xmlns:toolkit="http://schemas.microsoft.com/dotnet/2022/maui/toolkit">
    
    <Grid ColumnDefinitions="*,*,*" RowDefinitions="*,30">
        <toolkit:CameraView 
            Grid.ColumnSpan="3" 
            Grid.Row="0" />
    </Grid>

</ContentPage>

Wynikiem będzie renderowanie wyjścia domyślnej kamery podłączonej do urządzenia.

Uzyskaj dostęp do bieżącego aparatu

Właściwość SelectedCamera umożliwia dostęp do aktualnie wybranego aparatu.

W poniższym przykładzie pokazano, jak powiązać właściwość SelectedCamera z CameraView z właściwością o tej samej nazwie CameraViewModel w SelectedCamera.

<ContentPage
    x:Class="CommunityToolkit.Maui.Sample.Pages.CameraViewPage"
    xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
    xmlns:toolkit="http://schemas.microsoft.com/dotnet/2022/maui/toolkit">
    
    <Grid ColumnDefinitions="*,*,*" RowDefinitions="*,30,30">
        <toolkit:CameraView 
            Grid.ColumnSpan="3" 
            Grid.Row="0" 
            SelectedCamera="{Binding SelectedCamera}" />
    </Grid>

</ContentPage>

Kontroluj powiększenie

Właściwość SelectedCamera zapewnia zarówno właściwość MinimumZoomFactor i MaximumZoomFactor, które są tylko do odczytu i zapewniają programistom sposób programowego określania, jakie powiększenie można zastosować do bieżącego aparatu. Aby zmienić powiększenie bieżącej kamery, CameraView udostępnia właściwość ZoomFactor.

Uwaga

Jeśli wartość jest podana poza MinimumZoomFactor i MaximumZoomFactor, CameraView ograniczy wartość, aby pozostała w granicach.

W poniższym przykładzie pokazano, jak dodać element Slider do aplikacji i skonfigurować następujące powiązania:

  • Powiąż właściwość Maximum elementu Slider z właściwością MaximumZoomFactor elementu SelectedCamera.
  • Powiąż właściwość Minimum elementu Slider z właściwością MinimumZoomFactor elementu SelectedCamera.
  • Powiąż właściwość Value z właściwością Slider w klasie CurrentZoom.

Ostateczna zmiana polega na powiązaniu właściwości ZoomFactor elementu CameraView z właściwością CurrentZoom klasy CameraViewModel.

<ContentPage
    x:Class="CommunityToolkit.Maui.Sample.Pages.CameraViewPage"
    xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
    xmlns:toolkit="http://schemas.microsoft.com/dotnet/2022/maui/toolkit">
    
    <Grid ColumnDefinitions="*,*,*" RowDefinitions="*,30,30">
        <toolkit:CameraView 
            Grid.ColumnSpan="3" 
            Grid.Row="0"
            SelectedCamera="{Binding SelectedCamera}"
            ZoomFactor="{Binding CurrentZoom}" />

        <Slider 
            Grid.Column="0"
            Grid.Row="1"
            Value="{Binding CurrentZoom}"
            Maximum="{Binding SelectedCamera.MaximumZoomFactor, FallbackValue=1}"
            Minimum="{Binding SelectedCamera.MinimumZoomFactor, FallbackValue=1}"/>
    </Grid>

</ContentPage>

Tryb błysku aparatu

Zapewnia CameraView możliwość programowego zmieniania trybu flash na urządzeniu, możliwe są następujące opcje:

  • Off- lampa błyskowa jest wyłączona i nie będzie używana.
  • On- lampa błyskowa jest włączona i zawsze będzie używana.
  • Auto - lampa błyskowa będzie automatycznie używana na podstawie warunków oświetlenia.

Właściwość SelectedCamera udostępnia także IsFlashSupported, co umożliwia określenie, czy aktualnie wybrany aparat ma lampę błyskową, którą można kontrolować.

W poniższym przykładzie pokazano, jak dodać element Picker do aplikacji i skonfigurować następujące powiązania:

  • Powiąż właściwość IsVisible elementu Picker z właściwością IsFlashSupported elementu SelectedCamera.
  • Powiąż właściwość ItemsSource obiektu Picker z właściwością FlashModes klasy CameraViewModel — prosty wykaz możliwych wartości enum CameraFlashMode.
  • Powiąż właściwość SelectedItem z właściwością Picker w klasie FlashMode.

Ostateczna zmiana polega na powiązaniu właściwości CameraFlashMode elementu CameraView z właściwością FlashMode klasy CameraViewModel.

<ContentPage
    x:Class="CommunityToolkit.Maui.Sample.Pages.CameraViewPage"
    xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
    xmlns:toolkit="http://schemas.microsoft.com/dotnet/2022/maui/toolkit">
    
    <Grid ColumnDefinitions="*,*,*" RowDefinitions="*,30,30">
        <toolkit:CameraView 
            Grid.ColumnSpan="3" 
            Grid.Row="0"
            SelectedCamera="{Binding SelectedCamera}"
            ZoomFactor="{Binding CurrentZoom}"
            CameraFlashMode="{Binding FlashMode}" />

        <Slider 
            Grid.Column="0"
            Grid.Row="1"
            Value="{Binding CurrentZoom}"
            Maximum="{Binding SelectedCamera.MaximumZoomFactor, FallbackValue=1}"
            Minimum="{Binding SelectedCamera.MinimumZoomFactor, FallbackValue=1}"/>

        <Picker 
            Grid.Column="1"
            Grid.Row="1"
            Title="Flash"
            IsVisible="{Binding Path=SelectedCamera.IsFlashSupported, FallbackValue=false}"
            ItemsSource="{Binding FlashModes}"
            SelectedItem="{Binding FlashMode}" />
    </Grid>

</ContentPage>

RozdzielczośćPrzechwytywaniaObrazu

CameraView zapewnia możliwość programowego zmieniania rozdzielczości obrazów przechwyconych z bieżącego aparatu.

Uwaga

Nie spowoduje to zmiany rozdzielczości wyświetlanej w podglądzie aparatu.

Właściwość SelectedCamera również udostępnia SupportedResolutions, co umożliwia określenie, które rozdzielczości obsługuje bieżąca kamera.

W poniższym przykładzie pokazano, jak dodać element Picker do aplikacji i skonfigurować następujące powiązania:

  • Powiąż właściwość ItemsSource elementu Picker z właściwością SupportedResolutions elementu SelectedCamera.
  • Powiąż właściwość SelectedItem z właściwością Picker w klasie SelectedResolution.

Ostateczna zmiana polega na powiązaniu właściwości ImageCaptureResolution elementu CameraView z właściwością SelectedResolution klasy CameraViewModel.

<ContentPage
    x:Class="CommunityToolkit.Maui.Sample.Pages.CameraViewPage"
    xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
    xmlns:toolkit="http://schemas.microsoft.com/dotnet/2022/maui/toolkit">
    
    <Grid ColumnDefinitions="*,*,*" RowDefinitions="*,30,30">
        <toolkit:CameraView 
            Grid.ColumnSpan="3" 
            Grid.Row="0"
            SelectedCamera="{Binding SelectedCamera}"
            ZoomFactor="{Binding CurrentZoom}"
            CameraFlashMode="{Binding FlashMode}"
            ImageCaptureResolution="{Binding SelectedResolution}" />

        <Slider 
            Grid.Column="0"
            Grid.Row="1"
            Value="{Binding CurrentZoom}"
            Maximum="{Binding SelectedCamera.MaximumZoomFactor, FallbackValue=1}"
            Minimum="{Binding SelectedCamera.MinimumZoomFactor, FallbackValue=1}"/>

        <Picker 
            Grid.Column="1"
            Grid.Row="1"
            Title="Flash"
            IsVisible="{Binding Path=SelectedCamera.IsFlashSupported, FallbackValue=false}"
            ItemsSource="{Binding FlashModes}"
            SelectedItem="{Binding FlashMode}" />

        <Picker 
            Grid.Column="2"
            Grid.Row="1"
            Title="Available Resolutions"
            ItemsSource="{Binding SelectedCamera.SupportedResolutions}"
            SelectedItem="{Binding SelectedResolution}" />
    </Grid>

</ContentPage>

Zrób zdjęcie

CameraView umożliwia programowe inicjowanie przechwytywania obrazu. Jest to możliwe zarówno za pomocą metody CaptureImage, jak i metody CaptureImageCommand.

W poniższym przykładzie pokazano, jak dodać element Button do aplikacji i skonfigurować następujące powiązania:

  • Powiąż właściwość Command obiektu Button z właściwością CaptureImageCommand w obiekcie CameraView.
<ContentPage
    x:Class="CommunityToolkit.Maui.Sample.Pages.CameraViewPage"
    xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
    xmlns:toolkit="http://schemas.microsoft.com/dotnet/2022/maui/toolkit">
    
    <Grid ColumnDefinitions="*,*,*" RowDefinitions="*,30,30">
        <toolkit:CameraView
            x:Name="Camera" 
            Grid.ColumnSpan="3" 
            Grid.Row="0"
            SelectedCamera="{Binding SelectedCamera}"
            ZoomFactor="{Binding CurrentZoom}"
            CameraFlashMode="{Binding FlashMode}" />

        <Slider 
            Grid.Column="0"
            Grid.Row="1"
            Value="{Binding CurrentZoom}"
            Maximum="{Binding SelectedCamera.MaximumZoomFactor, FallbackValue=1}"
            Minimum="{Binding SelectedCamera.MinimumZoomFactor, FallbackValue=1}"/>

        <Picker 
            Grid.Column="1"
            Grid.Row="1"
            Title="Flash"
            IsVisible="{Binding Path=SelectedCamera.IsFlashSupported, FallbackValue=false}"
            ItemsSource="{Binding FlashModes}"
            SelectedItem="{Binding FlashMode}" />

        <Picker 
            Grid.Column="2"
            Grid.Row="1"
            Title="Available Resolutions"
            ItemsSource="{Binding SelectedCamera.SupportedResolutions}"
            SelectedItem="{Binding SelectedResolution}" />

        <Button
            Grid.Column="0"
            Grid.Row="2"
            Command="{Binding CaptureImageCommand, Source={x:Reference Camera}}"
            Text="Capture Image" />
    </Grid>

</ContentPage>

Uwaga

Aby użyć obrazu, który został przechwycony, CameraView dostarcza zdarzenie MediaCaptured.

W poniższym przykładzie pokazano, jak używać CaptureImage metody :

Uwaga

Poniższy kod języka C# używa pola Aparat zdefiniowany powyżej w języku XAML (<toolkit:CameraView x:Name="Camera" />)

async void HandleCaptureButtonTapped(object? sender, EventArgs e)
{
    try
    {
        // Use the Camera field defined above in XAML (`<toolkit:CameraView x:Name="Camera" />`)
        var captureImageCTS = new CancellationTokenSource(TimeSpan.FromSeconds(3));
        Stream stream = await Camera.CaptureImage(captureImageCTS.Token);
    }
    catch(Exception e)
    {
        // Handle Exception
        Trace.WriteLine(e);
    }
}

Nagrywanie wideo

Zapewnia CameraView możliwość rejestrowania filmów wideo. Jest to możliwe zarówno za pomocą metody StartVideoRecording, jak i metody StartVideoRecordingCommand.

W poniższym przykładzie pokazano, jak dodać element Button do aplikacji i skonfigurować następujące powiązania:

  • Powiąż właściwość Command obiektu Button z właściwością StartVideoRecordingCommand w obiekcie CameraView.
<ContentPage
    x:Class="CommunityToolkit.Maui.Sample.Pages.CameraViewPage"
    xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
    xmlns:toolkit="http://schemas.microsoft.com/dotnet/2022/maui/toolkit">
    
    <Grid ColumnDefinitions="*,*,*" RowDefinitions="*,30,30">
        <toolkit:CameraView
            x:Name="Camera" 
            Grid.ColumnSpan="3" 
            Grid.Row="0"
            SelectedCamera="{Binding SelectedCamera}"
            ZoomFactor="{Binding CurrentZoom}"
            CameraFlashMode="{Binding FlashMode}" />

        <Slider 
            Grid.Column="0"
            Grid.Row="1"
            Value="{Binding CurrentZoom}"
            Maximum="{Binding SelectedCamera.MaximumZoomFactor, FallbackValue=1}"
            Minimum="{Binding SelectedCamera.MinimumZoomFactor, FallbackValue=1}"/>

        <Picker 
            Grid.Column="1"
            Grid.Row="1"
            Title="Flash"
            IsVisible="{Binding Path=SelectedCamera.IsFlashSupported, FallbackValue=false}"
            ItemsSource="{Binding FlashModes}"
            SelectedItem="{Binding FlashMode}" />

        <Picker 
            Grid.Column="2"
            Grid.Row="1"
            Title="Available Resolutions"
            ItemsSource="{Binding SelectedCamera.SupportedResolutions}"
            SelectedItem="{Binding SelectedResolution}" />

        <Button Clicked="StartCameraRecording"
                Text="StartVideoRecording" />

        <Button Command="{Binding StartVideoRecordingCommand, Source={x:Reference Camera}, x:DataType=toolkit:CameraView}"
                CommandParameter="{Binding Stream}"
                Text="StartVideoRecording" />

        <Button Command="{Binding StopVideoRecordingCommand, Source={x:Reference Camera}, x:DataType=toolkit:CameraView}"
                CommandParameter="{Binding Token}"
                Text="StopVideoRecording" />
    </Grid>

</ContentPage>

Uwaga

Aby nagrać wideo, musisz podać czysty strumień.

W poniższym przykładzie pokazano, jak używać StartVideoRecording metody :

Uwaga

Poniższy kod języka C# używa pola Aparat zdefiniowany powyżej w języku XAML (<toolkit:CameraView x:Name="Camera" />)

async void StartCameraRecordingWithCustomStream(object? sender, EventArgs e)
{
    using var threeSecondVideoRecordingStream = new FileStream("recording.mp4", FileMode.Create);
    await Camera.StartVideoRecording(threeSecondVideoRecordingStream, CancellationToken.None);

    await Task.Delay(TimeSpan.FromSeconds(3));
    
    await Camera.StopVideoRecording(CancellationToken.None);
    await FileSaver.SaveAsync("recording.mp4", threeSecondVideoRecordingStream);
}

Jeśli chcesz nagrać krótkie wideo w MemoryStream, możesz użyć następnego przeciążenia VideoRecording:

async void StartCameraRecording(object? sender, EventArgs e)
{
    await Camera.StartVideoRecording(CancellationToken.None);
    
    await Task.Delay(TimeSpan.FromSeconds(3));
    
    var threeSecondVideoRecordingStream = await Camera.StopVideoRecording(CancellationToken.None);
    await FileSaver.SaveAsync("recording.mp4", threeSecondVideoRecordingStream);
}

Rozpocznij wersję zapoznawcza

Zapewnia CameraView możliwość programowego uruchomienia podglądu z kamery. Jest to możliwe zarówno za pomocą metody StartCameraPreview, jak i metody StartCameraPreviewCommand.

W poniższym przykładzie pokazano, jak dodać element Button do aplikacji i skonfigurować następujące powiązania:

  • Powiąż właściwość Command obiektu Button z właściwością StartCameraPreviewCommand w obiekcie CameraView.
<ContentPage
    x:Class="CommunityToolkit.Maui.Sample.Pages.CameraViewPage"
    xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
    xmlns:toolkit="http://schemas.microsoft.com/dotnet/2022/maui/toolkit">
    
    <Grid ColumnDefinitions="*,*,*" RowDefinitions="*,30,30">
        <toolkit:CameraView
            x:Name="Camera"  
            Grid.ColumnSpan="3" 
            Grid.Row="0"
            SelectedCamera="{Binding SelectedCamera}"
            ZoomFactor="{Binding CurrentZoom}"
            CameraFlashMode="{Binding FlashMode}" />

        <Slider 
            Grid.Column="0"
            Grid.Row="1"
            Value="{Binding CurrentZoom}"
            Maximum="{Binding SelectedCamera.MaximumZoomFactor, FallbackValue=1}"
            Minimum="{Binding SelectedCamera.MinimumZoomFactor, FallbackValue=1}"/>

        <Picker 
            Grid.Column="1"
            Grid.Row="1"
            Title="Flash"
            IsVisible="{Binding Path=SelectedCamera.IsFlashSupported, FallbackValue=false}"
            ItemsSource="{Binding FlashModes}"
            SelectedItem="{Binding FlashMode}" />

        <Picker 
            Grid.Column="2"
            Grid.Row="1"
            Title="Available Resolutions"
            ItemsSource="{Binding SelectedCamera.SupportedResolutions}"
            SelectedItem="{Binding SelectedResolution}" />

        <Button
            Grid.Column="0"
            Grid.Row="2"
            Command="{Binding CaptureImageCommand, Source={x:Reference Camera}}"
            Text="Capture Image" />

        <Button
            Grid.Column="1"
            Grid.Row="2"
            Command="{Binding StartCameraPreviewCommand, Source={x:Reference Camera}}"
            Text="Start Preview" />
    </Grid>

</ContentPage>

W poniższym przykładzie pokazano, jak używać StartCameraPreview metody :

Uwaga

Poniższy kod języka C# używa pola Aparat zdefiniowany powyżej w języku XAML (<toolkit:CameraView x:Name="Camera" />)

async void HandleStartCameraPreviewButtonTapped(object? sender, EventArgs e)
{

    try
    {
        var startCameraPreviewTCS = new CancellationTokenSource(TimeSpan.FromSeconds(3));

        // Use the Camera field defined above in XAML (`<toolkit:CameraView x:Name="Camera" />`)
        await Camera.StartCameraPreview(startCameraPreviewTCS.Token);
    }
    catch(Exception e)
    {
        // Handle Exception
        Trace.WriteLine(e);
    }
}

Zatrzymaj podgląd

CameraView zapewnia możliwość programowego zatrzymywania podglądu z kamery. Jest to możliwe zarówno za pomocą metody StopCameraPreview, jak i metody StopCameraPreviewCommand.

W poniższym przykładzie pokazano, jak dodać element Button do aplikacji i skonfigurować następujące powiązania:

  • Powiąż właściwość Command obiektu Button z właściwością StopCameraPreviewCommand w obiekcie CameraView.
<ContentPage
    x:Class="CommunityToolkit.Maui.Sample.Pages.CameraViewPage"
    xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
    xmlns:toolkit="http://schemas.microsoft.com/dotnet/2022/maui/toolkit">
    
    <Grid ColumnDefinitions="*,*,*" RowDefinitions="*,30,30">
        <toolkit:CameraView
            x:Name="Camera"  
            Grid.ColumnSpan="3" 
            Grid.Row="0"
            SelectedCamera="{Binding SelectedCamera}"
            ZoomFactor="{Binding CurrentZoom}"
            CameraFlashMode="{Binding FlashMode}" />

        <Slider 
            Grid.Column="0"
            Grid.Row="1"
            Value="{Binding CurrentZoom}"
            Maximum="{Binding SelectedCamera.MaximumZoomFactor, FallbackValue=1}"
            Minimum="{Binding SelectedCamera.MinimumZoomFactor, FallbackValue=1}"/>

        <Picker 
            Grid.Column="1"
            Grid.Row="1"
            Title="Flash"
            IsVisible="{Binding Path=SelectedCamera.IsFlashSupported, FallbackValue=false}"
            ItemsSource="{Binding FlashModes}"
            SelectedItem="{Binding FlashMode}" />

        <Picker 
            Grid.Column="2"
            Grid.Row="1"
            Title="Available Resolutions"
            ItemsSource="{Binding SelectedCamera.SupportedResolutions}"
            SelectedItem="{Binding SelectedResolution}" />

        <Button
            Grid.Column="0"
            Grid.Row="2"
            Command="{Binding CaptureImageCommand, Source={x:Reference Camera}}"
            Text="Capture Image" />

        <Button
            Grid.Column="1"
            Grid.Row="2"
            Command="{Binding StartCameraPreviewCommand, Source={x:Reference Camera}}"
            Text="Start Preview" />

        <Button
            Grid.Column="2"
            Grid.Row="2"
            Command="{Binding StopCameraPreviewCommand, Source={x:Reference Camera}}"
            Text="Stop Preview" />
    </Grid>

</ContentPage>

W poniższym przykładzie pokazano, jak używać StopCameraPreview metody :

Uwaga

Poniższy kod języka C# używa pola Aparat zdefiniowany powyżej w języku XAML (<toolkit:CameraView x:Name="Camera" />)

void HandleStopCameraPreviewButtonTapped(object? sender, EventArgs e)
{

    try
    {
        // Use the Camera field defined above in XAML (`<toolkit:CameraView x:Name="Camera" />`)
        Camera.StopCameraPreview();
    }
    catch(Exception e)
    {
        // Handle Exception
        Trace.WriteLine(e);
    }
}

Właściwości

Majątek Typ Opis Wartość domyślna
CameraFlashMode CameraFlashMode Pobiera lub ustawia tryb flash dla aparatu. Jest to właściwość powiązywalna. CameraFlashMode.Off
ImageCaptureResolution Size Pobiera lub ustawia rozdzielczość przechwytywania obrazów. Nie ma wpływu na rozdzielczość podglądu. Jest to właściwość powiązywalna. Size.Zero
IsAvailable bool Pobiera, czy aparat jest dostępny na urządzeniu. Jest to właściwość wiązalna tylko do odczytu. false
IsBusy bool Sprawdza, czy aparat jest obecnie zajęty (np. przechwytywaniem obrazu lub nagrywaniem). Jest to właściwość tylko do odczytu i możliwa do powiązania. false
IsTorchOn bool Pobiera lub ustawia, czy lampka aparatu (latarka) jest włączona. Jest to właściwość powiązywalna. false
SelectedCamera CameraInfo? Pobiera lub ustawia aktualnie wybrane urządzenie aparatu. Jest to właściwość powiązana z powiązaniem dwukierunkowym. null
ZoomFactor float Pobiera lub ustawia współczynnik powiększenia aparatu. Wartość jest automatycznie ograniczona do wybranych kamer MinimumZoomFactor i MaximumZoomFactor. Jest to właściwość powiązywalna. 1f

Commands

Polecenie Parametr polecenia Opis
CaptureImageCommand — Wyzwala przechwytywanie obrazu. Przechwycony obraz jest zwracany za pośrednictwem MediaCaptured zdarzenia.
StartCameraPreviewCommand — Uruchamia ekran podglądu aparatu.
StartVideoRecordingCommand Stream (opcjonalny) Rozpoczyna nagrywanie wideo. Opcjonalnie przekaż Stream, aby nagrać do.
StopCameraPreviewCommand — Zatrzymuje wyświetlanie podglądu aparatu.
StopVideoRecordingCommand — Zatrzymuje nagrywanie wideo i zwraca zarejestrowany strumień.

Events

Zdarzenie Typ Opis
MediaCaptured EventHandler<MediaCapturedEventArgs> Podniesione, gdy obraz zostanie pomyślnie przechwycony. Obiekt MediaCapturedEventArgs zawiera właściwość Media typu Stream, które zawierają przechwycone dane obrazu.
MediaCaptureFailed EventHandler<MediaCaptureFailedEventArgs> Zgłaszane, gdy przechwytywanie obrazu kończy się niepowodzeniem. MediaCaptureFailedEventArgs zawiera właściwość FailureReason z komunikatem o błędzie.

Methods

Metoda Zwracany typ Opis
CaptureImage(CancellationToken) Task Przechwytuje pojedynczy obraz z aparatu. Wynik jest dostarczany za pośrednictwem MediaCaptured zdarzenia.
GetAvailableCameras(CancellationToken) ValueTask<IReadOnlyList<CameraInfo>> Pobiera listę dostępnych urządzeń fotograficznych na urządzeniu.
StartCameraPreview(CancellationToken) Task Rozpoczyna wyświetlanie podglądu aparatu.
StartVideoRecording(CancellationToken) Task Rozpoczyna nagrywanie wideo na wewnętrzny element MemoryStream.
StartVideoRecording(Stream, CancellationToken) Task Rozpoczyna nagrywanie do podanego Stream.
StopCameraPreview() void Zatrzymuje wyświetlanie podglądu aparatu.
StopVideoRecording(CancellationToken) Task<Stream> Zatrzymuje nagrywanie wideo i zwraca zarejestrowane Stream.

CameraInfo

Klasa CameraInfo reprezentuje informacje o urządzeniu fotograficznym dostępnym w systemie.

Majątek Typ Opis
DeviceId string Unikatowy identyfikator urządzenia aparatu.
IsFlashSupported bool Czy aparat obsługuje lampę błyskową.
MaximumZoomFactor float Maksymalny obsługiwany współczynnik powiększenia.
MinimumZoomFactor float Minimalny obsługiwany współczynnik powiększenia.
Name string Nazwa urządzenia aparatu fotograficznego.
Position CameraPosition Fizyczne położenie aparatu na urządzeniu (Front, Rear, lub Unknown).
SupportedResolutions IReadOnlyList<Size> Lista rozdzielczości obsługiwanych przez aparat do przechwytywania obrazów.

CameraFlashMode

Wyliczenie CameraFlashMode definiuje dostępne tryby flash.

Wartość Opis
Off Lampa błyskowa jest wyłączona i nie będzie używana.
On Lampa błyskowa jest włączona i zawsze będzie używana.
Auto Lampa błyskowa będzie automatycznie używana na podstawie warunków oświetlenia.

PozycjaKamery

Wyliczenie CameraPosition definiuje możliwe fizyczne pozycje aparatu na urządzeniu.

Wartość Opis
Unknown Pozycja aparatu jest nieznana.
Front Aparat znajduje się przed urządzeniem (skierowanym do użytkownika).
Rear Kamera znajduje się z tyłu urządzenia (z dala od użytkownika).

Przykłady

Przykład tej funkcji można znaleźć w aplikacji przykładowej zestawu narzędzi .NET MAUI Community Toolkit.

API

Kod źródłowy można CameraView znaleźć w repozytorium GitHub zestawu narzędzi .NET MAUI Community Toolkit.

  • Last updated on