Intervalos de anúncio

Informações gerais

O SDK do receptor da Web apresenta suporte nativo para intervalos de anúncio e anúncios complementares em um determinado stream de mídia. Ela oferece APIs para definir a posição, a origem e o comportamento dos anúncios, além dos clipes de intervalo associados. Neste guia, um Break se refere a um intervalo para reprodução com um ou mais anúncios ou bumpers. Cada um deles é chamado de BreakClip. Esses intervalos são associados à mídia que está sendo carregada ou reproduzida.

Tipos de anúncio

O SDK do receptor da Web é compatível com a inserção de anúncios do lado do cliente (CSAI, na sigla em inglês) e com a inserção de anúncios integrados do servidor (SSAI, na sigla em inglês). Os anúncios acoplados ao cliente podem ser definidos manualmente pelo aplicativo ou extraídos dos arquivos de modelo VAST e VMAP. Os anúncios agrupados com servidor precisam ser especificados manualmente antes do carregamento do conteúdo como anúncios incorporados ou dinamicamente durante a reprodução do conteúdo como anúncios expandidos incorporados. As implementações de cada um desses tipos de anúncio são descritas em detalhes abaixo.

feita manualmente pelo cliente

O intervalo de anúncio manual dividido pelo cliente é um tipo de intervalo de anúncio agrupado pelo cliente e especificado manualmente pelo aplicativo usando as APIs do SDK. Esse tipo de anúncio não é incorporado ao stream do conteúdo principal. O BreakClip precisa fornecer o contentId, que é um URL que direciona para o conteúdo do anúncio, o contentType que descreve o formato do conteúdo do anúncio e o title.

Observação: em alguns casos, é necessário fornecer mais informações sobre o formato do conteúdo do anúncio na propriedade hlsSegmentFormat para anúncios HLS reproduzidos pelo MPL. Semelhante ao guia de suporte ao formato de segmento do conteúdo principal, essa propriedade comunica ao player o formato de contêiner esperado para os segmentos de anúncios subjacentes.

O Break precisa ter isEmbedded e expanded definidos como o valor padrão false. O position pode ser definido como um intervalo de anúncio precedente, intermediário ou final. Saiba mais na seção de posicionamento do intervalo. Ao preparar o anúncio para reprodução, o SDK do receptor da Web gera outra instância do player para carregar e reproduzir o conteúdo do anúncio. Esses intervalos exigem um stitched timeline e precisam ser adicionados estaticamente. Saiba mais na seção Inserção de anúncios. O exemplo abaixo mostra a implementação básica de um anúncio agrupado manual pelo cliente:

// Create the BreakClip.
let clipClient = new cast.framework.messages.BreakClip('bc_client');
clipClient.title = 'The Ad Title to be displayed during playback';
clipClient.contentId = 'https://example.com/ad.m3u8';
clipClient.contentType = 'application/vnd.apple.mpegurl';

// Optional: Used when HLS ad container formats differ from the main content's.
clipClient.hlsSegmentFormat = cast.framework.messages.HlsSegmentFormat.FMP4;

// Create the Break using the BreakClip id above.
let breakPostrollClient = new cast.framework.messages.Break(
    'break_postroll_client', ['bc_client'], -1);
breakPostrollClient.isEmbedded = false; // Optional: default is false.
breakPostrollClient.expanded = false; // Optional: default is false.

VAST

O SDK do receptor da Web é compatível com a adição de anúncios VAST (Modelo de veiculação de anúncio em vídeo) padrão do IAB. Quando fornecido, o modelo XML é analisado para gerar um clipe de interrupção agrupado pelo cliente subsequente ao inserir o intervalo.

Para criar um anúncio VAST, o app receptor precisa criar um VastAdsRequest e especificá-lo na propriedade BreakClip vastAdsRequest. O objeto VastAdsRequest precisa ter a propriedade adsResponse (uma representação de string do próprio modelo XML) ou adTagUrl (o URL em que o modelo XML está hospedado) definido. Se o URL for especificado, o SDK processará a busca do modelo. O encapsulamento Break segue as convenções para anúncios agrupados pelo cliente. Eles podem ser adicionados junto com outros anúncios manualmente agrupados pelo cliente no mesmo intervalo ou em intervalos separados para o mesmo conteúdo. O exemplo abaixo mostra uma implementação básica de um anúncio VAST:

