Selecione a solução de DAI do seu interesse
DAI de veiculação de conjunto
Os SDKs do IMA simplificam a integração de anúncios multimídia nos seus sites e aplicativos.
Os SDKs do IMA podem solicitar anúncios de qualquer servidor compatível com VAST 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 de anúncio e vídeo de conteúdo para VOD ou ao vivo. Em seguida, o SDK retorna um stream de vídeo combinado para que você não precise alternar entre o anúncio e o conteúdo de vídeo no app.
Este guia demonstra como reproduzir um stream de veiculação de conjunto DAI ao vivo usando o SDK da DAI do IMA para CAF.
Antes de usar este guia, familiarize-se com o protocolo Receptor da Web do framework de aplicativos do Chromecast (em inglês). Este guia pressupõe um entendimento básico dos conceitos de receptor CAF, como interceptores de mensagens e objetos mediaInformation, e familiaridade com o uso da ferramenta Cast Command and Control para emular um remetente de CAF.
Para usar a veiculação de conjunto de DAI do IMA, é preciso trabalhar com um parceiro de veiculação de conjunto e ter uma conta do Ad Manager 360 Advanced. Se você tiver uma conta do Ad Manager, entre em contato com o gerente de contas 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 a integração com outras plataformas ou sobre o uso de SDKs do lado do cliente do IMA, consulte SDKs do Interactive Media Ads.
Visão geral da veiculação de conjunto de DAI do IMA
A implementação da veiculação de pods usando o SDK de DAI do IMA CAF envolve dois componentes principais, que são 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 gerencia a comunicação entre o stream de vídeo e o SDK de DAI do IMA, como disparo de pings de rastreamento e encaminhamento de eventos de stream para o editor.
Pré-requisitos
- Uma conta do Play Console do Google Cast com dispositivos de teste registrados.
- Um app de receptor da Web hospedado registrado no Console para desenvolvedores do Google Cast e que pode ser modificado para hospedar o código fornecido por este guia.
- Um app de envio configurado para usar o app receptor da Web. Para os fins deste exemplo, use a ferramenta Cast Command and Control como remetente.
Configurar os objetos MediaInfo do remetente
Primeiro, configure o
objeto MediaInfo
do app remetente para incluir os seguintes campos:
Campo | Conteúdo | ||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
contentId
|
Um identificador exclusivo para esse item de mídia.
CONTENT_ID |
||||||||||
contentUrl
|
Opcional. URL da transmissão de backup que será reproduzido se o stream da DAI não for carregado.
BACKUP_STREAM_URL |
||||||||||
contentType
|
Opcional. O tipo MIME dos streams de backup de 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 campos obrigatórios extras.
|
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 faça uma solicitação
de carregamento para o 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 faça uma solicitação de carregamento ao recebedor 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 faça uma solicitação
de carregamento para o 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 faça uma solicitação
de carregamento para o 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 Cast Command and Control, clique na guia "Load Media" 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 receptor para testar o restante das etapas.
Criar um receptor CAF básico
Crie um receptor da Web personalizado, conforme visto no Guia do receptor da Web personalizado do SDK da 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 player
Adicione uma tag de script a fim de importar o SDK de DAI do IMA para o CAF para seu receptor da Web, logo após o script carregar o CAF. Na tag de 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 seus itens de mídia sejam transmitidos para o CAF, crie sua solicitação de stream em um interceptador 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 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;
};
Substitua 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
recuperar o ID do stream e inseri-lo no manifestoUrl, substituindo
[[STREAMID]]
. Em seguida, substitua o contentUrl
existente 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 é possível solicitar e reproduzir streams de veiculação de pods com o framework do aplicativo do Google Cast e o SDK de DAI do IMA para CAF.