Guia de início rápido: criando um receptor de reprodução (aplicativos da Windows Store em C#/VB/C++ e XAML)

Você pode criar um receptor de reprodução de software que receba a mídia transmitida de um computador do cliente e reproduza ou exiba o conteúdo como parte de seu aplicativo. Este tópico mostra como criar um aplicativo da Windows Store que notifique a si mesmo, na sua rede local, como um Renderizador de Mídia Digital; receba a mídia de vídeo de outro computador; reproduza esse vídeo e responda a comandos adicionais do computador cliente (por exemplo, alterações de volume, alterações de local de reprodução etc.).

Pré-requisitos

Microsoft Visual Studio

Criar um novo projeto e permitir o acesso às Imagens

  1. Abra o Visual Studio e selecione Novo Projeto no menu Arquivo. Na seção Visual C# ou Visual Basic, selecione Aplicativo em Branco. Nomeie o aplicativo PlayToReceiverSample e clique em OK.
  2. Abra o arquivo package.appxmanifest e selecione a guia Recursos. Selecione o recurso Rede doméstica ou do trabalho para habilitar seu aplicativo a se conectar com outros computadores de sua rede local. Feche e salve o arquivo de manifesto.

Adicionar a interface do usuário XAML

Abra o arquivo MainPage.xaml e adicione o seguinte ao elemento padrão Grade


<Button x:Name="StartReceiverButton" Content="Start Play To Receiver" Margin="283,26,0,703" Click="StartReceiverButton_Click" />
<Button x:Name="StopReceiverButton" Content="Stop Play To Receiver" Margin="907,26,0,703" Click="StopReceiverButton_Click" />
<MediaElement x:Name="VideoPlayer" Height="600" Width="800" Source="" />
<TextBlock x:Name="StatusTextBlock" Height="60" Width="800" Foreground="Green" Margin="283,689,283,19" />


Adicionar o botão manipuladores de eventos

O código nesta etapa define os manipuladores de eventos para os botões iniciar e parar. Durante o manipulador de eventos para o botão iniciar, o código cria uma instância da classe PlayToReceiver que é o Receptor de reprodução para o aplicativo. Depois que o código cria a instância do Receptor de reprodução, ele associa os manipuladores de eventos com os eventos do Receptor de reprodução. Esses eventos ocorrem quando uma ação é solicitada pelo computador do cliente de reprodução. Essas ações incluem o recebimento da mídia de origem, que aciona o evento SourceChangeRequested, e solicita pausar, continuar ou parar de reproduzir da mídia, alterar o nível do volume, ativar o mudo ou desativar o mudo do áudio, alterar a taxa de reprodução da mídia ou alterar o tempo do local de reprodução. Cada ação tem um evento respectivo.

Depois que os manipuladores de eventos são adicionados, o aplicativo define a propriedade FriendlyName do Receptor de reprodução que identifica o nome do Receptor de reprodução, pois ele é visto na rede e as propriedades que mostram que este Receptor de reprodução suporta apenas vídeo.

Depois que o Receptor de reprodução tiver sido inicializado, o aplicativo associa os manipuladores de evento para o rótulo do vídeo HTML5. Esses eventos são acionados quando uma ação ocorre para o rótulo do vídeo que é incluído no aplicativo. Quando esses eventos ocorrem , o manipulador de eventos chama um método de notificação do Receptor de reprodução para informar o cliente de reprodução sobre a ação. Por exemplo, quando a mídia termina de ser reproduzida, o evento ended do rótulo do vídeo é acionado. Durante o manipulador de eventos do evento ended, o código chama o evento NotifyEnded do Receptor de reprodução para informar o computador do cliente que o vídeo está concluído.

Depois que o Receptor de reprodução e o rótulo de vídeo tiverem sido iniciados, o código no manipulador do botão iniciar chama o método StartAsync para notificar o aplicativo como um Renderizador de mídia digital na rede local. O aplicativo também obtém uma referência para a janela de exibição ativa para impedir que a tela seja bloqueada.

No manipulador de eventos para o botão parar, o código chama o botão StopAsync para parar a notificação do Receptor de reprodução, libera a referência para a janela de exibição ativa e remove os manipuladores de eventos para o Receptor de reprodução e rótulo de vídeo.

Abra o arquivo MainPage.xaml.cs ou MainPage.xaml.vb e adicione o seguinte código à classe MainPage.


Windows.Media.PlayTo.PlayToReceiver receiver;
Windows.System.Display.DisplayRequest display;
Windows.UI.Core.CoreDispatcher dispatcher;
bool seeking = false;

private async void StartReceiverButton_Click(object sender, RoutedEventArgs e)
{
    try
    {
        dispatcher = Window.Current.CoreWindow.Dispatcher;

        if (receiver == null)
        {
            receiver = new Windows.Media.PlayTo.PlayToReceiver();
        }

        // Add Play To Receiver events and properties
        receiver.CurrentTimeChangeRequested += receiver_CurrentTimeChangeRequested;
        receiver.MuteChangeRequested += receiver_MuteChangeRequested;
        receiver.PauseRequested += receiver_PauseRequested;
        receiver.PlaybackRateChangeRequested += receiver_PlaybackRateChangeRequested;
        receiver.PlayRequested += receiver_PlayRequested;
        receiver.SourceChangeRequested += receiver_SourceChangeRequested;
        receiver.StopRequested += receiver_StopRequested;
        receiver.TimeUpdateRequested += receiver_TimeUpdateRequested;
        receiver.VolumeChangeRequested += receiver_VolumeChangeRequested;

        receiver.FriendlyName = "Sample Play To Receiver";
        receiver.SupportsAudio = false;
        receiver.SupportsVideo = true;
        receiver.SupportsImage = false;

        // Add MediaElement events
        VideoPlayer.CurrentStateChanged += VideoPlayer_CurrentStateChanged;
        VideoPlayer.MediaEnded += VideoPlayer_MediaEnded;
        VideoPlayer.MediaFailed += VideoPlayer_MediaFailed;
        VideoPlayer.MediaOpened += VideoPlayer_MediaOpened;
        VideoPlayer.RateChanged += VideoPlayer_RateChanged;
        VideoPlayer.SeekCompleted += VideoPlayer_SeekCompleted;
        VideoPlayer.VolumeChanged += VideoPlayer_VolumeChanged;

        // Advertise the receiver on the local network and start receiving commands
        await receiver.StartAsync();

        // Prevent the screen from locking
        if (display == null)
            display = new Windows.System.Display.DisplayRequest();
        display.RequestActive();

        StatusTextBlock.Text = "'" + receiver.FriendlyName + "' started.";
    }
    catch
    {
        receiver = null;
        StatusTextBlock.Text = "Failed to start receiver.";
    }
}

private async void StopReceiverButton_Click(object sender, RoutedEventArgs e)
{
    try
    {
        if (receiver != null)
        {
            await receiver.StopAsync();

            if (display != null)
                display.RequestRelease();

            // Remove Play To Receiver events
            receiver.CurrentTimeChangeRequested -= receiver_CurrentTimeChangeRequested;
            receiver.MuteChangeRequested -= receiver_MuteChangeRequested;
            receiver.PauseRequested -= receiver_PauseRequested;
            receiver.PlaybackRateChangeRequested -= receiver_PlaybackRateChangeRequested;
            receiver.PlayRequested -= receiver_PlayRequested;
            receiver.SourceChangeRequested -= receiver_SourceChangeRequested;
            receiver.StopRequested -= receiver_StopRequested;
            receiver.TimeUpdateRequested -= receiver_TimeUpdateRequested;
            receiver.VolumeChangeRequested -= receiver_VolumeChangeRequested;

            //  Remove MediaElement events
            VideoPlayer.Pause();

            VideoPlayer.CurrentStateChanged -= VideoPlayer_CurrentStateChanged;
            VideoPlayer.MediaEnded -= VideoPlayer_MediaEnded;
            VideoPlayer.MediaFailed -= VideoPlayer_MediaFailed;
            VideoPlayer.MediaOpened -= VideoPlayer_MediaOpened;
            VideoPlayer.RateChanged -= VideoPlayer_RateChanged;
            VideoPlayer.SeekCompleted -= VideoPlayer_SeekCompleted;
            VideoPlayer.VolumeChanged -= VideoPlayer_VolumeChanged;

            StatusTextBlock.Text = "Stopped '" + receiver.FriendlyName + "'.";
        }
    }
    catch
    {
        StatusTextBlock.Text = "Failed to stop '" + receiver.FriendlyName + "'.";
    }
}


Adicione os manipuladores de eventos do Receptor de reprodução

O código nesta etapa adiciona o código para os manipuladores de eventos do Receptor de reprodução. Esses manipuladores de eventos são chamados em resposta às solicitações do computador do cliente de reprodução. Por exemplo, se o computador do cliente de reprodução ativar ou desativar o mudo do volume, então o evento MuteChangeRequested será gerado. No manipulador de eventos associados, o aplicativo ativa ou desativa o mudo do rótulo do vídeo local em resposta à solicitação.

Adicione o seguinte código ao arquivo MainPage.xaml.cs ou MainPage.xaml.vb e após o código da etapa anterior.


async void receiver_CurrentTimeChangeRequested(
    Windows.Media.PlayTo.PlayToReceiver sender,
    Windows.Media.PlayTo.CurrentTimeChangeRequestedEventArgs args)
{
    await dispatcher.RunAsync(
        Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
        {
            VideoPlayer.Position = args.Time;
            receiver.NotifySeeking();
            seeking = true;
        });
}

async void receiver_MuteChangeRequested(
    Windows.Media.PlayTo.PlayToReceiver sender,
    Windows.Media.PlayTo.MuteChangeRequestedEventArgs args)
{
    await dispatcher.RunAsync(
        Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
        {
            VideoPlayer.IsMuted = args.Mute;
        });
}

async void receiver_PauseRequested(
    Windows.Media.PlayTo.PlayToReceiver sender,
    object args)
{
    await dispatcher.RunAsync(
        Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
        {
            VideoPlayer.Pause();
        });
}

async void receiver_PlaybackRateChangeRequested(
    Windows.Media.PlayTo.PlayToReceiver sender,
    Windows.Media.PlayTo.PlaybackRateChangeRequestedEventArgs args)
{
    await dispatcher.RunAsync(
        Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
        {
            VideoPlayer.PlaybackRate = args.Rate;
        });
}

async void receiver_PlayRequested(
    Windows.Media.PlayTo.PlayToReceiver sender,
    object args)
{
    await dispatcher.RunAsync(
        Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
        {
            VideoPlayer.Play();
        });
}

async void receiver_SourceChangeRequested(
    Windows.Media.PlayTo.PlayToReceiver sender,
    Windows.Media.PlayTo.SourceChangeRequestedEventArgs args)
{
    if (args.Stream != null)
        await dispatcher.RunAsync(
            Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
            {
                var stream = args.Stream as Windows.Storage.Streams.IRandomAccessStream;
                VideoPlayer.SetSource(stream, args.Stream.ContentType);
            });
}

async void receiver_StopRequested(
    Windows.Media.PlayTo.PlayToReceiver sender,
    object args)
{
    await dispatcher.RunAsync(
        Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
        {
            VideoPlayer.Stop();
        });
}

async void receiver_TimeUpdateRequested(
    Windows.Media.PlayTo.PlayToReceiver sender,
    object args)
{
    await dispatcher.RunAsync(
        Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
        {
            if (VideoPlayer.Position != null)
                receiver.NotifyTimeUpdate(VideoPlayer.Position);
        });
}

async void receiver_VolumeChangeRequested(
    Windows.Media.PlayTo.PlayToReceiver sender,
    Windows.Media.PlayTo.VolumeChangeRequestedEventArgs args)
{
    await dispatcher.RunAsync(
        Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
        {
            VideoPlayer.Volume = args.Volume;
        });
}


Adicionar manipuladores de evento do player de vídeo

O código nesta etapa adiciona o código dos manipuladores de eventos do player de vídeo. Esses manipuladores de eventos são chamados quando ocorrem eventos para o player de vídeo local. Os manipuladores de eventos então notificam o computador do cliente usando o respectivo método do Receptor de reprodução.

  1. Adicione o seguinte código ao arquivo MainPage.xaml.cs ou MainPage.xaml.vb e após o código da etapa anterior.

    
    void VideoPlayer_CurrentStateChanged(object sender, RoutedEventArgs e)
    {
        if (receiver != null)
        {
            switch (VideoPlayer.CurrentState)
            {
                case MediaElementState.Playing:
                    receiver.NotifyPlaying();
                    break;
                case MediaElementState.Paused:
                    receiver.NotifyPaused();
                    break;
                case MediaElementState.Stopped:
                    receiver.NotifyStopped();
                    break;
            }
        }
    }
    
    void VideoPlayer_MediaFailed(object sender, ExceptionRoutedEventArgs e)
    {
        if (receiver != null) { receiver.NotifyError(); }
    }
    
    void VideoPlayer_MediaEnded(object sender, RoutedEventArgs e)
    {
        if (receiver != null)
        {
            receiver.NotifyEnded();
            VideoPlayer.Stop();
        }
    }
    
    void VideoPlayer_MediaOpened(object sender, RoutedEventArgs e)
    {
        if (receiver != null)
        {
            receiver.NotifyDurationChange(VideoPlayer.NaturalDuration.TimeSpan);
            receiver.NotifyLoadedMetadata();
        }
    }
    
    void VideoPlayer_RateChanged(object sender, RateChangedRoutedEventArgs e)
    {
        if (receiver != null)
            receiver.NotifyRateChange(VideoPlayer.PlaybackRate);
    }
    
    void VideoPlayer_SeekCompleted(object sender, RoutedEventArgs e)
    {
        if (receiver != null)
        {
            if (!seeking)
                receiver.NotifySeeking();
            receiver.NotifySeeked();
            seeking = false;
        }
    }
    
    void VideoPlayer_VolumeChanged(object sender, RoutedEventArgs e)
    {
        if (receiver != null)
            receiver.NotifyVolumeChange(VideoPlayer.Volume, VideoPlayer.IsMuted);
    }
    
    
    
  2. Salve e feche o arquivo MainPage.xaml.cs ou MainPage.xaml.vb

Executar o aplicativo

  1. No Visual Studio, pressione F5 (depurar) para executar o aplicativo.
  2. Clique no botão Iniciar Receptor de reprodução.
  3. Se o Receptor de reprodução iniciar com sucesso, abra o botão Configurações em outro computador e selecione Mais configurações do PC. Na janela Mais configurações, selecione Dispositivos.
  4. Na seção Dispositivos, clique em Adicionar um dispositivo. Localize o Renderizador de mídia digital do Receptor de reprodução de exemplo. Se você mudou o valor da propriedade FriendlyName do Receptor de reprodução, então localize aquele nome. Selecione o Receptor de reprodução na lista para adicioná-lo.
  5. No computador do cliente, reproduza um vídeo que possa ser transmitido usando Reproduzir em. Enquanto a mídia está em execução, abra o botão Dispositivos e selecione o Receptor de reprodução personalizado como o destino para o vídeo transmitido.

Resumo

Neste início rápido, você criou um aplicativo que se auto notifica como um Renderizador de mídia digital e reproduz o conteúdo transmitido de um cliente de reprodução.

Tópicos relacionados

Transmitindo mídia para dispositivos usando Reproduzir em
Exemplos
Exemplo do botão Reproduzir em
Exemplo de PlayToReceiver
Exemplo de Servidor de Mídia

 

 

Mostrar:
© 2014 Microsoft. Todos os direitos reservados.