Iniziare a utilizzare l'SDK IMA DAI

Gli SDK IMA semplificano l'integrazione degli annunci multimediali nei siti web e nelle app. Gli SDK IMA possono richiedere annunci da qualsiasi ad server compatibile con VAST e gestire la riproduzione degli annunci nelle tue app. Con gli SDK IMA DAI, le app effettuano una richiesta di streaming per annuncio e video di contenuti, sia VOD che contenuti dal vivo. L'SDK restituisce quindi uno stream video combinato, in modo che tu non debba gestire il passaggio dall'annuncio al video di contenuti all'interno dell'app.

Seleziona la soluzione DAI che ti interessa

DAI pubblicazione pod

Questa guida illustra come riprodurre uno stream con pubblicazione di pod DAI per contenuti dal vivo o VOD, utilizzando l'SDK IMA DAI per HTML5 con un video player che si basa su hls.js per la riproduzione. Se vuoi visualizzare o seguire un'integrazione di esempio completata, che supporta sia HLS.js sia la riproduzione Safari, consulta l'esempio di pubblicazione di pod HLS. Per il supporto di DASH.js, vedi l'esempio di pubblicazione dei pod DASH. Puoi scaricare queste app di esempio dalla pagina di rilascio di GitHub per DAI HTML5.

Panoramica della pubblicazione di pod DAI

L'implementazione della pubblicazione dei pod utilizzando l'SDK IMA DAI prevede due componenti principali, illustrati in questa guida:

  • PodStreamRequest / PodVodStreamRequest: un oggetto che definisce una richiesta di streaming ai server pubblicitari di Google. Le richieste specificano un codice di rete e PodStreamRequest richiede anche una chiave asset personalizzata e una chiave API facoltativa. Entrambi includono altri parametri facoltativi.

  • StreamManager: un oggetto che gestisce la comunicazione tra il video stream e l'SDK IMA DAI, ad esempio l'attivazione dei ping di monitoraggio e l'inoltro degli eventi di streaming al publisher.

Prerequisiti

Prima di iniziare, è necessario quanto segue:

  • Tre file vuoti:

    • dai.html
    • dai.css
    • dai.js

  • Python installato sul computer, un server web o un altro ambiente di sviluppo ospitato da utilizzare per il test

Configurare un ambiente di sviluppo

Poiché l'SDK carica le dipendenze utilizzando lo stesso protocollo della pagina da cui viene caricato, devi utilizzare un server web per testare l'app. Un modo rapido per avviare un server di sviluppo locale è utilizzare il server integrato di Python.

  1. Utilizzando una riga di comando, dalla directory che contiene il file index.html esegui:

    python -m http.server 8000

  2. In un browser web, vai a http://localhost:8000/

    Puoi anche utilizzare qualsiasi altro ambiente di sviluppo ospitato o server web, come Apache HTTP Server.

Creare un video player semplice

In primo luogo, modifica dai.html per creare un semplice elemento video HTML5 e un div da utilizzare per gli elementi dell'interfaccia utente dell'annuncio. Aggiungi anche i tag necessari per caricare i file dai.css e dai.js e per importare il video player hls.js.

Quindi, modifica dai.css per specificare le dimensioni e la posizione degli elementi della pagina. Infine, in dai.js, definisci le variabili in cui inserire le informazioni della richiesta di flusso e una funzione initPlayer() da eseguire al caricamento della pagina.

Le costanti delle richieste di flussi di dati sono le seguenti:

  • BACKUP_STREAM: un URL per uno stream di backup da riprodurre nel caso in cui durante l'elaborazione degli annunci si verifichi un errore irreversibile.

  • STREAM_URL: utilizzato solo per i live streaming. L'URL dello stream video fornito dal manipolatore del manifest o da un partner terzo utilizzando la pubblicazione dei pod. Prima di effettuare una richiesta, dovresti inserire l'ID stream fornito dall'SDK IMA DAI. In questo caso, l'URL dello stream include un segnaposto, [[STREAMID]], che viene sostituito con l'ID streaming prima di effettuare una richiesta.

  • NETWORK_CODE: il codice di rete del tuo account Ad Manager 360.

  • CUSTOM_ASSET_KEY: utilizzato solo per i live streaming. La chiave degli asset personalizzata che identifica l'evento di pubblicazione dei pod in Ad Manager 360. Può essere creato dal manipolatore del manifest o dal partner di pubblicazione di pod di terze parti.

  • API_KEY: utilizzato solo per i live streaming. Una chiave API facoltativa che può essere necessaria per recuperare un ID stream dall'SDK IMA DAI.