// Create the VastAdsRequest.
let vastTemplate = new cast.framework.messages.VastAdsRequest();
vastTemplate.adTagUrl = 'https://example.com/ads.xml'

// Create the BreakClip.
let clipVast = new cast.framework.messages.BreakClip('bc_vast');
clipVast.vastAdsRequest = vastTemplate;

// Create the Break using the BreakClip id above.
let breakPostrollVast = new cast.framework.messages.Break(
    'break_postroll_vast', ['bc_vast'], -1);
breakPostrollVast.isEmbedded = false; // Optional: default is false.
breakPostrollVast.expanded = false; // Optional: default is false.

Quando um Break contendo um BreakClip de VAST é inserido, o SDK do receptor da Web pode buscar e analisar o modelo. Durante a análise, o SDK gera uma nova BreakClip e a preenche com os valores extraídos do modelo, como contentId, contentType, title, duration, whenSkippable e clickThroughUrl. O id do clipe de intervalo gerado é definido como GENERATED:N, em que N é um número inteiro que incrementa em 1 para cada novo clipe de intervalo VAST criado a partir de 0. O anúncio gerado é adicionado à matriz BreakClip. O id de cada clipe de intervalo VAST no Break atual é substituído pelo id do clipe de intervalo gerado correspondente. Os snippets abaixo ilustram as mudanças nas mensagens MEDIA_STATUS relacionadas aos anúncios antes e depois de uma pausa como essa.

Observação: as matrizes BreakClip e Break são atualizadas e podem ser acessadas em BreakManager. Essas informações são incorporadas ao MEDIA_STATUS, que é transmitido aos remetentes.

Informações de Break e BreakClip antes de inserir uma pausa com anúncios VAST.

"breaks": [
  {
    "id": "break_postroll_vast",
    "breakClipIds": [
      "bc_vast"
    ],
    "position": 0,
    "isWatched": false
  }
],
"breakClips": [
  {
    "id": "bc_vast"
  }
]

Informações de Break e BreakClip após inserir uma pausa com anúncios VAST.

"breaks": [
  {
    "id": "break_postroll_vast",
    "breakClipIds": [
      "GENERATED:0"
    ],
    "position": 0,
    "isWatched": true
  }
],
"breakClips": [
  {
    "id": "bc_vast"
  },
  {
    "id": "GENERATED:0",
    "contentId": "https://example.com/break-clip-1.mpd",
    "contentType": "application/dash+xml",
    "title": "Ad Title Extracted from Template",
    "duration": 10,
    "whenSkippable": 5,
    "clickThroughUrl": "https://example.com/ad-target"
  }
]

VMAP

O SDK do receptor da Web é compatível com o padrão VMAP (playlists de vários anúncios em vídeo) do IAB. Quando um VMAP é fornecido, o SDK do receptor da Web analisa a resposta VMAP e gera objetos Break acoplados pelo cliente para todas as entradas <AdBreak> na resposta. Ele também gera o BreakClips apropriado com um objeto vastAdsRequest para cada entrada <AdSource> fornecida no VMAP. Para ativar o VMAP para a inserção de anúncios no conteúdo, o aplicativo precisa criar um objeto VastAdsRequest e atribuí-lo à propriedade vmapAdsRequest do MediaInformation em LoadRequestData. Esses anúncios precisam ser inseridos estaticamente. Saiba mais na seção Inserção de anúncios. Confira abaixo um snippet que descreve a criação de uma solicitação VMAP.

Observação :a definição manual de anúncios Break e BreakClip com anúncios VMAP substitui a solicitação de anúncio VMAP. Como resultado, o SDK vai descartar a solicitação de anúncio VMAP e, por padrão, usará os anúncios especificados manualmente em MediaInformation.

