Facing issue on flow player integration with Google IMA SDK 3

[ismail-majid]

I am facing following error on flow player 3.2.16

300: PLAYER INITIALIZATION FAILED: TYPEERROR: ERROR #1009

Below is my action-script source for flow player integration, I also get feedback that I am getting this error because of Error #2025: The supplied DisplayObject must be a child of the caller but I am not sure, how to address this.

/*

• Copyright (c) 2011 Andrew Stone
• This file is part of flowplayer-ima. *
• flowplayer-ima is free software: you can redistribute it and/or modify
• it under the terms of the GNU General Public License as published by
• the Free Software Foundation, either version 3 of the License, or
• (at your option) any later version. *
• flowplayer-ima is distributed in the hope that it will be useful,
• but WITHOUT ANY WARRANTY; without even the implied warranty of
• MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
• GNU General Public License for more details. *
• You should have received a copy of the GNU General Public License

• along with flowplayer-ima. If not, see http://www.gnu.org/licenses/. */ package com.iheart.ima {

  import mx.events.FlexEvent;

  import org.flowplayer.controller.VolumeController; import org.flowplayer.model.Clip; import org.flowplayer.model.ClipError; import org.flowplayer.model.ClipEvent; import org.flowplayer.model.ClipEventType; import org.flowplayer.model.DisplayProperties; import org.flowplayer.model.DisplayPropertiesImpl; import org.flowplayer.model.PluginEventType; import org.flowplayer.model.PluginModel; import org.flowplayer.util.Assert; import org.flowplayer.util.Log; import org.flowplayer.util.PropertyBinder; import org.flowplayer.view.Flowplayer;

  import com.google.ads.ima.api.AdErrorEvent; import com.google.ads.ima.api.AdEvent; import com.google.ads.ima.api.AdError; import com.google.ads.ima.api.AdsLoader; import com.google.ads.ima.api.AdsManager; import com.google.ads.ima.api.AdsManagerLoadedEvent; import com.google.ads.ima.api.AdsRenderingSettings; import com.google.ads.ima.api.AdsRequest; import com.google.ads.ima.api.ViewModes; import com.google.ads.ima.api.AdErrorEvent; //import com.google.ads.ima.api.VideoAd; //import org.osmf.events.TimeEvent;

  import flash.display.DisplayObject; import flash.display.MovieClip; import flash.display.Shape; import flash.display.Stage; import flash.media.Video; import flash.net.NetStream; import flash.net.URLLoader; import flash.net.URLRequest; import flash.utils.clearTimeout; import flash.utils.setTimeout; import flash.external.ExternalInterface;

  import flash.events.Event; import flash.events.FullScreenEvent; import flash.events.MouseEvent; import flash.display.DisplayObjectContainer;

  internal class AdPlayer { private var log:Log = new Log(this);

  private var _provider:InteractiveMediaAdsProvider;
  private var _player:Flowplayer;
  private var _config:Config;
  private var _clip:Clip;
  private var _screen:DisplayProperties;
  private var _stage:Stage;
  private var _model:PluginModel;
  
  private var _adInfo:Object
  //private var _currentAd:VideoAd;
  private var _companions:CompanionManager = new CompanionManager();
  private var _video:Video;
  private var _clickTrackingElement:MovieClip;
  private var _adsManager:AdsManager;
  
  private var _dispatchedError:Boolean = false;
  
  //for holding the timer so the ad doesn't get killed
  private var _waitTime:Number;
  private var _flashTime:Number = 0;
  
  private var _volumeController:VolumeController;
  private var _netstream:NetStream;
  
  private var fullScreenExited:Boolean;
  private var contentPlayheadTime:Number;
  
  public function AdPlayer(provider:InteractiveMediaAdsProvider, player:Flowplayer, config:Config, model:PluginModel, clip:Clip) {
    _provider = provider;
    _player = player;
    _screen = player.screen;
    _stage = _player.panel.stage;
    _config = config;
    _model = model;
    _clip = clip;
  
    if (!_model.dispatchBeforeEvent(PluginEventType.PLUGIN_EVENT, Events.BEFORE_AD_LOAD)) {
        log.info('not playing ad');
        return;
    }
  
    log.info('VAST URL: ' + clip.url);
  
    Assert.notNull(clip.url);
  
    var _adsLoader:AdsLoader;
    if (_adsLoader == null) {
        // On the first request, create the AdsLoader.
  
        _adsLoader = new AdsLoader();
        // The SDK uses a 2 stage loading process. Without this call, the second
        // loading stage will take place when ads are requested. Including this
        // call will decrease latency in starting ad playback.
        _adsLoader.loadSdk();
        _adsLoader.addEventListener(AdsManagerLoadedEvent.ADS_MANAGER_LOADED, onAdsLoaded);
        _adsLoader.addEventListener(AdErrorEvent.AD_ERROR, onAdError);
      }
  
    _adsLoader.requestAds(createAdsRequest());
  }
  
  private function remove(child:DisplayObject):void
  {
    if(child && child.parent)
    {
        child.parent.removeChild(child);
        child = null;
    }
  }
  public function set volumeController(c:VolumeController):void {
    _volumeController = c;
  }
  
  public function get time():Number {
    // if (_flashTime != 0) {
        // return _flashTime;
    // }
  
    // if (!_currentAd) {
        // return 0;
    // }
  
    // return _waitTime ? _waitTime : _currentAd.currentTime;
    return 0;
  }
  
  public function get clip():Clip {
    return _clip;
  }
  
  public function stop(e:ClipEvent):void {
    //null when there's an ad error
    if (_netstream) {
        _netstream.close();
    }
  
    if (_clip) {
        _clip.dispatchEvent(e);
    }
  
    cleanup();
  }
  public function interruptStop():void {
    //null when there's an ad error
    if (_netstream) {
        _netstream.close();
    }
    cleanup();
    _dispatchedError = true;
  
  }
  public function pause(e:ClipEvent):void {
    _netstream.pause();
    //_player.panel.getChildAt(1).visible = false;
    //for (var i:int = _player.panel.numChildren - 1; i >= 0; i--) {
    //  _player.panel.getChildAt(i).visible = false;
    //}
    //_player.panel.getChildAt(1).visible = true;
    _clip.dispatchEvent(e);
  }
  
  public function resume(e:ClipEvent):void {
    _netstream.resume();
    //_player.panel.getChildAt(1).visible = true;
    //for (var i:int = _player.panel.numChildren - 1; i >= 0; i--) {
    //  _player.panel.getChildAt(i).visible = true;
    //}
    _clip.dispatchEvent(e);
  }
  
  private function cleanup():void {
    //don't leave the video on the screen
    //null when there's an ad error, and the panel dies
    if (_clickTrackingElement) {
        _player.panel.removeChild(_clickTrackingElement);
    }
  
    //not set when there is an ad error
    if (_adsManager) {
        _adsManager.destroy();
    }
  
    _flashTime = 0;
  
    _provider.adCleanup();
  }
  
  private function dispatchError(id:int, error:String):void {
    if (_dispatchedError) {
        return;
    }
  
    _model.dispatch(PluginEventType.PLUGIN_EVENT, Events.AD_ERROR, id, error);
  
    log.debug("Error from: " + _clip.url);
    _dispatchedError = true;
  
    //There is no nice way to make flowplayer recover from an error
    //in a playlist. this is the best there is, and even still, I had to
    //hack FP to fire a PLAYLIST_COMPLETE event on next
    //  - modifying BufferingState to handle errors fails
    if (_config.nextOnError) {
        _player.next();
    }
  }
  
  private function createAdsRequest():AdsRequest {
    var request:AdsRequest = new AdsRequest();
  
    _video = new Video(_stage.stageWidth, _stage.stageHeight);
    _clickTrackingElement = new MovieClip();
    _clickTrackingElement.addEventListener(MouseEvent.CLICK,onAdClicked1);
    _clickTrackingElement.addChild(_video);
  
    log.debug("clickTrackingElement: " + _clickTrackingElement.width + "x" + _clickTrackingElement.height);
  
    _clip.setContent(_adsManager.adsContainer);
  
    var ct:String;
    ct="";
  
    for (var i:int = _player.panel.numChildren - 1; i >= 0; i--) {
        ct=ct+" control "+i+": "+_player.panel.getChildAt(i);
    }
    request.linearAdSlotHeight = _stage.stageHeight;
    request.linearAdSlotWidth = _stage.stageWidth;
  
    request.nonLinearAdSlotHeight = _stage.stageWidth;
    request.nonLinearAdSlotWidth = _stage.stageWidth;
  
    request.adTagUrl = _clip.url;
    request.disableCompanionAds = _config.disableCompanionAds;
  
    return request;
  }
  
  /**
  * Once the VAST is done loading and all ready
  */
  private function onAdsLoaded(e:AdsManagerLoadedEvent):void {
  if (_dispatchedError) {
        return;
    }
            // Publishers can modify the default preferences through this object.
      var adsRenderingSettings:AdsRenderingSettings =
          new AdsRenderingSettings();
  
      // In order to support VMAP ads, ads manager requires an object that
      // provides current playhead position for the content.
      var contentPlayhead:Object = {};
      contentPlayhead.time = function():Number {
        return contentPlayheadTime * 1000; // convert to milliseconds.
      };
  
      // Get a reference to the AdsManager object through the event object.
      //_adsManager = e.getAdsManager(contentPlayhead, adsRenderingSettings);
      _adsManager = e.getAdsManager(contentPlayhead, adsRenderingSettings);
      if (_adsManager) {
        // Add required ads manager listeners.
        // ALL_ADS_COMPLETED event will fire once all the ads have played. There
        // might be more than one ad played in the case of ad pods and VMAP.
        _adsManager.addEventListener(AdEvent.ALL_ADS_COMPLETED,
                                    allAdsCompletedHandler);
        // If ad is linear, it will fire content pause request event.
        _adsManager.addEventListener(AdEvent.CONTENT_PAUSE_REQUESTED,
                                    contentPauseRequestedHandler);
        // When ad finishes or if ad is non-linear, content resume event will be
        // fired. For example, if VMAP response only has post-roll, content
        // resume will be fired for pre-roll ad (which is not present) to signal
        // that content should be started or resumed.
        _adsManager.addEventListener(AdEvent.CONTENT_RESUME_REQUESTED,
                                    contentResumeRequestedHandler);
        // We want to know when an ad starts.
        _adsManager.addEventListener(AdEvent.STARTED, startedHandler);
        _adsManager.addEventListener(AdErrorEvent.AD_ERROR,
                                    adsManagerPlayErrorHandler);
  
        // If your video player supports a specific version of VPAID ads, pass
        // in the version. If your video player does not support VPAID ads yet,
        // just pass in 1.0.
        _adsManager.handshakeVersion("1.0");
        // Init should be called before playing the content in order for VMAP
        // ads to function correctly.
        _adsManager.init(_player.panel.width,
                        _player.panel.height,
                        ViewModes.NORMAL);
  
        // Add the adsContainer to the display list. Below is an example of how
        // to do it in Flex.
  
        //DisplayObjectContainer(_player.panel).addChild(_clickTrackingElement);
        try{
        //_player.panel.removeView();
        //_player.panel.stage.parent.removeChild(this);
        //_player.panel.parent.removeChild(this);
        //_player.panel.parent.removeChild(_player.panel.stage);
  
        //DisplayObjectContainer(_player.panel.stage).addChild(_clickTrackingElement);
        //_adsManager.setClickTrackingElement(_clickTrackingElement);
        //this.remove(DisplayObjectContainer(_player.panel));
        //_player.panel.addView(_clickTrackingElement, null, null);
        _player.panel.removeChild(_clickTrackingElement);
        //_player.panel.addView(clickTrackingElement, null, null);
        DisplayObjectContainer(_player.panel.addChild(_clickTrackingElement));
        }
        catch(e:Error){
        //log.info("  Error Detail: " + e.message);
        throw e;
        }
        catch (error:*) 
        { 
        throw error;
            //log.info("  Error Detail: " + error);// Catch any other error. 
        } 
        //_player.panel.addView(_clickTrackingElement, "screen", null);
        //_player.panel.addView(_clickTrackingElement, null, DisplayPropertiesImpl.fullSize(null));
        // Start the ad playback.
        _adsManager.start();
      }
  }
  
  private function onFlashContentPauseRequested(event:AdEvent):void {
    log.debug("onFlashContentPauseRequested");
  }
  
  private function onFlashContentResumeRequested(event:AdEvent):void {
    log.debug("onFlashContentResumeRequested");
  
  }
  
  private function onFlashAdSizeChanged(event:AdEvent):void {
    log.debug("Size change: " + event.type);
  }
  
  private function onFlashAdCustomEvent(event:AdEvent):void {
    log.debug("Custom event: " + event.type);
  }
  
  /**
  * Any errors that happen on the network
  */
  private function onAdError(e:AdErrorEvent):void {
    var adError:AdError = e.error;
  
    //_currentAd = null;
    if(adError.errorCode==1001||adError.errorCode==401) //NO_ADS_FOUND=1001,LINEAR_FILE_NOT_FOUND = 401
    {
        ExternalInterface.call("onIMANoAdAvailable", adError.errorMessage+' '+adError.errorCode);
    }
    else
    {
        sendMessageToJs('Error with VAST response: ' + adError.errorMessage+' '+adError.errorCode);
    }
    dispatchError(adError.errorCode, 'Error with VAST response: ' + adError.errorMessage);
  
  }
  private function sendMessageToJs(msg:String):void {
    if(ExternalInterface.available)
        {
            ExternalInterface.call("onIMAError", msg);
        }
    }
  /**
  * A single, specific ad that meets our requirements has been loaded.  No
  * size information about the ad is present in _video.
  */
  private function onAdLoaded(e:AdEvent):void {
    if (_dispatchedError) {
        return;
    }
    //_player.panel.swapChildrenAt(0,1);
    _clip.dispatch(ClipEventType.BEGIN);
    /*_netstream = _volumeController.netStream = e.netStream;
  
    // Doesn't exist for flash ads
    if (e.netStream) {
        e.netStream.client = {
            onMetaData: function(o:Object):void {
                _clip.duration = _clip.durationFromMetadata = Math.ceil(o['duration']);
  
                var m:Object = _clip.metaData;
                m.width = o.width;
                m.height = o.height;
                _clip.metaData = m;
  
                _clip.dispatch(ClipEventType.METADATA);
            }
            //onBufferFull: function():void {}
        };
    }*/
  
    //FP creates a VideoDisplay object to house the tracking element (set in setContent),
    //but it doesn't write it to the screen or anything, so we have to do it manually
    //as well as make sure that its (x,y) are set correctly
    // - see org.flowplayer.view.VideoDisplay@init(): we don't give it a Video object,
    //     so we're never added to the element that gets the correct positioning stuffs
    _clip.onResized(function():void {
        _player.panel.update(_clickTrackingElement, DisplayPropertiesImpl.fullSize(null));
        _player.panel.draw(_clickTrackingElement);
    });
  
    var adType:String = '',
        duration:Number = -1;
  
    // if (e['ad'] && e['ad'] is VideoAd) {
        // _currentAd = e['ad'];
        // adType = MediaTool.getMediaType(_currentAd['mediaUrl']);
        // duration = _currentAd['duration'];
        // _clip.duration = duration;
    // } else {
        // adType = 'flash';
    // }
    // //sendMessageToJs(""+_clip.linkUrl);
    // _adInfo = {
        // adType: adType,
        // description: _currentAd ? _currentAd['description'] : '',
        // duration: duration,
        // companions: _companions.getSpecialCompanions(_adsManager),
        // customProperties: _clip.customProperties,
        // title: _currentAd ? _currentAd['title'] : ''
    // };
  
    log.debug('adloaded');
  
    //dispatch the loaded event before sending companions to the page
    //this allows us to get the page nice and ready for the incoming
    //companions
    _model.dispatch(PluginEventType.PLUGIN_EVENT, Events.AD_LOADED, _adInfo);
    //_companions.displayCompanions(_adsManager);
  }
  
  /*
  * The single ad is playing.
  */
  private var _onAdStarted:Boolean = false;
  private function onAdStarted(e:AdEvent):void {
    ExternalInterface.call("onIMALoaded", e.ad.id);
    //ExternalInterface.call("onIMALoaded", e.ad.mediaUrl);
    sendMessageToJs(e.ad.mediaUrl);
    if (_dispatchedError) {
        return;
    }
  
    //this method fires twice sometimes...no fucking idea why
    //but this seems like pretty standard behavior for flowplayer
    if (_onAdStarted) {
        return;
    }
    _onAdStarted = true;
  
    _model.dispatch(PluginEventType.PLUGIN_EVENT, Events.AD_START, _adInfo);
    _clip.dispatch(ClipEventType.START);
    _clip.dispatch(ClipEventType.BUFFER_FULL);
    _player.panel.addView(_clickTrackingElement, null, DisplayPropertiesImpl.fullSize(null));
  
    //sometimes onFinish just doesn't fire. excellent.
    _clip.onLastSecond(function():void {
        _waitTime = e.ad.currentTime;
    });
  }
  
  /**
  * The ad is done playing.
  */
  private var _onAdComplete:Boolean = false;
  private function onAdComplete(e:AdEvent):void {
    if (_dispatchedError) {
        return;
    }
  
    //this method fires twice sometimes...no fucking idea why
    //but this seems like pretty standard behavior for flowplayer
    if (_onAdComplete) {
        return;
    }
    _onAdComplete = true;
  
    function finish():void {
        log.info('onAdComplete');
  
        cleanup();
  
        _model.dispatch(PluginEventType.PLUGIN_EVENT, Events.AD_FINISH, _adInfo);
        _clip.dispatchBeforeEvent(new ClipEvent(ClipEventType.FINISH));
    }
  
    /*if (_adsManager.type == AdsManagerTypes.FLASH) {
        setTimeout(finish, 500);
    } else {
        finish();
    }*/
    finish();
  }
  private function onAdClicked(e:AdEvent):void {
    if (_dispatchedError) {
        return;
    }
  
    return;
  }
  private function onAdClicked1(e:MouseEvent):void {
    if (_dispatchedError) {
        return;
    }
    ExternalInterface.call("onIMAVideoClicked");
    return;
  }
  
  /**

  • If an error occurs during the ads load, the content can be resumed or
  • another ads request can be made. In this example, the content is resumed
  • if there's an error loading ads. */ private function adsLoadErrorHandler(event:AdErrorEvent):void { trace("warning", "Ads load error: " + event.error.errorMessage); _player.play(); }

  /**

  • If an error occurs during the ads manager play, the content should be
  • resumed. In this example, the content is resumed if there's an error
  • playing ads. */ private function adsManagerPlayErrorHandler(event:AdErrorEvent):void { trace("warning", "Ad playback error: " + event.error.errorMessage); destroyAdsManager(); enableContentControls(); _player.play(); }

  /**

  • Clean up AdsManager references when no longer needed. Explicit cleanup
  • is necessary to prevent memory leaks. */ private function destroyAdsManager():void { enableContentControls(); if (_adsManager) { if (_adsManager.adsContainer.parent && _adsManager.adsContainer.parent.contains(_adsManager.adsContainer)) { _adsManager.adsContainer.parent.removeChild(_adsManager.adsContainer); } _adsManager.destroy(); } }

  /**

  • The AdsManager raises this event when it requests the publisher to pause
  • the content. _/ private function contentPauseRequestedHandler(event:AdEvent):void { // The ad will cover a large portion of the content, therefore content // must be paused. /_if (_player.playing) { _player.pause(); } // Manually flip play button state. _player.playPauseButton.selected = !_player.playPauseButton.selected; // Rewire controls to affect ads manager instead of the content video. enableLinearAdControls(); // Ads usually do not allow scrubbing. canScrub = false;*/ }

  /**

  • The AdsManager raises this event when it requests the publisher to resume
  • the content. */ private function contentResumeRequestedHandler(event:AdEvent):void { // Rewire controls to affect content instead of the ads manager. enableContentControls(); _player.play(); }

  /**

  • The AdsManager raises this event when the ad has started. */ private function startedHandler(event:AdEvent):void { // If the ad exists and is a non-linear, start the content with the ad. if (event.ad != null && !event.ad.linear) { _player.play(); } }

  /**

  • The AdsManager raises this event when all ads for the request have been
  • played. */ private function allAdsCompletedHandler(event:AdEvent):void { // Ads manager can be destroyed after all of its ads have played. destroyAdsManager(); }

  /**

  • The video player raises this event when the user clicks the play/pause
  • button. _/ private function playPauseButtonHandler(event:MouseEvent):void { // Prevent video player from receiving the event, because it would affect // content. /_event.stopImmediatePropagation(); var paused:Boolean = !_player.playPauseButton.selected; if (paused) { _adsManager.pause(); } else { _adsManager.resume(); }*/ }

  /**

  • Switches the video player controls to control the video ad. _/ private function enableLinearAdControls():void { // Subscribe to the the player control click events with maximum // priority, so that we can handle the click before it is handled by the // VideoPlayer instance. /__player.playPauseButton.addEventListener(MouseEvent.CLICK, playPauseButtonHandler, false, // use capture. int.MAX_VALUE); _player.volumeBar.addEventListener(Event.CHANGE, volumeChangeHandler, false, // use capture. int.MAX_VALUE); _player.volumeBar.addEventListener(FlexEvent.MUTED_CHANGE, volumeMutedHandler, false, // use capture. int.MAX_VALUE);*/ }

  /**

  • Switches the video player controls to control the content. _/ private function enableContentControls():void { /__player.playPauseButton.removeEventListener(MouseEvent.CLICK, playPauseButtonHandler); _player.volumeBar.removeEventListener(Event.CHANGE, volumeChangeHandler); _player.volumeBar.removeEventListener(FlexEvent.MUTED_CHANGE, volumeMutedHandler); canScrub = true;*/ }

  private function volumeMutedHandler(event:FlexEvent):void { // Prevent video player from receiving the event, because it would affect // content. event.stopImmediatePropagation(); //_adsManager.volume = 0; }

  private function volumeChangeHandler(event:Event):void { // Prevent video player from receiving the event, because it would affect // content. event.stopImmediatePropagation(); //_adsManager.volume = _player.volumeBar.value; }

  private function set canScrub(value:Boolean):void { //_player.scrubBar.enabled = value; //_player.scrubBar.mouseEnabled = value; }

  /**

  • Update the playhead time for the AdsManager.

  private function contentPlayheadTimeChangeHandler(event:TimeEvent):void { contentPlayheadTime = event.time; }*/

  private function fullscreenChangeHandler(event:FullScreenEvent):void { if (event.fullScreen) { _adsManager.resize(_player.panel.width, _player.panel.height, ViewModes.FULLSCREEN); } else { fullScreenExited = true; // Ads manager resize will occur after update complete. } }

  /**

  • Workaround for a bug in the video player's full screen functionality. */ private function videoPlayerUpdateCompleteHandler(event:FlexEvent):void { if (fullScreenExited) { fullScreenExited = false; _adsManager.resize(_player.panel.width, _player.panel.height, ViewModes.NORMAL); } }

  /**

  • The video player raises this event when the content has finished playing.

  private function contentCompleteHandler(event:TimeEvent):void { _player.stage.removeEventListener(FullScreenEvent.FULL_SCREEN, fullscreenChangeHandler); _player.removeEventListener(FlexEvent.UPDATE_COMPLETE, videoPlayerUpdateCompleteHandler); _player.removeEventListener(TimeEvent.COMPLETE, contentCompleteHandler); // Tell the SDK when any content completes, even content without ads. The // SDK uses this method for better ad selection (especially VMAP). adsLoader.contentComplete(); }*/ } }

[ismail-majid]

I am still waiting for any suggestion on this issue. I will be grateful, if anyone can suggest me anything.

[thatguystone]

Could you post your player config?

[ismail-majid]

I am attaching the front end flow player implementation, where I am using the swf generated from above script.

Change the file externsion to rar from png. Thank You.

[ismail-majid]

I am still waiting for response on this.

[thatguystone]

Well, you've probably noticed that Google has killed support for IMAv2, so this is rather untestable now :disappointed: If you'd like to try your hand at getting this working for IMAv3, I'm happy to entertain pull requests.

In your test, though, there were a few issues. Your config should look like this:

flowplayer("player", "flowplayer.commercial-"+version+".swf", {
    log: {
        level: 'error',
        filter:'*'
    },
    plugins: {
        ima: {
            url: "flowplayer.ima-3.2.7.swf"
        }
    },
    playlist: [
        {
            provider: 'ima',
            url: url
        }
    ]
});

There should be no mention of scheduling or anything of the like with the plugin.

For now, you might want to give Flowplayer HTML5 Ads a look: http://demos.flowplayer.org/ads/videoad.html

[divyenduz]

Was this replicated or resolved ? I am facing similar issue in FP 6.

Skippable ad calls for ad EP once it is over and if it is filled with another ad, it plays twice.

[thatguystone]

I doubt this will ever be resolved. This uses Google's Flash IMA SDK v2, which was deprecated long ago. Even upgrading to v3 would be pointless since Google is going to deprecate their entire Flash IMA SDK on June 1, 2017 (https://developers.google.com/interactive-media-ads/docs/sdks/flash/quickstart).