@saooti/octopus-sdk 40.0.3 → 40.1.0

package/src/components/composable/player/usePlayerLogicProgress.ts

@@ -0,0 +1,135 @@
+import { usePlayerStore } from "../../../stores/PlayerStore";
+import { useAuthStore } from "../../../stores/AuthStore";
+import { onMounted, Ref, ref, watch} from 'vue';
+import classicApi from "../../../api/classicApi";
+
+export const usePlayerLogicProgress = ()=>{
+  const listenTime= ref(0);
+  const notListenTime= ref(0);
+  const lastSend= ref(0);
+  const downloadId: Ref<string | null>= ref(null);
+
+  const playerStore = usePlayerStore();
+  const authStore = useAuthStore();
+
+
+
+  watch(listenTime, async (newVal) => {
+    if (
+      (playerStore.playerRadio && !playerStore.playerPodcast && !playerStore.playerLive) ||
+      !downloadId.value ||
+      newVal - lastSend.value < 10
+    ) {
+      return;
+    }
+    lastSend.value = newVal;
+    await classicApi.putData({
+      api: 0,
+      path:"podcast/listen/" + downloadId.value + "?seconds=" + Math.round(newVal),
+      isNotAuth:true
+    });
+  });
+
+  watch(()=>playerStore.playerSeekTime, async () => {
+    if (undefined===playerStore.playerSeekTime) {
+      return;
+    }
+    if (playerStore.playerPodcast || playerStore.playerLive) {
+      notListenTime.value = playerStore.playerSeekTime - listenTime.value;
+    }
+    if(playerStore.playerVideo){
+      return;
+    }
+    const audioPlayer: HTMLAudioElement | null = document.querySelector("#audio-player");
+    if (!audioPlayer) return;
+    audioPlayer.currentTime = playerStore.playerSeekTime;
+  });
+
+
+
+  onMounted(() => {
+      window.addEventListener("beforeunload", endListeningProgress);
+  })
+
+  async function initLiveDownloadId() {
+    if (!playerStore.playerLive || downloadId.value) {
+      return;
+    }
+    try {
+      const mediaType = playerStore.playerVideo ? "VIDEO":"AUDIO";
+      const downloadId = await classicApi.putData<string | null>({
+        api: 0,
+        path:"podcast/prepare/live/" + playerStore.playerLive.podcastId+"?mediaType="+mediaType,
+        isNotAuth:true
+      });
+      await classicApi.fetchData<string | null>({
+        api:0,
+        path: "podcast/download/live/" + playerStore.playerLive.podcastId + ".m3u8",
+        parameters:{
+          downloadId: downloadId ?? undefined,
+          origin: "octopus",
+          distributorId: authStore.authOrgaId,
+        },
+        isNotAuth:true
+      });
+      setDownloadId(downloadId);
+    } catch {
+      downloadId.value = null;
+      console.log("ERROR downloadId");
+    }
+  }
+
+  function onTimeUpdateProgress(currentTime: number): void {
+    if (!downloadId.value) {
+      return;
+    }
+    if (
+      playerStore.playerLive &&
+      0 === listenTime.value &&
+      0 !== currentTime
+    ) {
+      notListenTime.value = currentTime;
+      listenTime.value = 1;
+    } else {
+      const newListenTime = currentTime - notListenTime.value;
+      const diffTime = newListenTime - listenTime.value;
+      if(diffTime > 0 && diffTime<1){
+        listenTime.value = newListenTime;
+      }
+    }
+  }
+
+  function setDownloadId(newValue: string | null): void {
+    endListeningProgress();
+    downloadId.value = newValue;
+  }
+
+  async function endListeningProgress(): Promise<void> {
+    if (!downloadId.value) return;
+    try {
+      await classicApi.putData<string | null>({
+        api: 0,
+        path:"podcast/listen/" +
+        downloadId.value +
+          "?seconds=" +
+          Math.round(listenTime.value),
+        isNotAuth:true
+      });
+    } catch {
+      //Do nothing
+    }
+    downloadId.value = null;
+    notListenTime.value = 0;
+    lastSend.value = 0;
+    listenTime.value = 0;
+  }
+
+
+	return {
+    listenTime,
+    downloadId,
+    initLiveDownloadId,
+    setDownloadId,
+    onTimeUpdateProgress
+	}
+}

package/src/components/composable/player/usePlayerStitching.ts