// Create the VastAdsRequest.
let vastTemplate = new cast.framework.messages.VastAdsRequest();
vastTemplate.adTagUrl = 'https://example.com/vmap.xml'

// Add it to the MediaInformation of the LoadRequest.
loadRequestData.media.vmapAdsRequest = vastTemplate;

incorporado

O intervalo de anúncio incorporado é um tipo de intervalo de anúncio costurado do lado do servidor no stream do conteúdo principal. A duração de Break é subtraída da duração do conteúdo principal ao calcular o tempo de mídia.

O BreakClip precisa fornecer o duration do conteúdo do anúncio e o title. O Break precisa ter isEmbedded definido como true e expanded definido como false. O position pode ser definido como um intervalo de anúncio precedente ou intermediário. Os intervalos de anúncios finais são compatíveis com valores exatos positivos de position. Saiba mais sobre isso na seção de posicionamento de intervalo. Quando o anúncio é acionado para reprodução, o SDK do receptor da Web continua a reprodução do stream à medida que os segmentos de anúncio são incorporados a ele. Não há mecanismo de carregamento adicional para esse tipo de anúncio. Os metadados do anúncio relevantes são mostrados ao usuário quando o marcador está no intervalo do intervalo. Esses intervalos exigem um embedded timeline e precisam ser adicionados estaticamente. Saiba mais na seção sobre inserção de anúncios. O exemplo abaixo mostra uma implementação básica de um anúncio embedded.

// Create the BreakClip.
let clipEmbedded = new cast.framework.messages.BreakClip('bc_embedded');
clipEmbedded.title = 'The Ad Title to be displayed during playback';
clipEmbedded.duration = 15;

// Create the Break using the BreakClip id above.
let breakPrerollEmbedded = new cast.framework.messages.Break(
    'break_preroll_embedded', ['bc_embedded'], 0);
breakPrerollEmbedded.isEmbedded = true;
breakPrerollEmbedded.expanded = false; // Optional: default is false.

incorporado expandido

O intervalo de anúncio expandido incorporado é um tipo de intervalo de anúncio colocado no servidor no stream do conteúdo principal. A duração do Break é incluída na duração do conteúdo principal ao calcular o tempo de mídia.

O BreakClip precisa fornecer o duration do conteúdo do anúncio e o title. O Break precisa ter isEmbedded definido como true e expanded definido como true. O position pode ser definido como um intervalo de anúncio precedente ou intermediário. Os intervalos de anúncios finais são compatíveis com valores position positivos. Saiba mais sobre isso na seção de posicionamento de intervalo. Quando o anúncio é acionado para reprodução, o SDK do receptor da Web continua a reprodução do stream à medida que os segmentos de anúncio são incorporados a ele. Não há mecanismo de carregamento adicional para esse tipo de anúncio. Os metadados do anúncio relevantes são mostrados ao usuário quando o marcador está no intervalo do intervalo. Esses intervalos exigem um embedded timeline e podem ser adicionados estaticamente ou dinamicamente. Saiba mais na seção Inserção de anúncios. O exemplo abaixo mostra uma implementação básica de um anúncio embedded expanded:

// Create the BreakClip.
let clipEmbeddedExpanded =
    new cast.framework.messages.BreakClip('bc_embedded_expanded');
clipEmbeddedExpanded.title = 'The Ad Title to be displayed during playback';
clipEmbeddedExpanded.duration = 15;

// Create the Break using the BreakClip id above.
let breakPrerollEmbeddedExpanded = new cast.framework.messages.Break(
    'break_preroll_embedded_expanded', ['bc_embedded_expanded'], 0);
breakPrerollEmbeddedExpanded.isEmbedded = true;
breakPrerollEmbeddedExpanded.expanded = true;

Tipos de linha do tempo do jogador

