Iniziare a utilizzare l'SDK IMA DAI

Seleziona la soluzione DAI che ti interessa

DAI pubblicazione pod

Gli SDK IMA semplificano l'integrazione degli annunci multimediali nei siti web e nelle app.

Gli SDK IMA possono richiedere annunci da qualsiasi Compatibile con VAST l'ad server 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 per contenuti dal vivo o VOD. L'SDK restituisce quindi uno stream video combinato, che non è necessario gestire il passaggio dall'annuncio ai video di contenuti e viceversa dell'app.

Questa guida illustra come riprodurre uno stream di pubblicazione di pod DAI dal vivo utilizzando l'SDK IMA SDK DAI per CAF.

Prima di utilizzare questa guida, acquisisci familiarità con le Ricevitore web del framework delle applicazioni Chromecast protocollo. Questa guida presuppone una conoscenza di base dei concetti dei ricevitori CAF, come intercettatori di messaggi e mediaInformation oggetti e la familiarità nell'uso Strumento di comando e controllo di trasmissione, per emulare un mittente CAF.

Per utilizzare la pubblicazione di pod IMA DAI, devi collaborare con un partner per la pubblicazione di pod e un oggetto Funzionalità avanzata di Ad Manager 360 . Se hai un account Ad Manager, contatta il tuo account manager per ulteriori dettagli. Per informazioni su come registrarti ad Ad Manager, visita la Centro assistenza Ad Manager.

Per informazioni sull'integrazione con altre piattaforme o sull'utilizzo dell'IMA SDK lato client, consulta gli SDK Interactive Media Ads.

Panoramica della pubblicazione di pod IMA DAI

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

• StreamRequest: Un oggetto che definisce una richiesta di flusso ai server pubblicitari di Google. Le richieste specificano un codice di rete, una chiave asset personalizzata e una chiave API facoltativa. e altri parametri facoltativi.
• StreamManager: Un oggetto che gestisce la comunicazione tra il video stream e l'IMA DAI l'SDK, come l'attivazione di ping di monitoraggio e l'inoltro di eventi di streaming al publisher.

Prerequisiti

• Un account della Console per gli sviluppatori di Google Cast con dispositivi di test registrati.
• Un ricevitore web ospitato Google Cloud, registrato con la tua Console per gli sviluppatori di Google Cast e che può essere modificato per ospitare il codice fornito in questa guida.
• Un'app di invio configurata per usare l'app del ricevitore web. Per ai fini di questo esempio, usa i campi Comando e controllo predefinito come mittente.

configura gli oggetti MediaInfo del mittente

Innanzitutto, configura l'input dell'app del mittente Oggetto MediaInfo per includere i seguenti campi:

Ecco alcuni esempi di codice utili per iniziare:

// 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"
    }
  }
}

Questa richiesta di caricamento personalizzato può essere inviata al destinatario per testare il resto dei carichi di lavoro passaggi.

Crea un ricevitore CAF di base

Crea un ricevitore web personalizzato, come mostrato nel ricevitore web personalizzato dell'SDK CAF Google Cloud.

Il codice del destinatario dovrebbe avere l'aspetto seguente:

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

Importa l'SDK IMA DAI e scarica Player Manager

Aggiungi un tag script per importare l'SDK IMA DAI per CAF nel ricevitore web, dopo il caricamento del CAF dello script. Nel tag script, archivia il contesto del ricevitore player manager come costanti prima di avviare il ricevitore.

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

Inizializza IMA Stream Manager

Inizializza il Gestore stream 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>

Creazione dell'intercettatore del carico del gestore dei flussi

Prima che i tuoi elementi multimediali vengano passati al CAF, crea la tua richiesta di streaming in un CARICA messaggio intercettore.

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

Crea la richiesta di flusso

Completa la funzione createStreamRequest per creare un pod che gestisce lo stream sulla richiesta di caricamento 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;
    };

Sostituisci l'URL dei contenuti con l'URL del file manifest e l'ID stream

Se la tua richiesta di stream ha esito positivo, usa streamManager.getStreamId() per recupera l'ID dello stream e inseriscilo nel tuo manifestUrl, sostituendo [[STREAMID]]. Poi sostituisci il campo contentUrl esistente con il nuovo manifestUrl in modo che il CAF riproduca il live streaming con i pod di annunci uniti.

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

Ora puoi richiedere e riprodurre gli stream per la gestione dei pod con l'applicazione Cast e l'SDK IMA DAI per CAF.