dai.html

<html>
<head>
  <script src="https://cdn.jsdelivr.net/npm/hls.js@latest"></script>
  <script src="dai.js"></script>
  <link rel="stylesheet" href="dai.css" type="text/css">
</head>
<body onLoad="initPlayer()">
  <h2>IMA DAI SDK Demo (HLS.JS)</h2>
    <video id="video"></video>
    <div id="ad-ui"></div>
</body>
</html>

dai.css

#video,
#ad-ui {
  width: 640px;
  height: 360px;
  position: absolute;
  top: 35px;
  left: 0;
}

#ad-ui {
  cursor: pointer;
}

dai.js

var BACKUP_STREAM =
    'https://storage.googleapis.com/interactive-media-ads/media/bbb.m3u8'

// Stream Config.
const STREAM_URL = "https://encodersim.sandbox.google.com/masterPlaylist/...&stream_id=[[STREAMID]]";
const NETWORK_CODE = "51636543";
const CUSTOM_ASSET_KEY = "google-sample";
const API_KEY = "";

var hls = new Hls(); // hls.js video player
var videoElement;
var adUiElement;

function initPlayer() {
  videoElement = document.getElementById('video');
  adUiElement = document.getElementById('adUi');
}

Carica l'SDK IMA DAI

Poi aggiungi il framework DAI utilizzando un tag script in dai.html, prima del tag per dai.js.

dai.html

<html>
<head>
  <script src="https://cdn.jsdelivr.net/npm/hls.js@latest"></script>
  <script type="text/javascript" src="//imasdk.googleapis.com/js/sdkloader/ima3_dai.js"></script>
  <script src="dai.js"></script>
  <link rel="stylesheet" href="dai.css" type="text/css">
</head>
...

Inizializza StreamManager ed effettua una richiesta di streaming dal vivo o VOD

Pubblicazione di pod in live streaming

Per richiedere un insieme di annunci, crea un ima.dai.api.StreamManager, responsabile della richiesta e della gestione degli stream DAI. Il costruttore utilizza un elemento video e l'istanza risultante utilizza un elemento dell'interfaccia utente dell'annuncio per gestire le interazioni con gli annunci.

Quindi, definisci una funzione per richiedere il live streaming del pod che gestisce il flusso. Questa funzione crea prima un PodStreamRequest, lo configura con i parametri streamRequest, quindi chiama streamManager.requestStream() con quell'oggetto di richiesta.

dai.js

function initPlayer() {
  videoElement = document.getElementById('video');
  adUiElement = document.getElementById('adUi');
  streamManager = new google.ima.dai.api.StreamManager(videoElement, adUiElement)

  requestLivePodStream(NETWORK_CODE, CUSTOM_ASSET_KEY, API_KEY);
}

function requestLivePodStream(networkCode, customAssetKey, apiKey) {
  // clear HLS.js instance, if in use
  if (hls) {
    hls.destroy();
  }

  // Generate a Pod Serving live Stream Request
  const streamRequest = new google.ima.dai.api.PodStreamRequest();
  streamRequest.networkCode = networkCode;
  streamRequest.customAssetKey = customAssetKey;
  streamRequest.apiKey = apiKey;
  streamRequest.format = 'hls';
  streamManager.requestStream(streamRequest);
}

Pubblicazione di pod VOD

Per richiedere un insieme di annunci, crea un ima.dai.api.StreamManager, responsabile della richiesta e della gestione degli stream DAI. Il costruttore utilizza un elemento video e l'istanza risultante utilizza un elemento dell'interfaccia utente dell'annuncio per gestire le interazioni con gli annunci.

