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 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 per VOD che per contenuti dal vivo. L'SDK restituisce quindi uno stream video combinato, in modo da non dover gestire il passaggio dall'annuncio al video di contenuti all'interno dell'app.
Questa guida illustra come riprodurre uno stream di pubblicazione di pod DAI con live streaming utilizzando l'SDK IMA DAI per CAF.
Prima di utilizzare questa guida, acquisisci familiarità con il protocollo del ricevitore web del framework per le applicazioni Chromecast. Questa guida presuppone una conoscenza di base dei concetti dei ricevitori CAF, ad esempio intercettatori di messaggi e degli oggetti mediaInformation, nonché di avere familiarità con l'utilizzo dello strumento Comando e controllo Cast, per emulare un mittente CAF.
Per utilizzare la pubblicazione di pod IMA DAI, devi collaborare con un partner per la pubblicazione di pod e devi disporre di un account Ad Manager 360 Advanced. Se disponi di un account Ad Manager, contatta il tuo account manager per maggiori dettagli. Per informazioni sulla registrazione ad Ad Manager, visita il Centro assistenza Ad Manager.
Per informazioni sull'integrazione con altre piattaforme o sull'utilizzo degli SDK IMA 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, illustrati 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, una chiave API facoltativa, oltre ad altri parametri facoltativi.StreamManager: un oggetto che gestisce la comunicazione tra lo stream video e l'SDK IMA DAI, ad esempio l'attivazione dei ping di monitoraggio e l'inoltro degli eventi di streaming al publisher.
Prerequisiti
- Un account della Console per gli sviluppatori di Google Cast con dispositivi di test registrati.
- Un'app di ricezione web ospitata che viene registrata sulla tua Console per gli sviluppatori di Google Cast e che può essere modificata per ospitare il codice fornito in questa guida.
- Un'app di invio configurata per utilizzare l'app del ricevitore web. Ai fini di questo esempio, utilizza lo strumento Comando e controllo di trasmissione come mittente.
configura gli oggetti MediaInfo del mittente
Innanzitutto, configura l'oggetto MediaInfo dell'app mittente in modo da includere i seguenti campi:
| Campo | Contenuti | ||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|
contentId
|
Un identificatore univoco per questo elemento multimediale.
CONTENT_ID |
||||||||||
contentUrl
|
Campo facoltativo. URL dello stream di backup da riprodurre se il caricamento dello stream DAI non va a buon fine.
BACKUP_STREAM_URL |
||||||||||
contentType
|
Campo facoltativo. Tipo MIME degli stream di backup dei contenuti. Necessario solo per gli streaming DASH.
CONTENT_STREAM_MIMETYPE |
||||||||||
streamType
|
Il valore letterale della stringa o la costante utilizzata per questo valore variano a seconda della piattaforma del mittente. | ||||||||||
customData
|
Il campo customData contiene un archivio di coppie chiave-valore di altri campi obbligatori.
|
Ecco alcuni esempi di codice utili per iniziare:
Pagine web
Per configurare questi valori in un mittente web di trasmissione, devi prima creare un oggetto MediaInfo con i dati richiesti, quindi effettuare una richiesta di caricamento al ricevitore 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
Per configurare questi valori in un mittente web di trasmissione, devi prima creare un oggetto MediaInfo con i dati richiesti, quindi effettuare una richiesta di caricamento al ricevitore 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)
Per configurare questi valori in un mittente web di trasmissione, devi prima creare un oggetto GCKMediaInformation con i dati richiesti, quindi effettuare una richiesta di caricamento al ricevitore 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)
Per configurare questi valori in un mittente web di trasmissione, devi prima creare un oggetto GCKMediaInformation con i dati richiesti, quindi effettuare una richiesta di caricamento al ricevitore 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
}
Strumento CAC
Per configurare questi valori nello strumento Comando e controllo Cast, fai clic sulla scheda Carica contenuti multimediali e imposta il tipo di richiesta di caricamento personalizzato su LOAD. Poi sostituisci i dati JSON nell'area di testo con questo 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"
}
}
}
Questa richiesta di caricamento personalizzato può essere inviata al destinatario per testare gli altri passaggi.
Crea un ricevitore CAF di base
Crea un ricevitore web personalizzato, come illustrato nella Guida al ricevitore web personalizzato dell'SDK CAF.
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, subito dopo il caricamento dello script CAF. Nel tag script, memorizza il contesto del ricevitore e il gestore del player 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 gli elementi multimediali vengano passati al CAF, crea la richiesta di flusso in un intercettore dei messaggi 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();
Crea la richiesta di flusso
Completa la funzione createStreamRequest per creare uno stream di gestione dei pod in base alla richiesta di caricamento del 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 richiesta di stream ha esito positivo, utilizza streamManager.getStreamId() per
recuperare l'ID dello stream e inserirlo nel tuo file manifestUrl, sostituendo
[[STREAMID]]. Sostituisci quindi l'elemento 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 stream con pubblicazione di pod con il framework dell'applicazione Cast e l'SDK IMA DAI per CAF.