Ao criar uma instância de player, o SDK do receptor da Web seleciona um tipo de linha do tempo para oferecer suporte à reprodução de anúncios durante a reprodução do conteúdo. Cada linha do tempo permite que determinados tipos de intervalo de anúncio sejam adicionados. O tipo de cronograma é determinado pelos tipos de anúncios presentes durante o tempo de carregamento na MediaInformation do LoadRequestData. Se houver intervalos de anúncio incorporados, o cronograma embedded será selecionado. Se houver intervalos de anúncios agrupados pelo cliente, o cronograma stitched será selecionado. Caso não haja anúncios, o SDK usará a linha do tempo embedded por padrão. Depois de selecionada, a linha do tempo não pode ser modificada para o item de mídia atual. A tabela abaixo fornece uma descrição detalhada de cada linha do tempo.

Tipo de linha do tempo	Descrição
Linha do tempo incorporada	Uma representação do tempo de mídia que oferece suporte a anúncios incorporados ao conteúdo principal (intervalos de anúncios incorporados e expandidos). Quando há um intervalo de anúncio não expandido, a duração dele é subtraída da duração total do conteúdo. Por outro lado, quando um intervalo de anúncio expandido está presente, o tempo dele é considerado parte do conteúdo principal.
linha do tempo agrupada	Uma representação do tempo de mídia compatível com anúncios provenientes de arquivos de mídia externos (intervalos de anúncios agrupados manualmente pelo cliente, VAST e VMAP). Quando adicionado, a duração do intervalo de anúncio não faz parte da duração do conteúdo principal.

As Figuras 1 a 3 abaixo ilustram alguns conteúdos com vários tipos de anúncios e os respectivos valores de cronograma. O conteúdo é configurado com uma pausa de anúncio precedente que contém dois clipes de intervalos e intervalos de anúncio intermediário e anúncio final com um único clipe de intervalo. O tempo decorrido desde o início da reprodução do conteúdo, o tempo de mídia do conteúdo principal e o horário do intervalo em reprodução do clipe estão alinhados abaixo de cada figura.

Figura 1: a linha do tempo que representa parte do conteúdo e os três intervalos de anúncio agrupados pelo cliente.

Figura 2: a linha do tempo que representa parte do conteúdo e os três intervalos de anúncio incorporados e integrados pelo servidor.

Figura 3: a linha do tempo que representa parte do conteúdo e os três intervalos de anúncios expandidos incorporados agrupados pelo servidor.

Posição de intervalo

O SDK do receptor da Web permite que os desenvolvedores especifiquem onde os intervalos de anúncio precisam ser posicionados definindo a propriedade position do Break. Esse valor corresponde ao tempo de mídia do conteúdo principal e pode ser usado para criar intervalos de anúncio pre-roll, mid-roll e post-roll. Eles são definidos da seguinte maneira:

Posição de intervalo	Descrição
anúncio precedente	Um intervalo de anúncio reproduzido antes do conteúdo principal. Isso é indicado ao definir breakPosition como 0.
anúncio intermediário	Um intervalo de anúncio reproduzido no meio do conteúdo. Isso é denotado ao definir o breakPosition como um horário em que o início da pausa é maior que o início do conteúdo principal e o horário de término do intervalo é menor que o horário de término do conteúdo principal.
anúncio final	Um intervalo de anúncio reproduzido após o conteúdo principal. Isso é indicado ao definir breakPosition como -1 para linhas do tempo agrupadas. Para linhas do tempo incorporadas, o breakPosition precisa ser definido como a duração do conteúdo principal subtraída pela duração da pausa. Indisponível para conteúdo ao vivo.

Matriz de interoperabilidade

Como ponto de referência rápido, a Tabela 1 mostra uma visão geral dos tipos de anúncio e a compatibilidade deles com os recursos relacionados a anúncios.

Tabela 1: matriz de interoperabilidade de anúncios

Suporte a recursos	anúncio manual integrado pelo cliente	VAST	VMAP	anúncio incorporado	anúncio expandido incorporado
compatível com	VAST	feita manualmente pelo cliente	N/A	incorporado expandido	incorporado
barra de tempo	costurado	costurado	costurado	incorporado	incorporado
inserção de anúncios	static	static	static	static	estático, dinâmico
remoção de anúncios
anúncio precedente
anúncio intermediário
anúncio final
anúncio pulado
interceptador de busca por quebra
interceptador de carga de clipe

