Começar a usar o SDK de DAI do IMA

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 Compatível com VAST servidor de anúncios e gerenciar a reprodução de anúncios nos seus aplicativos.

Com os SDKs de DAI do IMA, os apps fazem uma solicitação de stream para anúncios e vídeos de conteúdo para VOD ou conteúdo ao vivo. Em seguida, o SDK retorna um fluxo de vídeo combinado para que você não precisa gerenciar a alternância entre anúncios e conteúdo em vídeo nos seus app.

Este guia demonstra como reproduzir um stream de Veiculação de conjunto DAI ao vivo usando o SDK SDK de DAI para CAF.

Antes de usar este guia, você precisa conhecer Receptor da Web do framework de aplicativos do Chromecast protocolo. Este guia pressupõe uma compreensão básica dos conceitos do receptor CAF, como interceptadores de mensagens e mediaInformation e familiaridade com o uso dos Ferramenta de comando e controle do Cast, para emular um remetente de CAF.

Para usar a veiculação de conjunto de DAI do IMA, você precisa trabalhar com um parceiro desse tipo e precisa ter um Ad Manager 360 Advanced (em inglês) do Compute Engine. Se você tiver uma conta do Ad Manager, entre em contato com o gerente de contas do 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 o uso do SDK SDKs do lado do cliente, consulte SDKs do Interactive Media Ads.

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: 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 a DAI do IMA do SDK, como disparar pings de acompanhamento 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 receptor da Web hospedado app que é registrados no seu Console do desenvolvedor do Google Cast e que podem ser modificados para hospedar o código fornecido por este guia.
• Um app de envio configurado para usar seu app receptor da Web. Para o neste exemplo, use o comando e controle do Cast ferramenta como remetente.

Configurar os objetos MediaInfo do remetente

Primeiro, configure o endereço IP do app remetente Objeto MediaInfo inclua os seguintes campos:

Aqui estão alguns exemplos de código para ajudar você a começar:

// 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); });

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());

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;
}

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
}

{
  "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 carga personalizada pode ser enviada ao receptor para testar o restante etapas.

Criar um receptor CAF básico

Crie um receptor da Web personalizado, conforme mostrado no artigo Receptor da Web personalizado do SDK CAF Guia.

O código do seu 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 para importar o SDK de DAI do IMA para CAF ao seu receptor da Web. após o carregamento do script no CAF. Na tag script, armazene o contexto do receptor e 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 passados para o CAF, crie sua solicitação de stream em um LOAD mensagem interceptor.

    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 pods 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 recuperar o ID do fluxo e inseri-lo em seu 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 é possível solicitar e reproduzir streams de veiculação de pods com o aplicativo Transmitir Framework e o SDK de DAI do IMA para CAF.