@@ -0,0 +1,213 @@
+import { usePlayerStore } from "../../../stores/PlayerStore";
+import { useVastStore } from "../../../stores/VastStore";
+import { useSaveFetchStore } from "../../../stores/SaveFetchStore";
+import { usePlayerVast } from "./usePlayerVast";
+import fetchHelper from "../../../helper/fetchHelper";
+
+import {computed, onMounted, Ref, ref, watch} from 'vue';
+import { useRoute } from "vue-router";
+import dayjs from "dayjs";
+import classicApi from "../../../api/classicApi";
+import { AdserverOtherEmission } from "@/stores/class/adserver/adserverOtherEmission";
+import { AdPosition } from "@/stores/class/adserver/adPosition";
+import { AdserverTiming } from "@/stores/class/adserver/adserverTiming";
+
+export const usePlayerStitching = ()=>{
+
+  const { isAdRequested, prepareIMA, onRequestAd,destroyAdManager, contentEndedAdsLoader } = usePlayerVast();
+
+  const radioInterval : Ref<ReturnType<typeof setTimeout> | undefined> = ref(undefined);
+
+  const route = useRoute()
+  const playerStore = usePlayerStore();
+  const vastStore = useVastStore();
+  const saveFetchStore= useSaveFetchStore();
+
+  const radioNextAdvertisingStartDate = computed(() => { 
+    return playerStore.playerRadio?.nextAdvertising?.startDate;
+  });
+
+
+  watch(() => playerStore.playerCurrentChange, () => {
+    if(playerStore.playerCurrentChange && playerStore.playerCurrentChange > 0 && !checkUsePlayerPodcastStitching()){return;}
+    onPlayerChange();
+  });
+
+  //launch advertising for podcast
+  watch(() => playerStore.playerElapsedSeconds, () => {
+    if(!checkUsePlayerPodcastStitching()){return;}
+    if(!isAdRequested.value && checkAdNeedToBeLaunch()){
+      onRequestAd(vastStore.adPositionsPodcasts[playerStore.playerCurrentChange??0][vastStore.adPositionIndex].vastUrl);
+      vastStore.updateAdPositionIndex(vastStore.adPositionIndex+1); 
+    }
+  });
+
+  // launch advertising for radio
+  watch(radioNextAdvertisingStartDate, () => {
+    if(!radioNextAdvertisingStartDate.value){
+      return;
+    }
+    defineRadioInterval();
+  }, { immediate: true });
+
+
+  onMounted(() => {
+    vastStore.updateuseVastPlayerPodcast("true"===route.query.vast);
+  })
+
+  function checkUsePlayerPodcastStitching():boolean{
+    return vastStore.useVastPlayerPodcast;
+  }
+
+  function defineRadioInterval(){
+    clearRadioInterval();
+    const timeRemaining = dayjs(radioNextAdvertisingStartDate.value).diff(dayjs(), "millisecond");
+    console.log("TimeRemaining "+timeRemaining);
+    if(timeRemaining < 0){
+      return;
+    }
+    radioInterval.value = setTimeout(() => {
+      radioIntervalExecute();
+    }, timeRemaining);
+  }
+
+  async function radioIntervalExecute(){
+    //If pause when ad needs to be played then skipped (TO THINK)
+    if("PAUSED"===playerStore.playerStatus){return;}
+    const vastUrl = await getVastUrl(playerStore.playerRadio?.nextAdvertising?.tag ??"5e385e1b51c86", playerStore.playerRadio?.nextAdvertising?.adCount ?? 1);
+    console.log("vastUrl "+vastUrl);
+    onRequestAd(vastUrl);
+  }
+
+  function clearRadioInterval() {
+    clearInterval(radioInterval.value as unknown as number);
+    radioInterval.value = undefined;
+  }
+
+  function checkAdNeedToBeLaunch(){
+    if(!playerStore.playerCurrentChange || !vastStore.adPositionsPodcasts[playerStore.playerCurrentChange]?.[vastStore.adPositionIndex]){return false;}
+    return vastStore.adPositionsPodcasts[playerStore.playerCurrentChange][vastStore.adPositionIndex]?.seconds <= playerStore.playerElapsedSeconds;
+  }
+
+  async function onPlayerChange(){
+    destroyAdManager();
+    if(null==playerStore.playerCurrentChange){return;}
+    prepareIMA();
+    await fetchPodcastAdConfig();
+  }
+
+  async function fetchPodcastAdConfig(){
+    if(!playerStore.playerCurrentChange || !playerStore.playerPodcast ||(playerStore.playerCurrentChange && vastStore.adPositionsPodcasts[playerStore.playerCurrentChange])){
+      return;
+    }
+    const adserverConfig = await classicApi.fetchData<AdserverOtherEmission>({
+      api:0,
+      path: `ad/test/podcast/${playerStore.playerCurrentChange}`,
+      isNotAuth:true
+    });
+    if(!adserverConfig || "SOUNDCAST_VAST"!==adserverConfig.config?.server){
+      vastStore.updateAdPositionsPodcasts(playerStore.playerCurrentChange, []);
+      return;
+    }
+    const podcastDurationSeconds = Math.round((playerStore.playerPodcast?.duration??0) / 1000);
+    const allAdPositions =generateAllAdPositions(adserverConfig.config.doublets, podcastDurationSeconds);
+    const selectedAdPositions = await selectCorrectAdPositions(allAdPositions, podcastDurationSeconds, adserverConfig.config.minIntervalDuration, adserverConfig.config.minTailDuration);
+    vastStore.updateAdPositionsPodcasts(playerStore.playerCurrentChange, selectedAdPositions);
+  }
+
+  function generateAllAdPositions(doublets: Array<AdserverTiming>, podcastDuration: number): Array<AdPosition>{
+    const adPositions: Array<AdPosition> = [];
+    if(doublets.some((element: AdserverTiming)=>{return "TAG_NO_AD"===element.tag})){
+      return [];
+    }
+    for (const doublet of doublets) {
+      if(!doublet.tag){continue;}
+      let seconds = 0;
+      if("post"===doublet.timing.insertion){
+        seconds = podcastDuration;
+      }else if("mid"===doublet.timing.insertion){
+        const mesure = doublet.timing.mesure ?? 0;
+        switch (doublet.timing.unit){
+          case "MILLISECOND": seconds = mesure * 1000; break;
+          case "MINUTE": seconds = Math.round(mesure / 60); break;
+          case "PERCENT": seconds = Math.round((mesure * podcastDuration) / 100); break;
+          default: seconds = mesure; break;
+        }
+      }
+      adPositions.push({
+        impressId: doublet.tag,
+        policy: doublet.timing.insertion,
+        seconds: seconds,
+        vastUrl: ""
+      });
+    }
+    return adPositions.sort((a: AdPosition, b: AdPosition) => {
+      if (a.seconds > b.seconds) {
+        return 1;
+      }
+      return b.seconds > a.seconds ? -1 : 0;
+    });
+  }
+
+  async function selectCorrectAdPositions(allAdPositions: Array<AdPosition>, podcastDuration: number, minIntervalDuration:number, minTailDuration:number): Promise<Array<AdPosition>>{
+    const adPositions: Array<AdPosition> = [];
+    let previousPosition = -1;
+    for(const adPosition of allAdPositions){
+      switch (adPosition.policy) {
+        case "pre":
+          adPositions.push(await defineVastUrl(adPosition));
+          previousPosition = 0;
+          break;
+        case "mid":
+          if (adPosition.seconds > podcastDuration - minTailDuration) {
+            //Too close to end
+            continue;
+          }
+          if (previousPosition >= 0 && adPosition.seconds < previousPosition + minIntervalDuration) {
+            //Too close to previous ad
+            continue;
+          }
+          adPositions.push(await defineVastUrl(adPosition));
+          previousPosition = adPosition.seconds;
+          break;
+        case "post":
+          if (previousPosition >= 0 && previousPosition > podcastDuration - minIntervalDuration) {
+            //Too close to previous ad
+            continue;
+          }
+          adPositions.push(await defineVastUrl(adPosition));
+          break;
+        default:break;
+      }
+    }
+    return adPositions;
+  }
+
+  async function defineVastUrl(adPosition: AdPosition): Promise<AdPosition>{
+    adPosition.vastUrl = await getVastUrl(adPosition.impressId, 1);
+    return adPosition;
+  }
+
+  async function getVastUrl(tag: string, adCount: number): Promise<string>{
+    const baseUrl = "https://api.soundcast.io/v1/vast/"+tag;
+    let keywords: Array<string> = [];
+    if(playerStore.playerPodcast?.tags?.length){
+      const attributes = await saveFetchStore.getOrgaAttributes(playerStore.playerPodcast.organisation.id);
+      if ("true"===attributes["AD_CONFIG_PODCAST_TAG"]) {
+        keywords = playerStore.playerPodcast.tags.map((e) => {
+          return "tag:" + e;
+        });
+      }
+    }
+    const parameters = fetchHelper.getUriSearchParams({
+      adCount: adCount ?? 1,
+      pageUrl:document.referrer,
+      keywords:keywords
+    });
+    return baseUrl + '?' + parameters.toString();
+  }
+
+	return {
+    contentEndedAdsLoader
+	}
+}