Quindi, definisci una funzione per richiedere il pod che pubblica lo stream VOD. Questa funzione crea prima un PodVodStreamRequest, lo configura con i parametri streamRequest, quindi chiama streamManager.requestStream() con quell'oggetto di richiesta.

dai.js

function initPlayer() {
  videoElement = document.getElementById('video');
  adUiElement = document.getElementById('adUi');
  streamManager = new google.ima.dai.api.StreamManager(videoElement, adUiElement)

  requestVodPodStream(NETWORK_CODE);
}

function requestVodPodStream(networkCode) {
  // clear HLS.js instance, if in use
  if (hls) {
    hls.destroy();
  }

  // Generate a Pod Serving VOD Stream Request
  const streamRequest = new google.ima.dai.api.PodVodStreamRequest();
  streamRequest.networkCode = networkCode;
  streamRequest.format = 'hls';
  streamManager.requestStream(streamRequest);
}

Gestire gli eventi di streaming

Pubblicazione di pod in live streaming

Successivamente, implementa listener di eventi per gli eventi video principali. In questo esempio vengono gestiti gli eventi STREAM_INITIALIZED, ERROR, AD_BREAK_STARTED e AD_BREAK_ENDED richiamando una funzione onStreamEvent(). Questa funzione gestisce il caricamento dello stream e gli errori, oltre a disattivare i controlli del player durante la riproduzione di un annuncio, come richiesto dall'SDK. Quando viene caricato lo stream, il video player carica e riproduce l'URL fornito utilizzando una funzione loadStream().

dai.js

var isAdBreak;

