Inserimento parziale dell’interruzione pubblicitaria

Puoi offrire un’esperienza simile alla TV, ovvero poter partecipare a un annuncio in streaming live.

La funzione di interruzione annuncio parziale consente di simulare un’esperienza simile a quella TV in cui, se il client avvia uno streaming live all’interno di un midroll, questo inizierà all’interno di tale midroll. È simile al passaggio a un canale TV e gli spot vengono eseguiti senza problemi.

Ad esempio, se un utente si unisce nel mezzo di un’interruzione pubblicitaria di 90 secondi (tre annunci di 30 secondi), 10 secondi nel secondo annuncio (ovvero, a 40 secondi dall’interruzione pubblicitaria), si verifica quanto segue:

  • Il secondo annuncio viene riprodotto per la durata rimanente (20 sec) seguito dal terzo annuncio.
  • I tracker degli annunci per l’annuncio parzialmente riprodotto (il secondo annuncio) non vengono attivati. Viene attivato solo il tracker per il terzo annuncio.

Questo comportamento non è abilitato per impostazione predefinita. Per abilitare questa funzione nell’app, effettua le seguenti operazioni.

  1. Disattiva i preroll attivi utilizzando il metodo setEnableLivePreroll della classe AdvertisingMetadata.

    advertisingMetadata.setEnableLivePreroll(String.valueOf(false))

  2. Attivare la preferenza per l'inserimento parziale dell'interruzione pubblicitaria. Utilizzare il nuovo metodo setPartialAdBreakPref nell'interfaccia MediaPlayer per attivare questa funzione. Utilizzare il metodo getPartialAdBreakPref per trovare lo stato corrente di questa preferenza.

    MediaPlayer mediaPlayer = DefaultMediaPlayer.create(getActivity().getApplicationContext());

       mediaPlayer.setPartialAdBreakPref(true);

  3. Questa funzione richiede l’implementazione di un selettore di criteri di annuncio personalizzato per personalizzare il comportamento. Se non si dispone già di un'implementazione personalizzata della classe AdvertisingFactory, aggiungere una nuova implementazione AdvertisingFactory. Ignorare il metodo createAdPolicySelector. Questo metodo restituisce una nuova istanza dell'implementazione di AdPolicySelector.

    Di seguito è riportato un esempio di implementazione da utilizzare come riferimento. La seguente implementazione di esempio è disponibile per l’utilizzo dal pacchetto com.adobe.mediacore. Tuttavia, viene semplificato per un riferimento semplice e non è consigliabile utilizzarlo così com’è.

    1. Selettore dei criteri degli annunci di esempio

       package com.adobe.mediacore;

import com.adobe.mediacore.logging.Log;
import com.adobe.mediacore.logging.Logger;
import com.adobe.mediacore.metadata.*;
import com.adobe.mediacore.timeline.advertising.*;

import java.util.ArrayList;
import java.util.List;

public class PartialAdBreakAdPolicySelector implements AdPolicySelector {
    private static final String LOG_TAG = "[PSDK]::" + DefaultAdPolicySelector.class.getSimpleName();
    private final Logger _logger = Log.getLogger(LOG_TAG);

    private final MediaPlayerItem _mediaPlayerItem;
    private final AdBreakAsWatched _adBreakAsWatchedPolicy;

    public PartialAdBreakAdPolicySelector(MediaPlayerItem mediaPlayerItem) {
        _mediaPlayerItem = mediaPlayerItem;
        _adBreakAsWatchedPolicy = extractAdBreakAsWatchedPolicy(_mediaPlayerItem);
    }

    @Override
    public AdBreakPolicy selectPolicyForAdBreak(AdPolicyInfo adPolicyInfo) {
        _logger.i(LOG_TAG + "#selectPolicyForAdBreak", "currentTime=" + adPolicyInfo.getCurrentTime() + " seekToTime="
                + adPolicyInfo.getSeekToTime() + " rate=" + adPolicyInfo.getRate() + " adPolicyMode=" + adPolicyInfo.getMode());

        if (adPolicyInfo.getAdBreakPlacements().size() > 0) {
            AdBreakPlacement adBreakTimelineItem = adPolicyInfo.getAdBreakPlacements().get(0);
            if (adPolicyInfo.getMode() == AdPolicyMode.SEEK && adBreakTimelineItem.getAdBreak().isWatched()) {
                return AdBreakPolicy.SKIP;
            }
        }

        AdSignalingMode adSignalingMode = AdSignalingMode.DEFAULT;
        if (_mediaPlayerItem != null) {
            MetadataNode metadata = (MetadataNode) _mediaPlayerItem.getResource().getMetadata();
            if (metadata != null) {
                AdvertisingMetadata advertisingMetadata = (AdvertisingMetadata) metadata.getNode(DefaultMetadataKeys.ADVERTISING_METADATA.getValue());
                if (advertisingMetadata != null) {
                    adSignalingMode = advertisingMetadata.getSignalingMode();
                }
            }
        }

        // can't remove main content due to a ave bug, need to check if stream is live or ad signaling mode is manifest cue
        if (_mediaPlayerItem.isLive() || adSignalingMode == AdSignalingMode.MANIFEST_CUES) {
            return AdBreakPolicy.PLAY;
        }

        return AdBreakPolicy.REMOVE_AFTER_PLAY;
    }