Eventos

Quando ocorrem eventos de quebra de tecla, o SDK de transmissão envia eventos do tipo BreaksEvent. Um app receptor pode se inscrever neles usando a API PlayerManager addEventListener.

Esses eventos podem ser usados para análise e rastreamento de reprodução de anúncios. Quando os anúncios VMAP (playlist de vários anúncios em vídeo) e VAST (modelo de veiculação de anúncio em vídeo) são usados, todos os eventos de acompanhamento padrão fornecidos nas respostas são enviados automaticamente pelo SDK.

Os tipos de evento estão listados na Tabela 2 com uma descrição detalhada sobre quando são disparados.

Figura 4: ciclo de vida dos eventos de interrupção.

Tabela 2: eventos de interrupção e as descrições deles.

Evento de intervalo	Descrição
BREAK_STARTED	Disparado quando o tempo de mídia atual do conteúdo principal é igual ao position de um intervalo não assistido.
BREAK_CLIP_LOADING	Disparado somente quando um clipe de intervalo da linha do tempo agrupada começa a ser carregado.
BREAK_CLIP_STARTED	Disparado quando a reprodução de um clipe de intervalo é iniciada.
BREAK_CLIP_ENDED	Disparado quando um clipe de intervalo termina. O campo endedReason será preenchido nas seguintes circunstâncias: Um clipe de intervalo da linha do tempo agrupado foi reproduzido por completo. Um clipe de intervalo da linha do tempo agrupados faz a transição para outro clipe de intervalo. Os clipes de intervalo são ignorados. O último clipe de intervalo reproduzido inteiramente em um intervalo incorporado de anúncio final. Ocorreu um erro.
BREAK_ENDED	Disparado quando o último clipe de intervalo de um intervalo termina.

Inserção de anúncios

O SDK de transmissão permite que os aplicativos insiram e removam anúncios em diferentes momentos de uma sessão de transmissão. Os dois tipos de inserção de anúncios são estáticas e dinâmicas. A inserção de anúncios estáticos exige que eles sejam especificados no LoadRequestData antes da criação do player. A inserção de anúncios dinâmicos usa a API BreakManager addBreak para inserir intervalos no conteúdo já carregado. Cada método de inserção é compatível com determinados tipos de anúncio. Uma visão geral da compatibilidade é fornecida na matriz de interoperabilidade.

Inserção de anúncios estáticos

A inserção de anúncios estáticos é caracterizada pela adição dos metadados de anúncios relevantes antes da criação do player. Esta informação é fornecida no MediaInformation do LoadRequestData. Por exemplo, isso pode ser definido na solicitação de carregamento original de um remetente conectado ou inserido pelo aplicativo receptor da Web interceptando a solicitação LOAD. Quando o LoadRequestData é retornado ao SDK do receptor da Web para processamento, o player é criado. Veja mais sobre como carregar mídia. O exemplo abaixo mostra um anúncio manual incluído pelo cliente sendo adicionado ao interceptador da solicitação LOAD.

const context = cast.framework.CastReceiverContext.getInstance();
const playerManager = context.getPlayerManager();

playerManager.setMessageInterceptor(
    cast.framework.messages.MessageType.LOAD, loadRequestData => {

  // Create the BreakClip.
  let clipClient = new cast.framework.messages.BreakClip('bc_client');
  clipClient.title = 'The Ad Title to be displayed during playback';
  clipClient.contentId = 'https://example.com/ad.mp4';
  clipClient.contentType = 'video/mp4';

  // Create the Break using the BreakClip id above.
  let breakPostrollClient = new cast.framework.messages.Break(
      'break_postroll_client', ['bc_client'], -1);

  // Set the ad information in the load request data.
  let media = loadRequestData.media;
  media.breakClips = [clipClient];
  media.breaks = [breakPostrollClient];

  return loadRequestData;
});

Inserção de anúncios dinâmicos

