Selecione a solução de DAI do seu interesse
DAI de veiculação de conjuntos
Os SDKs do IMA simplificam a integração de anúncios multimídia nos seus sites e apps.
Os SDKs do IMA podem solicitar anúncios de qualquer servidor de anúncios compatível com VAST (em inglês) e gerenciar a reprodução de anúncios nos seus apps.
Com os SDKs de DAI do IMA, os apps fazem uma solicitação de stream para anúncios e conteúdo de vídeo para VOD ou conteúdo ao vivo. Em seguida, o SDK retorna um stream de vídeo combinado para que você não precise gerenciar a alternância entre anúncios e vídeos de conteúdo no app.
Este guia demonstra como reproduzir um stream de Veiculação de conjunto DAI ao vivo usando o SDK de DAI do IMA para CAF.
Antes de usar este guia, familiarize-se com o protocolo Receptor da Web do framework de aplicativo do Chromecast. Para emular um remetente de CAF, é necessário ter conhecimento básico dos conceitos de receptor CAF, como interceptadores de mensagens e objetos mediaInformation, e familiaridade com o uso da ferramenta de comando e controle do Cast.
Para usar a veiculação de conjunto de DAI do IMA, você precisa trabalhar com um parceiro de veiculação de conjunto e ter uma conta Ad Manager 360 Advanced. Se você tiver uma conta do Ad Manager, entre em contato com o gerente da conta para mais detalhes. Para informações sobre como se inscrever no Ad Manager, acesse a Central de Ajuda do Ad Manager.
Para informações sobre como integrar com outras plataformas ou usar os SDKs do lado do cliente do IMA, consulte SDKs do Interactive Media Ads (link em inglês).
Visão geral da veiculação de conjunto DAI do IMA
A implementação da veiculação de pods usando o SDK de DAI do CAF do IMA envolve dois componentes principais, demonstrados neste guia:
StreamRequest: um objeto que define uma solicitação de stream para os servidores de publicidade do Google. As solicitações especificam um código de rede, uma chave de recurso personalizada e uma chave de API opcional, além de outros parâmetros opcionais.StreamManager: um objeto que processa a comunicação entre o stream de vídeo e o SDK de DAI do IMA, como disparar pings de rastreamento e encaminhar eventos de stream para o editor.
Pré-requisitos
- Uma conta do Console para desenvolvedores do Google Cast com dispositivos de teste registrados.
- Um app receptor da Web hospedado registrado no seu Play Console do Google Cast e que pode ser modificado para hospedar o código fornecido por este guia.
- Um app de envio configurado para usar seu app receptor da Web. Para os fins deste exemplo, use a ferramenta de comando e controle do Cast como remetente.
Configurar os objetos MediaInfo do remetente
Primeiro, configure o
objeto MediaInfo
do app remetente para incluir os seguintes campos:
| Field | Conteúdo | ||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|
contentId
|
Um identificador exclusivo para este item de mídia.
CONTENT_ID |
||||||||||
contentUrl
|
Opcional. URL do stream de backup a ser reproduzido se o stream da DAI não for carregado.
BACKUP_STREAM_URL |
||||||||||
contentType
|
Opcional. Tipo MIME dos streams de backup do conteúdo. Necessário apenas para streams DASH.
CONTENT_STREAM_MIMETYPE |
||||||||||
streamType
|
O literal ou a constante de string usado para esse valor varia de acordo com a plataforma do remetente. | ||||||||||
customData
|
O campo customData contém um armazenamento de chave-valor de outros campos obrigatórios.
|
Aqui estão alguns exemplos de código para ajudar você a começar:
Web
Para configurar esses valores em um remetente da Web do Cast, primeiro crie um objeto
MediaInfo
com os dados necessários e depois faça uma solicitação
de carregamento ao receptor da Web.
// Create mediaInfo object
const mediaInfo = new chrome.cast.media.MediaInfo("CONTENT_ID");
mediaInfo.contentUrl = "BACKUP_STREAM_URL";
mediaInfo.contentType = "CONTENT_STREAM_MIMETYPE";
mediaInfo.streamType = chrome.cast.media.StreamType.LIVE;
mediaInfo.customData = {
manifestUrl: "MANIFEST_URL",
networkCode: "NETWORK-CODE",
customAssetKey: "CUSTOM_ASSET_KEY",
apiKey: "API_KEY"
};
// Make load request to cast web receiver
const castSession = cast.framework.CastContext.getInstance().getCurrentSession();
const request = new chrome.cast.media.LoadRequest(mediaInfo);
castSession.loadMedia(request).then(
() => { console.log('Load succeed'); },
(errorCode) => { console.log('Error code: ' + errorCode); });
Android
Para configurar esses valores em um remetente da Web do Cast, primeiro crie um objeto MediaInfo com os dados necessários e depois faça uma solicitação de carregamento ao receptor da Web.
JSONObject customData = new JSONObject()?
.put("manifestUrl", "MANIFEST_URL")
.put("networkCode", "NETWORK-CODE")
.put("customAssetKey", "CUSTOM_ASSET_KEY")
.put("apiKey", "API_KEY");
MediaInfo mediaInfo = MediaInfo.Builder("CONTENT_ID")
.setContentUrl("BACKUP_STREAM_URL")
.setContentType("CONTENT_STREAM_MIMETYPE")
.setStreamType(MediaInfo.STREAM_TYPE_LIVE)
.setCustomData(customData)
.build();
RemoteMediaClient remoteMediaClient = mCastSession.getRemoteMediaClient();
remoteMediaClient.load(new MediaLoadRequestData.Builder().setMediaInfo(mediaInfo).build());
iOS (Obj-C)
Para configurar esses valores em um remetente da Web do Cast, primeiro crie um objeto
GCKMediaInformation
com os dados necessários e depois faça uma solicitação
de carregamento ao receptor da Web.
NSURL url = [NSURL URLWithString:@"BACKUP_STREAM_URL"];
NSDictionary *customData = @{
@"manifestUrl": @"MANIFEST_URL",
@"networkCode": @"NETWORK-CODE",
@"customAssetKey": @"CUSTOM_ASSET_KEY",
@"apiKey": @"API_KEY"};
mediaInfoBuilder.customData = customData;
GCKMediaInformationBuilder *mediaInfoBuilder =
[[GCKMediaInformationBuilder alloc] initWithContentID: @"CONTENT_ID"];
mediaInfoBuilder.contentURL = url;
mediaInfoBuilder.contentType = @"CONTENT_STREAM_MIMETYPE";
mediaInfoBuilder.streamType = GCKMediaStreamTypeLive;
mediaInfoBuilder.customData = customData;
self.mediaInformation = [mediaInfoBuilder build];
GCKRequest *request = [self.sessionManager.currentSession.remoteMediaClient loadMedia:self.mediaInformation];
if (request != nil) {
request.delegate = self;
}
iOS (Swift)
Para configurar esses valores em um remetente da Web do Cast, primeiro crie um objeto
GCKMediaInformation
com os dados necessários e depois faça uma solicitação
de carregamento ao receptor da Web.
let url = URL.init(string: "BACKUP_STREAM_URL")
guard let mediaURL = url else {
print("invalid mediaURL")
return
}
let customData = [
"liveConfigID": "MANIFEST_URL",
"networkCode": "NETWORK-CODE",
"customAssetKey": "CUSTOM_ASSET_KEY",
"region": "API_KEY"
]
let mediaInfoBuilder = GCKMediaInformationBuilder.init(contentId: "CONTENT_ID")
mediaInfoBuilder.contentURL = mediaUrl
mediaInfoBuilder.contentType = @"CONTENT_STREAM_MIMETYPE"
mediaInfoBuilder.streamType = GCKMediaStreamType.Live
mediaInfoBuilder.customData = customData
mediaInformation = mediaInfoBuilder.build()
guard let mediaInfo = mediaInformation else {
print("invalid mediaInformation")
return
}
if let request = sessionManager.currentSession?.remoteMediaClient?.loadMedia
(mediaInfo) {
request.delegate = self
}
Ferramenta CAC
Para configurar esses valores na ferramenta de comando e controle do Cast, clique na guia "Carregar mídia" e defina o tipo de solicitação de carregamento personalizado como LOAD. Em seguida, substitua os dados JSON na área de texto por este JSON:
{
"media": {
"contentId": "CONTENT_ID",
"contentUrl": "BACKUP_STREAM_URL",
"contentType": ""CONTENT_STREAM_MIMETYPE"",
"streamType": "LIVE",
"customData": {
"liveConfigID": "MANIFEST_URL",
"networkCode": "NETWORK-CODE",
"customAssetKey": "CUSTOM_ASSET_KEY",
"oAuthToken": "API_KEY"
}
}
}
Essa solicitação de carregamento personalizada pode ser enviada ao destinatário para testar as outras etapas.
Criar um receptor CAF básico
Crie um receptor da Web personalizado conforme visto no Guia do receptor da Web personalizado do SDK CAF.
O código do receptor vai ficar assim:
<html>
<head>
<script
src="//www.gstatic.com/cast/sdk/libs/caf_receiver/v3/cast_receiver_framework.js">
</script>
</head>
<body>
<cast-media-player></cast-media-player>
<script>
// ...
</script>
</body>
</html>
Importar o SDK de DAI do IMA e acessar o Gerenciador de players
Adicione uma tag de script para importar o SDK de DAI do IMA para CAF para seu receptor da Web, logo após o carregamento do script CAF. Na tag script, armazene o contexto do receptor e o gerenciador do player como constantes antes de iniciar o receptor.
<html>
<head>
<script
src="//www.gstatic.com/cast/sdk/libs/caf_receiver/v3/cast_receiver_framework.js"></script>
<script src="//imasdk.googleapis.com/js/sdkloader/cast_dai.js"></script>
</head>
<body>
<cast-media-player></cast-media-player>
<script>
const castContext = cast.framework.CastReceiverContext.getInstance();
const playerManager = castContext.getPlayerManager();
castContext.start();
</script>
</body>
</html>
Inicializar o Gerenciador de streams do IMA
Inicialize o Gerenciador de streams do IMA.
<html>
<head>
<script type="text/javascript"
src="//www.gstatic.com/cast/sdk/libs/caf_receiver/v3/cast_receiver_framework.js"></script>
<script src="//imasdk.googleapis.com/js/sdkloader/cast_dai.js"></script>
</head>
<body>
<cast-media-player></cast-media-player>
<script>
const castContext = cast.framework.CastReceiverContext.getInstance();
const playerManager = castContext.getPlayerManager();
const streamManager = new google.ima.cast.dai.api.StreamManager();
castContext.start();
</script>
</body>
</html>
Criar o interceptador de carga do gerenciador de streams
Antes que os itens de mídia sejam transmitidos para o CAF, crie a solicitação de stream em um interceptor de mensagens LOAD.
const castContext = cast.framework.CastReceiverContext.getInstance();
const playerManager = castContext.getPlayerManager();
const streamManager = new google.ima.cast.dai.api.StreamManager();
/**
* Creates a livestream request object for a pod serving stream.
* @param {!LoadRequestData} castRequest The request object from the cast sender
* @return {StreamRequest} an IMA stream request
*/
const createStreamRequest = (castRequest) => { /* ... */};
/**
* Initates a DAI stream request for the final stream manifest.
* @param {!LoadRequestData} castRequest The request object from the cast sender
* @return {Promise<LoadRequestData>} a promise that resolves to an updated castRequest, containing the DAI stream manifest
*/
const createDAICastRequest = (castRequest) => {
return streamManager.requestStream(castRequest, createStreamRequest(castRequest))
.then((castRequestWithPodStreamData) => {
console.log('Successfully made DAI stream request.');
// ...
return castRequestWithPodStreamData;
})
.catch((error) => {
console.log('Failed to make DAI stream request.');
// CAF will automatically fallback to the content URL
// that it can read from the castRequest object.
return castRequest;
});
};
playerManager.setMessageInterceptor(
cast.framework.messages.MessageType.LOAD, createDAICastRequest);
castContext.start();
Criar a solicitação de stream
Conclua a função createStreamRequest para criar um fluxo de veiculação de pod com base na solicitação de carregamento do CAF.
/**
* Creates a livestream request object for a pod serving stream.
* @param {!LoadRequestData} castRequest The request object from the cast sender
* @return {StreamRequest} an IMA stream request
*/
const createStreamRequest = (castRequest) => {
const streamRequest = new google.ima.cast.dai.api.PodStreamRequest();
const customData = castRequest.media.customData;
streamRequest.customAssetKey = customData.customAssetKey;
streamRequest.networkCode = customData.networkCode;
streamRequest.apiKey = customData.apiKey;
return streamRequest;
};
Substituir o URL de conteúdo pelo URL do manifesto e pelo ID do fluxo
Se a solicitação de stream for bem-sucedida, use streamManager.getStreamId() para
extrair o ID do stream e inseri-lo no manifestUrl, substituindo
[[STREAMID]]. Em seguida, substitua o contentUrl atual pelo novo
manifestUrl para que o CAF reproduza a transmissão ao vivo com os conjuntos de anúncios agrupados.
/**
* Initates a DAI stream request for the final stream manifest.
* @param {!LoadRequestData} castRequest The request object from the cast sender
* @return {Promise<LoadRequestData>} a promise that resolves to an updated castRequest, containing the DAI stream manifest
*/
const createDAICastRequest = (castRequest) => {
return streamManager.requestStream(castRequest, createStreamRequest(castRequest))
.then((castRequestWithPodStreamData) => {
console.log('Successfully made DAI stream request.');
const media = castRequestWithPodStreamData.media;
const manifestUrl = media.customData.manifestUrl || "";
if (manifestUrl) {
console.log('Replacing the contentURL with the manifest URL and stream ID');
const streamId = streamManager.getStreamId();
castRequestWithPodStreamData.media.contentUrl = manifestUrl.replace('[[STREAMID]]', streamId);
return castRequestWithPodStreamData;
})
.catch((error) => {
console.log('Failed to make DAI stream request.');
// CAF will automatically fallback to the content URL
// that it can read from the castRequest object.
return castRequest;
});
};
Agora você pode solicitar e reproduzir streams de veiculação de pod com o framework de aplicativo de transmissão e o SDK de DAI do IMA para CAF.