    @Override
    public List<AdBreakPlacement> selectAdBreaksToPlay(AdPolicyInfo adPolicyInfo) {
        _logger.i(LOG_TAG + "#selectAdBreaksToPlay", "currentTime=" + adPolicyInfo.getCurrentTime() + " seekToTime="
                + adPolicyInfo.getSeekToTime() + " rate=" + adPolicyInfo.getRate() + " adPolicyMode=" + adPolicyInfo.getMode());

        List<AdBreakPlacement> adBreakPlacements = adPolicyInfo.getAdBreakPlacements();
        if (adBreakPlacements != null) {
            int size = adBreakPlacements.size();
            List<AdBreakPlacement> adBreaks = new ArrayList<AdBreakPlacement>();
            if (size > 0 && adPolicyInfo.getCurrentTime() <= adPolicyInfo.getSeekToTime()) {
                AdBreakPlacement adBreak = adBreakPlacements.get(size - 1);
                if (!adBreak.getAdBreak().isWatched()) {
                    adBreaks.add(adBreak);
                    return adBreaks;
                }
            }
        }

        return null;
    }

    @Override
    public AdPolicy selectPolicyForSeekIntoAd(AdPolicyInfo adPolicyInfo) {
        _logger.i(LOG_TAG + "#selectPolicyForSeekIntoAd", "currentTime=" + adPolicyInfo.getCurrentTime() + " seekToTime="
                + adPolicyInfo.getSeekToTime() + " rate=" + adPolicyInfo.getRate() + " adPolicyMode=" + adPolicyInfo.getMode());

        // If you really want to allow seek during ads (you likely do not).
        return AdPolicy.PLAY;
    }

    @Override
    public AdBreakAsWatched selectWatchedPolicyForAdBreak(AdPolicyInfo adPolicyInfo) {
        _logger.i(LOG_TAG + "#selectWatchedPolicyForAdBreak", "currentTime=" + adPolicyInfo.getCurrentTime() + " seekToTime="
                + adPolicyInfo.getSeekToTime() + " rate=" + adPolicyInfo.getRate() + " adPolicyMode=" + adPolicyInfo.getMode());

        return _adBreakAsWatchedPolicy;
    }

    /**
     * Extract the ad break watched policy for the specified media player item.
     *
     * @param item Associated media player item.
     * @return a valid ad break watched policy.
     */
    private AdBreakAsWatched extractAdBreakAsWatchedPolicy(MediaPlayerItem item) {
        AdBreakAsWatched adBreakWatchedPolicy = AdBreakAsWatched.AD_BREAK_AS_WATCHED_ON_BEGIN;

        if (item != null) {
            MetadataNode metadata = (MetadataNode) item.getResource().getMetadata();
            if (metadata != null) {
                AdvertisingMetadata advertisingMetadata = (AdvertisingMetadata) metadata.getNode(DefaultMetadataKeys.ADVERTISING_METADATA.getValue());
                if (advertisingMetadata != null) {
                    adBreakWatchedPolicy = advertisingMetadata.getAdBreakAsWatched();
                }
            }
        }

        return adBreakWatchedPolicy;
    }
}

    2. Esempio di Advertising factory

      private AdvertisingFactory createPartialAdBreakFactory() {
return new AdvertisingFactory() {
@Override
             public AdPolicySelector
createAdPolicySelector(MediaPlayerItem mediaPlayerItem) {
                return new PartialAdBreakAdPolicySelector(mediaPlayerItem);
             }

// Rest of the interface methods can be overridden as per your
// customization needs
// As shown next
@Override
public AdPolicySelector
createAdPolicySelector(MediaPlayerItem mediaPlayerItem) {
   return new PartialAdBreakAdPolicySelector(mediaPlayerItem);
  }
// . . .

 }
}

    3. Registra la nostra AdvertisingFactory con il lettore multimediale

      AdvertisingFactory advertisingFactory = createPartialAdBreakFactory();

if (advertisingFactory != null) {
            mediaPlayer.registerAdClientFactory(advertisingFactory);
}

    4. Ignorare il metodo createAdPolicySelector

      @Override
public AdPolicySelector
createAdPolicySelector(MediaPlayerItem mediaPlayerItem) {
   return new PartialAdBreakAdPolicySelector(mediaPlayerItem);
}

In questa pagina