function initPlayer() {
  videoElement = document.getElementById('video');
  adUiElement = document.getElementById('adUi');
  streamManager = new google.ima.dai.api.StreamManager(videoElement, adUiElement);
  
  streamManager.addEventListener(
    [google.ima.dai.api.StreamEvent.Type.STREAM_INITIALIZED,
    google.ima.dai.api.StreamEvent.Type.ERROR,
    google.ima.dai.api.StreamEvent.Type.AD_BREAK_STARTED,
    google.ima.dai.api.StreamEvent.Type.AD_BREAK_ENDED],
    onStreamEvent,
    false);
...
function onStreamEvent(e) {
  switch (e.type) {
    case google.ima.dai.api.StreamEvent.Type.STREAM_INITIALIZED:
      console.log('Stream initialized');
      loadStream(e.getStreamData().streamId);
      break;
    case google.ima.dai.api.StreamEvent.Type.ERROR:
      console.log('Error loading stream, playing backup stream.' + e);
      loadStream('');
      break;
    case google.ima.dai.api.StreamEvent.Type.AD_BREAK_STARTED:
      console.log('Ad Break Started');
      isAdBreak = true;
      videoElement.controls = false;
      adUiElement.style.display = 'block';
      break;
    case google.ima.dai.api.StreamEvent.Type.AD_BREAK_ENDED:
      console.log('Ad Break Ended');
      isAdBreak = false;
      videoElement.controls = true;
      adUiElement.style.display = 'none';
      break;
    default:
      break;
  }
}

function loadStream(streamID) {
  var url;
  if(streamID) {
    url = STREAM_URL.replace('[[STREAMID]]', streamID);
  } else {
    console.log('Stream Initialization Failed');
    url = BACKUP_STREAM;
  }
  console.log('Loading:' + url);
  hls.loadSource(url);
  hls.attachMedia(videoElement);
}

Pubblicazione di pod VOD

Successivamente, implementa listener di eventi per gli eventi video principali. Questo esempio gestisce gli eventi STREAM_INITIALIZED, LOADED, ERROR, AD_BREAK_STARTED e AD_BREAK_ENDED chiamando una funzione onStreamEvent(). Questa funzione gestisce il caricamento dello stream e gli errori, nonché la disattivazione dei controlli del player durante la riproduzione di un annuncio, operazione richiesta dall'SDK.

Inoltre, gli stream per la pubblicazione di pod VOD richiedono la chiamata a StreamManager.loadStreamMetadata() in risposta all'evento STREAM_INITIALIZED. Devi anche richiedere un URL dello stream al tuo partner di tecnologia video (VTP). Una volta completata la chiamata a loadStreamMetadata(), viene attivato un evento LOADED, in cui devi chiamare una funzione loadStream() con l'URL dello stream per caricare e riprodurre lo stream.

var isAdBreak;

function initPlayer() {
  videoElement = document.getElementById('video');
  adUiElement = document.getElementById('adUi');
  streamManager = new google.ima.dai.api.StreamManager(videoElement, adUiElement);
  
  streamManager.addEventListener(
    [google.ima.dai.api.StreamEvent.Type.STREAM_INITIALIZED,
    google.ima.dai.api.StreamEvent.Type.ERROR,
    google.ima.dai.api.StreamEvent.Type.AD_BREAK_STARTED,
    google.ima.dai.api.StreamEvent.Type.AD_BREAK_ENDED],
    onStreamEvent,
    false);
...
function onStreamEvent(e) {
  switch (e.type) {
    case google.ima.dai.api.StreamEvent.Type.STREAM_INITIALIZED:
      const streamId = e.getStreamData().streamId;
      // 'vtpInterface' is a place holder for your own video technology
      //  partner (VTP) API calls.
      vtpInterface.requestStreamURL({
        'streamId': streamId,
      })
      .then( (vtpStreamUrl) => {
        streamUrl = vtpStreamUrl;
        streamManager.loadStreamMetadata();
      }, (error) => {
        // Handle the error.
      });
      break;
    case google.ima.dai.api.StreamEvent.Type.LOADED:
      loadStream(streamUrl);
      break;
    case google.ima.dai.api.StreamEvent.Type.ERROR:
      console.log('Error loading stream, playing backup stream.' + e);
      loadStream();
      break;
    case google.ima.dai.api.StreamEvent.Type.AD_BREAK_STARTED:
      console.log('Ad Break Started');
      isAdBreak = true;
      videoElement.controls = false;
      adUiElement.style.display = 'block';
      break;
    case google.ima.dai.api.StreamEvent.Type.AD_BREAK_ENDED:
      console.log('Ad Break Ended');
      isAdBreak = false;
      videoElement.controls = true;
      adUiElement.style.display = 'none';
      break;
    default:
      break;
  }
}

function loadStream(url) {
  if(url) {
    console.log('Loading:' + url);
    hls.loadSource(url);
  } else {
    console.log('Stream Initialization Failed');
    hls.loadSource(BACKUP_STREAM);
  }
  hls.attachMedia(videoElement);
}

Gestire i metadati degli stream

In questo passaggio implementerai i listener di eventi per i metadati al fine di notificare all'SDK quando si verificano eventi relativi agli annunci. L'ascolto di eventi di metadati in-stream può variare a seconda del formato dello stream (HLS o DASH), del tipo di stream (streaming live o VOD), del tipo di player e del tipo di backend DAI utilizzato. Per ulteriori informazioni, consulta la nostra guida I metadati con timestamp.

Formato di stream HLS (streaming live e VOD, player HLS.js)

Se utilizzi un player HLS.js, ascolta l'evento FRAG_PARSING_METADATA HLS.js per ottenere i metadati ID3 e passalo all'SDK con StreamManager.processMetadata().

Per riprodurre automaticamente il video dopo che tutto è stato caricato e pronto, ascolta l'evento MANIFEST_PARSED HLS.js per attivare la riproduzione.

function loadStream(streamID) {
  hls.loadSource(url);
  hls.attachMedia(videoElement);
  
  // Timed metadata is passed HLS stream events to the streamManager.
  hls.on(Hls.Events.FRAG_PARSING_METADATA, parseID3Events);
  hls.on(Hls.Events.MANIFEST_PARSED, startPlayback);
}

function parseID3Events(event, data) {
  if (streamManager && data) {
    // For each ID3 tag in the metadata, pass in the type - ID3, the
    // tag data (a byte array), and the presentation timestamp (PTS).
    data.samples.forEach((sample) => {
      streamManager.processMetadata('ID3', sample.data, sample.pts);
    });
  }
}

function startPlayback() {
  console.log('Video Play');
  videoElement.play();
}

DASH.js (formato di streaming DASH, tipo di stream live e tipo di stream VOD)

Se utilizzi un player DASH.js, devi utilizzare stringhe diverse per ascoltare i metadati ID3 per gli stream dal vivo o VOD:

  • Live streaming: 'https://developer.apple.com/streaming/emsg-id3'
  • Stream VOD: 'urn:google:dai:2018'

Trasmetti i metadati ID3 all'SDK con StreamManager.processMetadata().

Per mostrare automaticamente i controlli video dopo che tutto è stato caricato e pronto, ascolta l'evento MANIFEST_LOADED DASH.js.

const googleLiveSchema = 'https://developer.apple.com/streaming/emsg-id3';
const googleVodSchema = 'urn:google:dai:2018';
dashPlayer.on(googleLiveSchema, processMetadata);
dashPlayer.on(googleVodSchema, processMetadata);
dashPlayer.on(dashjs.MediaPlayer.events.MANIFEST_LOADED, loadlistener);

function processMetadata(metadataEvent) {
  const messageData = metadataEvent.event.messageData;
  const timestamp = metadataEvent.event.calculatedPresentationTime;

  // Use StreamManager.processMetadata() if your video player provides raw
  // ID3 tags, as with dash.js.
  streamManager.processMetadata('ID3', messageData, timestamp);
}

function loadlistener() {
  showControls();

  // This listener must be removed, otherwise it triggers as addional
  // manifests are loaded. The manifest is loaded once for the content,
  // but additional manifests are loaded for upcoming ad breaks.
  dashPlayer.off(dashjs.MediaPlayer.events.MANIFEST_LOADED, loadlistener);
}

Shaka Player con live streaming (formato di stream DASH)

Se utilizzi Shaka player per la riproduzione del live streaming, usa la stringa 'emsg' per ascoltare gli eventi dei metadati. Quindi, utilizza i dati dei messaggi di evento nella chiamata a StreamManager.onTimedMetadata().

shakaPlayer.addEventListener('emsg', (event) => onEmsgEvent(event));

function onEmsgEvent(metadataEvent) {
  // Use StreamManager.onTimedMetadata() if your video player provides
  // processed metadata, as with Shaka player livestreams.
  streamManager.onTimedMetadata({'TXXX': metadataEvent.detail.messageData});
}

Player Shaka con stream VOD (formato stream DASH)

Se utilizzi Shaka player per la riproduzione in streaming VOD, utilizza la stringa 'timelineregionenter' per ascoltare gli eventi dei metadati. Quindi, utilizza i dati del messaggio di evento nella chiamata a StreamManager.processMetadata() con la stringa 'urn:google:dai:2018'.

shakaPlayer.addEventListener('timelineregionenter', (event) => onTimelineEvent(event));

function onTimelineEvent(metadataEvent) {
  const detail = metadataEvent.detail;
  if ( detail.eventElement.attributes &&
       detail.eventElement.attributes['messageData'] &&
       detail.eventElement.attributes['messageData'].value ) {
        const mediaId = detail.eventElement.attributes['messageData'].value;
        const pts = detail.startTime;
        // Use StreamManager.processMetadata() if your video player provides raw
        // ID3 tags, as with Shaka player VOD streams.
        streamManager.processMetadata('urn:google:dai:2018', mediaId, pts);
       }
}

Gestire gli eventi dei giocatori

Aggiungi listener di eventi agli eventi pause e start dell'elemento video per consentire all'utente di riprendere la riproduzione quando l'SDK viene messo in pausa durante le interruzioni pubblicitarie.

function loadStream(streamUrl) {
  ...
  
  videoElement.addEventListener('pause', onStreamPause);
  videoElement.addEventListener('play', onStreamPlay);
}

function onStreamPause() {
  console.log('paused');
  if (isAdBreak) {
    videoElement.controls = true;
    adUiElement.style.display = 'none';
  }
}

function onStreamPlay() {
  console.log('played');
  if (isAdBreak) {
    videoElement.controls = false;
    adUiElement.style.display = 'block';
  }
}

È tutto. Stai richiedendo e mostrando annunci in uno stream di pubblicazione di pod con l'SDK IMA DAI per HTML5. Per scoprire di più sulle funzionalità avanzate dell'SDK, consulta le altre guide o gli esempi su GitHub.