A Inserção de anúncios dinâmicos é caracterizada pela definição de um intervalo de anúncio durante a reprodução do conteúdo. Para fazer isso, receba uma instância de BreakManager e chame a API addBreak. Isso usa no mínimo dois parâmetros, uma Break expandida incorporada e uma matriz de BreakClip. Uma terceira propriedade opcional é incluída para forçar o envio das mudanças para remetentes conectados por uma transmissão MediaStatus quando definida como true. Ao adicionar quebras e clipes de quebra, os IDs correspondentes precisam ser exclusivos. Esses anúncios só podem ser adicionados depois que o player é criado. O SDK do receptor da Web dispara o evento PLAYER_LOADING quando o player é criado. Veja o exemplo abaixo que mostra o uso em um manipulador de eventos que responde a alterações nos metadados ID3 de um stream e cria objetos Break e BreakClip para inseri-los na linha do tempo.

const context = cast.framework.CastReceiverContext.getInstance();
const playerManager = context.getPlayerManager();
const breakManager = playerManager.getBreakManager();

playerManager.addEventListener(cast.framework.events.EventType.ID3, (event) => {

  // Create the BreakClip.
  let clipEmbeddedExpanded = parseBreakClipFromData(event.segmentData);
  let breakEmbeddedExpanded = parseExpandedBreakFromData(event.segmentData);

  // Add the break and break clip.
  breakManager.addBreak(breakEmbeddedExpanded, [clipEmbeddedExpanded]);
});

Remoção de anúncios dinâmicos

Para remover as pausas dinâmicas, o aplicativo precisa chamar removeBreakById durante a reprodução. A função recebe um identificador de string da pausa a ser removida da linha do tempo. O breakId especificado precisa apontar para um intervalo de anúncio expandido incorporado. Se qualquer outro tipo de intervalo de anúncio for detectado, ele permanecerá na linha do tempo. Veja o exemplo abaixo que remove uma pausa.

const context = cast.framework.CastReceiverContext.getInstance();
const playerManager = context.getPlayerManager();
const breakManager = playerManager.getBreakManager();

breakManager.removeBreakById('break_midroll_embedded_expanded');

Comportamento das pausas

O SDK define um comportamento padrão para quando o jogador entra e sai de intervalos e oferece uma maneira de personalizá-lo ainda mais usando algumas das APIs fornecidas em BreakManager.

Comportamento de interrupção padrão

Quando um Break é inserido por reprodução normal ou buscando um Break, o SDK avalia se o usuário já o viu verificando a propriedade isWatched. Quando criado, o valor padrão de uma pausa para essa propriedade é false. Se a propriedade for true, o intervalo não será reproduzido quando inserido, e o conteúdo principal continuará sendo reproduzido. Se a propriedade for false, a pausa será reproduzida quando inserida.

Observação: para intervalos de anúncios na linha do tempo incorporada, o SDK vai buscar a duração de um intervalo assistido pelo usuário para retomar a reprodução do conteúdo principal.

Ao buscar intervalos passados, a implementação padrão extrai todos os itens Break em que position está entre os valores seekFrom e seekTo da operação de busca. Nessa lista de intervalos, o SDK reproduzirá a Break em que o position está mais próximo do valor seekTo e com a propriedade isWatched definida como false. A propriedade isWatched desse intervalo será definida como true, e o jogador vai começar a reproduzir os clipes de intervalo. Quando a pausa for assistida, o conteúdo principal vai retomar a reprodução na posição seekTo. Se não houver uma pausa, nenhuma interrupção será reproduzida, e a reprodução do conteúdo principal será retomada na posição seekTo.

Durante a reprodução de intervalo, o SDK vai transmitir todas as atualizações relevantes aos aplicativos de remetente conectados na MediaStatus. Esses apps vão usar as transmissões para atualizar a interface para anúncios lendo a propriedade breakStatus. Esta propriedade é definida somente durante a interrupção da reprodução.

Observação: os aplicativos receptores podem se inscrever em eventos PlayerManager MEDIA_STATUS para monitorar as mudanças no MediaStatus.