package/src/components/composable/player/usePlayerTranscript.ts

@@ -0,0 +1,120 @@
+import { usePlayerStore } from "../../../stores/PlayerStore";
+import { useVastStore } from "../../../stores/VastStore";
+import classicApi from "../../../api/classicApi";
+import { AdserverOtherEmission } from "@/stores/class/adserver/adserverOtherEmission";
+export const usePlayerTranscript = ()=>{
+
+  const playerStore = usePlayerStore();
+  const vastStore = useVastStore();
+
+  async function checkDelaytWithStitching(){
+    playerStore.playerUpdateDelayStitching(0);
+    if(vastStore.useVastPlayerPodcast){return;}
+    const audioPlayer = document.querySelector("#audio-player") as HTMLAudioElement;
+    if (!playerStore.playerTranscript || !audioPlayer || !playerStore.playerPodcast ||
+      audioPlayer.duration <= playerStore.playerPodcast.duration / 1000 + 5) 
+    {
+      return;
+    }
+    const adserverConfig = await classicApi.fetchData<AdserverOtherEmission>({
+      api:0,
+      path:`ad/test/podcast/${playerStore.playerPodcast.podcastId}`,
+      isNotAuth:true
+    });
+    const doubletsLength = adserverConfig.config.doublets.length;
+    if(1=== doubletsLength &&  "pre" === adserverConfig.config.doublets[0].timing.insertion){
+      playerStore.playerUpdateDelayStitching( audioPlayer.duration - (playerStore.playerPodcast.duration / 1000));
+    }else if(0===doubletsLength || 1=== doubletsLength &&  "post" === adserverConfig.config.doublets[0].timing.insertion){
+      return;
+    }else{
+      playerStore.playerUpdateChaptering();
+      playerStore.playerUpdateTranscript();
+    }
+  }
+
+  async function getTranscription(): Promise<void> {
+    if (!playerStore.playerPodcast) {
+      playerStore.playerUpdateTranscript();
+      return;
+    }
+    const result = await classicApi.fetchData<string>({
+      api:11,
+      path:`response/${playerStore.playerPodcast.podcastId}`,
+    });
+
+    const arrayTranscript = parseSrt(result);
+    const actualText =
+      arrayTranscript?.[0]?.startTime === 0 ? arrayTranscript[0].text : "";
+    if(!arrayTranscript){
+      return;
+    }
+    playerStore.playerUpdateTranscript({
+      actual: 0,
+      actualText: actualText,
+      value: arrayTranscript
+    });
+  }
+
+  function parseSrt(transcript: string) {
+    const result = [];
+    if (typeof transcript != "string") {
+      return;
+    }
+    if (transcript == null) {
+      return;
+    }
+    const pattern =
+    /(\d+)\n([\d:,]+)\s+-{2}>\s+([\d:,]+)\n([\s\S]*?(?=\n{2}|$))/gm;
+    transcript = transcript.replace(/\r\n|\r|\n|\t/g, "\n");
+    let matches;
+    while ((matches = pattern.exec(transcript)) != null) {
+      result.push({
+        startTime: srtTimeToSeconds(matches[2]),
+        endTime: srtTimeToSeconds(matches[3]),
+        text: matches[4],
+      });
+    }
+    return result;
+  }
+
+  function srtTimeToSeconds(time: string): number {
+    const a = time.split(":");
+    return +a[0] * 60 * 60 + +a[1] * 60 + +parseFloat(a[2]);
+  }
+
+  function onTimeUpdateTranscript(currentTime: number) {
+    if(!playerStore.playerTranscript?.value.length){
+      return;
+    }
+    const startTime = (playerStore.playerTranscript.value[playerStore.playerTranscript.actual]?.startTime ?? 0) + playerStore.playerDelayStitching;
+    if (startTime <= currentTime) {
+      playerStore.playerTranscript.actualText = playerStore.playerTranscript.value[playerStore.playerTranscript?.actual]?.text ??"";
+    }
+    if (
+      (playerStore.playerTranscript.value[playerStore.playerTranscript.actual]?.endTime ??Infinity) + playerStore.playerDelayStitching< currentTime
+    ) {
+      playerStore.playerTranscript.actual += 1;
+      playerStore.playerTranscript.actualText =
+        playerStore.playerTranscript?.value[playerStore.playerTranscript.actual]?.text ??
+        "";
+    }
+  }
+  
+  function onSeekedTranscript(currentTime: number) {
+    if (playerStore.playerTranscript) {
+      let newActual = 0;
+      while (currentTime >(playerStore.playerTranscript.value[newActual]?.endTime ?? Infinity) + playerStore.playerDelayStitching) {
+        newActual += 1;
+      }
+      playerStore.playerTranscript.actual = newActual;
+    }
+  }
+
+
+	return {
+    checkDelaytWithStitching,
+    getTranscription,
+    onTimeUpdateTranscript,
+    onSeekedTranscript
+	}
+}

