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
.
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.
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.
// 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.
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.
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.
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:
|
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.
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.
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
.
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.
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.
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.
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.
const context = cast.framework.CastReceiverContext.getInstance();
const playerManager = context.getPlayerManager();
const breakManager = playerManager.getBreakManager();
breakManager.setBreakClipLoadInterceptor(
(breakClip, breakClipLoadInterceptorContext) => {
return null;
});