Os aplicativos receptores também podem consultar diretamente informações relacionadas à posição do marcador em relação ao tempo atual do BreakClip mostrado chamando PlayerManager getBreakClipCurrentTimeSec. Da mesma forma, os aplicativos podem consultar a duração da BreakClip atual chamando getBreakClipDurationSec.

Comportamento de intervalo personalizado

O comportamento padrão para clipes de intervalos e intervalos pode ser modificado usando os métodos setBreakClipLoadInterceptor e setBreakSeekInterceptor fornecidos em BreakManager.

Observação: se estiver executando uma operação de busca após a conclusão de uma pausa, verifique se o playerState do objeto MediaStatus mudou para PLAYING antes de realizar a operação de busca.

Interceptador de busca por Break

O interceptador de busca de intervalo permite que o app controle o comportamento da busca por intervalos de anúncio. A função é acionada quando é solicitada uma operação de busca que avança ou retrocede em um ou mais intervalos. Quando chamado, o BreakSeekData é transmitido como um parâmetro para a função de callback. O objeto BreakSeekData contém uma matriz de objetos Break com a propriedade position definida como um número entre o tempo do marcador atual definido como seekFrom e o tempo de destino da busca seekTo.

Esse interceptador permite que os objetos Break nos respectivos intervalos sejam modificados. Quando implementado, o interceptador de busca de intervalo precisa especificar quais intervalos de anúncio serão reproduzidos retornando um objeto BreakSeekData opcional. O jogador vai continuar a reproduzir todos os intervalos incluídos no valor de retorno. Se um valor de null ou nada for retornado do interceptador de busca de interrupção, a quebra será ignorada.

Observação: definir o interceptador de busca de interrupção substitui o comportamento padrão. Isso inclui recursos como pular intervalos já assistidos. Para personalizar o comportamento de busca de intervalos e não reproduzir os intervalos assistidos, o aplicativo vai precisar especificar essa lógica no interceptador de busca de intervalo, verificando a propriedade isWatched de um Break. O SDK vai processar a configuração da propriedade isWatched quando uma pausa for inserida, independente do uso do interceptador de intervalo de busca.

O exemplo abaixo mostra uma implementação simples do interceptador, que substitui o comportamento padrão para assistir todos os intervalos de anúncios buscados, com exceção dos intervalos já assistidos.

const context = cast.framework.CastReceiverContext.getInstance();
const playerManager = context.getPlayerManager();
const breakManager = playerManager.getBreakManager();

breakManager.setBreakSeekInterceptor((breakSeekData) => {

  // Filter the breaks array by removing watched breaks.
  const unwatchedBreaks =
      breakSeekData.breaks.filter(adBreak => !adBreak.isWatched);
  breakSeekData.breaks = unwatchedBreaks;

  return breakSeekData;
});

Interceptor de carga do clipe

Ao usar o interceptador de carga de clipe de interrupção, um objeto BreakClip pode ser modificado antes do início da reprodução.

O interceptador de carga do clipe de interrupção é chamado apenas para intervalos da linha do tempo agrupados e pode ser definido usando setBreakClipLoadInterceptor. Antes de inserir um Break, esse interceptador é chamado uma vez para cada BreakClip individual definido nesse intervalo. O SDK transmite o objeto BreakClip original como um parâmetro da função de callback. O aplicativo pode modificar esse BreakClip e retorná-lo para que o SDK possa buscar e exibir o clipe de interrupção com a configuração atualizada. Se null ou nada for retornado, o clipe de interrupção será ignorado.

Observação: se houver um intervalo de anúncio precedente, o interceptador de carregamento do clipe de intervalo será chamado para o intervalo do anúncio precedente assim que a reprodução começar. Imediatamente após o intervalo do anúncio precedente, o interceptador da carga do clipe de intervalo para o próximo intervalo é chamado, se existir.

Veja abaixo um exemplo que modifica a contentUrl dos clipes de interrupção com uma chamada de função utilitária getUrlFromClipId, em que o id do BreakClip é mapeado para um URL.