package/src/components/composable/player/usePlayerVast.ts

@@ -0,0 +1,207 @@
+import { usePlayerStore } from "../../../stores/PlayerStore";
+import { useVastStore } from "../../../stores/VastStore";
+import { loadScript } from "../../../helper/loadScript";
+import {Ref, ref, watch} from 'vue';
+let adsLoader: any;
+let adsManager:any;
+let adDisplayContainer:any;
+let adsRequest: any;
+export const usePlayerVast = ()=>{
+  const imaLoaded = ref(false);
+  const isContentFinished = ref(false);
+  const audioContainer : Ref<HTMLAudioElement|null>= ref(null);
+  const isAdRequested = ref(false);
+  const statusPlayerWhenLoaded = ref("");
+
+  const playerStore = usePlayerStore();
+  const vastStore = useVastStore();
+
+  watch(() => vastStore.isAdPaused, () => {onAdChangePlayingStatus();});
+  watch(() => vastStore.isAdSkipped, () => {onAdSkipped();});
+
+  function prepareIMA(){
+    if(!imaLoaded.value){
+      imaLoaded.value = true;
+      loadIMA();
+    }else{
+      initializeIMA();
+    }
+  }
+
+  function loadIMA(){
+    loadScript('//imasdk.googleapis.com/js/sdkloader/ima3.js', true, (isIMALoaded:boolean) => {
+      if(isIMALoaded) {
+        initializeIMA();
+      }
+    });
+  }
+
+  function initializeIMA(): void {
+    console.log("Initialize IMA");
+    initializeDisplayContainer();
+    if(!adDisplayContainer || !adsLoader){
+      return;
+    }
+  }
+
+  function onRequestAd(vastUrl: string){
+    isAdRequested.value = true;
+    console.log("Request ad "+vastUrl);
+    initializeAdsRequest(vastUrl);
+    adsLoader.requestAds(adsRequest);
+  }
+
+  function initializeDisplayContainer():void{
+    if(adDisplayContainer){return};
+    audioContainer.value = (document.getElementById('audio-player') as HTMLAudioElement); 
+    if(null===audioContainer.value){return;}
+    adDisplayContainer = new google.ima.AdDisplayContainer(document.getElementById('ad-container'), audioContainer.value);
+    adDisplayContainer.initialize();
+    initializeAdsLoader();
+  }
+
+  function initializeAdsLoader():void{
+    adsLoader = new google.ima.AdsLoader(adDisplayContainer);
+    adsManager = null;
+    adsLoader.addEventListener(
+      google.ima.AdsManagerLoadedEvent.Type.ADS_MANAGER_LOADED,
+      onAdsManagerLoaded,
+      false
+    );
+    adsLoader.addEventListener(
+      google.ima.AdErrorEvent.Type.AD_ERROR,
+      onAdError,
+      false
+    );
+  }
+
+  function initializeAdsRequest(vastUrl: string):void{
+    adsRequest = new google.ima.AdsRequest();
+    adsRequest.setAdWillAutoPlay(true);
+    adsRequest.adTagUrl = vastUrl;
+  }
+
+  function onAdsManagerLoaded(adsManagerLoadedEvent: any) {
+    const adsRenderingSettings = new google.ima.AdsRenderingSettings();
+    adsRenderingSettings.restoreCustomPlaybackStateOnAdBreakComplete = true;
+    adsManager = adsManagerLoadedEvent.getAdsManager(audioContainer.value, adsRenderingSettings);
+    startAdManager();
+  }
+
+  function startAdManager(){
+    console.log("Start manager");
+    initAdManagerEvents();
+    try {
+      adsManager.init(0, 0, google.ima.ViewMode.NORMAL);
+      adsManager.start();
+    } catch (adError) {
+      console.log(adError);
+      playerStore.playerChangeStatus(false);
+      destroyAdManager();
+    }
+  }
+
+  function initAdManagerEvents(){
+    adsManager.addEventListener(google.ima.AdErrorEvent.Type.AD_ERROR,onAdError);
+    adsManager.addEventListener(google.ima.AdEvent.Type.CONTENT_PAUSE_REQUESTED, onContentPauseRequested);
+    adsManager.addEventListener(google.ima.AdEvent.Type.CONTENT_RESUME_REQUESTED, onContentResumeRequested);
+    const events = [
+      google.ima.AdEvent.Type.ALL_ADS_COMPLETED, google.ima.AdEvent.Type.AD_PROGRESS,
+      google.ima.AdEvent.Type.COMPLETE, google.ima.AdEvent.Type.LOADED, 
+      google.ima.AdEvent.Type.PAUSED, google.ima.AdEvent.Type.STARTED,
+    ];
+    for (const index in events) {
+      adsManager.addEventListener(events[index], onAdEvent);
+    }
+  }
+
+  function onAdError(adErrorEvent: any) {
+    console.log(adErrorEvent.getError());
+    destroyAdManager();
+  }
+
+  function destroyAdManager(){
+    if(!adsManager){return;}
+    console.log("Destroy manager");
+    adsManager?.destroy();
+    adsManager = null;
+    vastStore.restartVastData();
+    isContentFinished.value =false;
+    isAdRequested.value = false;
+  }
+
+  function onAdEvent(adEvent: any) {
+    const ad = adEvent.getAd();
+    if(ad){
+      vastStore.updateCurrentAd(ad);
+    }
+    switch (adEvent.type) {
+      case google.ima.AdEvent.Type.LOADED:
+        statusPlayerWhenLoaded.value = playerStore.playerStatus;
+        if (!ad.isLinear()) {
+          playerStore.playerChangeStatus(false);
+          isAdRequested.value = false;
+        }
+        break;
+      case google.ima.AdEvent.Type.STARTED:
+        console.log("Launched status : "+statusPlayerWhenLoaded.value);
+        if("PLAYING"!==statusPlayerWhenLoaded.value){
+          vastStore.updateIsAdPaused(true);
+          adsManager.pause();
+        }
+        break;
+      case google.ima.AdEvent.Type.AD_PROGRESS:{
+        isAdRequested.value = false;
+        const adProgressData = adEvent.getAdData();
+        vastStore.updateProgressionData(adProgressData.duration,adProgressData.currentTime);
+        vastStore.updateSkippableData(
+          vastStore.currentAd.getSkipTimeOffset()!== -1,
+          adsManager.getAdSkippableState(),
+          Math.ceil(vastStore.currentAd.getSkipTimeOffset() - adProgressData.currentTime));
+        break;
+      }
+    }
+  }
+
+  function onContentPauseRequested() {
+    vastStore.updateIsAdPlaying(true);
+    playerStore.playerChangeStatus(true);
+  }
+
+  function onContentResumeRequested() {
+    vastStore.updateIsAdPlaying(false);
+    if (!isContentFinished.value) {
+      playerStore.playerChangeStatus(false);
+    }
+  }
+
+  function contentEndedAdsLoader():void{
+    if (vastStore.isAdPlaying) return;
+    isContentFinished.value = true;
+    adsLoader?.contentComplete();
+  }
+
+  function onAdChangePlayingStatus(){
+    if(!adsManager){return;}
+    if(vastStore.isAdPaused){
+      adsManager.pause();
+    }else{
+      adsManager.resume();
+    }
+  }
+
+  function onAdSkipped(){
+    if(vastStore.isAdSkipped){
+      adsManager.skip();
+    }
+  }
+
+
+	return {
+    isAdRequested,
+    prepareIMA,
+    onRequestAd,
+    destroyAdManager,
+    contentEndedAdsLoader
+	}
+}