const context = cast.framework.CastReceiverContext.getInstance();
const playerManager = context.getPlayerManager();
const breakManager = playerManager.getBreakManager();

breakManager.setBreakClipLoadInterceptor(
    (breakClip, breakClipLoadInterceptorContext) => {

  // Obtains the URL of a break clip id from a function call.
  breakClip.contentUrl = getUrlFromClipId(breakClip.id);

  return breakClip;
});

Ignorar anúncio

O SDK do receptor da Web fornece APIs para pular intervalos de anúncio e clipes de intervalo individuais em um intervalo de anúncio. O SDK também permite que os usuários pulem clipes de interrupção interagindo com os aplicativos emissores ou dispositivos smart display.

Clipes de intervalo puláveis do usuário

A definição de clipes de intervalo como puláveis permite que os usuários interajam com os aplicativos de envio conectados e os dispositivos de smart display para pular o restante de um clipe de intervalo em reprodução no momento. Definir a propriedade whenSkippable como um número não negativo de segundos vai ativar esse recurso para o objeto BreakClip. O player vai considerar o clipe de intervalo pulável quando ele é reproduzido durante esse número de segundos. Definir esse valor como 0 permite que os usuários pulem o clipe de intervalo imediatamente.

// Create the BreakClip.
let clip = new cast.framework.messages.BreakClip('bc');
clip.title = 'The Ad Title to be displayed during playback';
clip.whenSkippable = 10; // Users can skip the clip after 10 seconds of playback.

Essas informações podem ser definidas na solicitação de carregamento original do remetente ou no app receptor. Quando ignorado, um clipe de intervalo em um intervalo de anúncio linha do tempo agrupadas para de reproduzir o clipe de intervalo atual. O player carrega o próximo clipe de intervalo, se presente, ou o conteúdo principal. Quando ignorado, um clipe de intervalo em uma linha do tempo incorporada vai buscar o fim do clipe e continuar a reprodução do stream nesse ponto.

Observação: além de implementar o snippet acima, os aplicativos do Web Sender precisam adicionar request logic para permitir que um usuário pule um anúncio. Isso não é necessário em plataformas de remetentes móveis, porque a funcionalidade é fornecida pelo SDK.

Como pular anúncios de forma programática

Os anúncios também podem ser pulados automaticamente sem qualquer interação do usuário.

Para pular toda a pausa da reprodução, um aplicativo precisa definir a propriedade isWatched de um Break como true. Isso pode ser feito a qualquer momento durante a sequência de carregamento ou a reprodução do conteúdo. A propriedade isWatched é avaliada pelo jogador quando o position de uma pausa é alcançado no horário atual do conteúdo principal. Nesse momento, o jogador vai determinar se uma pausa precisa ser feita. O exemplo abaixo faz um loop em todos os intervalos e modifica o valor quando o player está carregando.

const context = cast.framework.CastReceiverContext.getInstance();
const playerManager = context.getPlayerManager();
const breakManager = playerManager.getBreakManager();

playerManager.addEventListener(cast.framework.events.EventType.PLAYER_LOADING,
    (event) => {

  // Obtain the breaks and iterate through each item to skip all ad breaks.
  let breaks = breakManager.getBreaks();
  breaks.forEach((brk) => {
    brk.isWatched = true;
  });
});

Para pular um clipe de intervalo específico de forma programática, o interceptador de carga do clipe de interrupção precisa ser usado. Ao retornar null ou não retornar um valor na função de callback, o clipe nessa intervalo será ignorado.

Observação: o interceptador de carga do clipe de intervalo é chamado apenas para quebras da linha do tempo agrupadas. Se você quiser pular intervalos em uma linha do tempo incorporada, confira a remoção de anúncios dinâmicos.

const context = cast.framework.CastReceiverContext.getInstance();
const playerManager = context.getPlayerManager();
const breakManager = playerManager.getBreakManager();

breakManager.setBreakClipLoadInterceptor(
      (breakClip, breakClipLoadInterceptorContext) => {
  return null;
});