Cheat Engine

[InternetIsSeriousBusiness]

package com.tubemogul.inplay.error {

public class TerminatedError extends Error {

public function TerminatedError(_arg1:String=""){
name = "TerminatedError";
message = ((_arg1) ? _arg1 : "InPlay terminated!");
}
}
}//package com.tubemogul.inplay.error
package com.tubemogul.inplay.log {
import com.tubemogul.inplay.util.*;

public class Log extends AbstractLog {

private static var _debugLog:Log = null;

public static function set debugOn(_arg1:Boolean):void{
debugLog.level = ((_arg1)==true) ? LogLevel.DEBUG : LogLevel.OFF;
}
public static function debugLevelPassedIn():int{
var _local1:String = CoreUtils.checkForParam("debugLevel", "OFF");
return (LogLevel.getLevelValue(_local1));
}
public static function error(_arg1:Object, _arg2:String=""):void{
if (debugLog){
debugLog.log(LogLevel.ERROR, _arg1, _arg2);
};
}
public static function fatal(_arg1:Object, _arg2:String=""):void{
if (debugLog){
debugLog.log(LogLevel.FATAL, _arg1, _arg2);
};
}
public static function warn(_arg1:Object, _arg2:String=""):void{
if (debugLog){
debugLog.log(LogLevel.WARN, _arg1, _arg2);
};
}
public static function info(_arg1:Object, _arg2:String=""):void{
if (debugLog){
debugLog.log(LogLevel.INFO, _arg1, _arg2);
};
}
public static function get debugLog():Log{
return (_debugLog);
}
public static function logException(_arg1:String, _arg2:int, _arg3:Error):void{
if (debugLog){
debugLog.logException(_arg1, _arg2, _arg3);
};
}
public static function debug(_arg1:Object, _arg2:String=""):void{
if (debugLog){
debugLog.log(LogLevel.DEBUG, _arg1, _arg2);
};
}
public static function init():void{
if (!_debugLog){
_debugLog = new (Log)();
};
}
public static function dumpObject(_arg1:String, _arg2:Object):void{
if (debugLog){
debugLog.dumpObject(_arg1, _arg2);
};
}
public static function dumpException(_arg1:String, _arg2:int, _arg3:Error):void{
if (debugLog){
debugLog.dumpException(_arg1, _arg2, _arg3);
};
}

}
}//package com.tubemogul.inplay.log
package com.tubemogul.inplay.log {
import flash.events.*;
import flash.net.*;

public class SharedObject_IP {

public static const STATE_SET:String = "SET";
public static const STATE_TBD:String = "TBD";
public static const STATE_PENDING:String = "PENDING";
public static const STATE_NOT_ALLOWED:String = "NOT_ALLOWED";

private var _name:String = "";
private var _minDisk:int = 0;
private var _state:String = "PENDING";
private var _so:SharedObject;
private var _pendingCallback:Function = null;

public function SharedObject_IP(_arg1:String, _arg2:Function=null, _arg3:int=4000){
var name:* = _arg1;
var pendingCallback = _arg2;
var minDiskSpace:int = _arg3;
super();
var retVal:* = "";
try {
_so = SharedObject.getLocal(name, "/", false);
_so.objectEncoding = ObjectEncoding.AMF0;
_name = name;
_minDisk = minDiskSpace;
_pendingCallback = pendingCallback;
update();
} catch(err:Error) {
Log.info(("Problem reading/creating shared object " + name));
_state = STATE_NOT_ALLOWED;
};
}
public static function getLocal(_arg1:String, _arg2:String=null, _arg3:Boolean=false):SharedObject{
return (SharedObject.getLocal(_arg1, _arg2, _arg3));
}

public function get size():uint{
return (_so.size);
}
public function get client():Object{
return (_so.client);
}
public function set client(_arg1:Object):void{
_so.client = _arg1;
}
private function pendingUpdate(_arg1:NetStatusEvent):void{
if (_arg1.info.level == "error"){
return;
};
Log.debug("SharedObject_IP: Shared object no longer pending");
_so.removeEventListener(NetStatusEvent.NET_STATUS, this.pendingUpdate);
update();
}
public function get allowed():Boolean{
return (!((_state == STATE_NOT_ALLOWED)));
}
public function update():Boolean{
var retVal:* = null;
try {
retVal = flush();
if (retVal == SharedObjectFlushStatus.PENDING){
Log.debug(("Shared object pending: " + _name));
_state = STATE_PENDING;
if (_pendingCallback != null){
_so.addEventListener(NetStatusEvent.NET_STATUS, _pendingCallback);
} else {
_so.addEventListener(NetStatusEvent.NET_STATUS, this.pendingUpdate);
};
return (false);
};
if (_so.size == 0){
Log.debug(("Shared object TBD: " + _name));
_state = STATE_TBD;
return (false);
};
if (retVal == SharedObjectFlushStatus.FLUSHED){
_state = STATE_SET;
return (true);
};
Log.error(("SharedObject.flush returned unknown value: " + retVal));
_state = STATE_NOT_ALLOWED;
return (false);
} catch(err:Error) {
Log.info(("Problem updating shared object " + _name));
_state = STATE_NOT_ALLOWED;
};
return (false);
}
public function flush():Object{
return (_so.flush(_minDisk));
}
public function clear():void{
_so.clear();
_state = STATE_PENDING;
}
public function get state():String{
return (_state);
}
public function updateField(_arg1:String, _arg2:Object):Boolean{
if (!allowed){
return (false);
};
_so.data[_arg1] = _arg2;
return (update());
}
public function get data():Object{
return (_so.data);
}

}
}//package com.tubemogul.inplay.log
package com.tubemogul.inplay.log {
import flash.events.*;
import com.tubemogul.inplay.util.*;

public class AbstractLog extends EventDispatcher {

private var _level:uint = 5;

public function debug(_arg1:Object, _arg2:String=""):void{
log(LogLevel.DEBUG, _arg1, _arg2);
}
public function get level():int{
return (_level);
}
public function warn(_arg1:Object, _arg2:String=""):void{
log(LogLevel.WARN, _arg1, _arg2);
}
public function set level(_arg1:int):void{
_level = _arg1;
}
public function fatal(_arg1:Object, _arg2:String=""):void{
log(LogLevel.FATAL, _arg1, _arg2);
}
public function info(_arg1:Object, _arg2:String=""):void{
log(LogLevel.INFO, _arg1, _arg2);
}
public function error(_arg1:Object, _arg2:String=""):void{
log(LogLevel.ERROR, _arg1, _arg2);
}
public function logException(_arg1:String, _arg2:uint, _arg3:Error):void{
dumpException(_arg1, _arg2, _arg3);
}
public function dumpObject(_arg1:String, _arg2:Object):void{
var _local3:String;
if (!_arg2){
debug((("--------</" + _arg1) + ">--------"));
return;
};
debug((("--------<" + _arg1) + ">--------"));
for (_local3 in _arg2) {
debug(((_local3 + " = ") + _arg2[_local3]));
};
debug((("--------</" + _arg1) + ">--------"));
}
public function dumpException(_arg1:String, _arg2:uint, _arg3:Error):void{
log(_arg2, ("Unintentional exception in " + _arg1));
log(_arg2, (" message = " + _arg3.message));
log(_arg2, (" name = " + _arg3.name));
log(_arg2, _arg3.getStackTrace());
}
public function log(_arg1:uint, _arg2:Object, _arg3:String="object"):void{
var _local4:LogEvent = new LogEvent(_arg1, _arg2, _arg3);
dispatchEvent(_local4);
}

}
}//package com.tubemogul.inplay.log
package com.tubemogul.inplay.log {
import flash.events.*;

public class LogEvent extends Event {

public static const LOG_EVENT:String = "LOG_EVENT";

public var objectName:String;
public var level:uint;
public var object:Object;

public function LogEvent(_arg1:uint, _arg2:Object, _arg3:String="object"):void{
super(LOG_EVENT);
this.level = _arg1;
this.object = _arg2;
this.objectName = _arg3;
}
}
}//package com.tubemogul.inplay.log
package com.tubemogul.inplay.log {
import com.tubemogul.inplay.*;
import com.tubemogul.inplay.util.*;

public class LogTracer {

private var _log:AbstractLog = null;

public function LogTracer(_arg1:AbstractLog){
_log = _arg1;
_arg1.addEventListener(LogEvent.LOG_EVENT, output);
}
private function output(_arg1:LogEvent):void{
var _local2:String;
if (_arg1.level < _log.level){
return;
};
if (((!(_arg1.object)) || ((_arg1.object == "")))){
return;
};
if ((typeof(_arg1.object) as String) == "string"){
_local2 = LogLevel.getLevelStr(_arg1.level);
trace(((((_local2 + ": ") + CoreUtils.getCurrentTime()) + ": ") + _arg1.object.toString()));
} else {
_log.dumpObject(_arg1.objectName, _arg1.object);
};
}

}
}//package com.tubemogul.inplay.log
package com.tubemogul.inplay.log {
import flash.events.*;
import com.tubemogul.inplay.*;

public class UserLogBroadcaster {

private var _userLog:EventDispatcher = null;

public function UserLogBroadcaster(_arg1:AbstractLog, _arg2:EventDispatcher){
_userLog = _arg2;
_arg1.addEventListener(LogEvent.LOG_EVENT, output);
}
private function output(_arg1:LogEvent):void{
var _local2:String;
if (((!(_arg1.object)) || ((_arg1.object == "")))){
return;
};
if ((typeof(_arg1.object) as String) != "string"){
return;
};
if (!_userLog){
return;
};
switch (_arg1.level){
case LogLevel.DEBUG:
_local2 = InPlayLogEvent.DEBUG;
break;
case LogLevel.INFO:
_local2 = InPlayLogEvent.INFO;
break;
case LogLevel.WARN:
_local2 = InPlayLogEvent.WARN;
break;
case LogLevel.ERROR:
case LogLevel.FATAL:
_local2 = InPlayLogEvent.ERROR;
break;
default:
return;
};
_userLog.dispatchEvent(new InPlayLogEvent(_local2, (_arg1.object as String)));
}

}
}//package com.tubemogul.inplay.log
package com.tubemogul.inplay.log {
import com.tubemogul.inplay.util.*;

public class LogLevel {

public static const FATAL:int = 4;
public static const WARN:int = 2;
public static const ERROR:int = 3;
public static const INFO:int = 1;
public static const OFF:int = 5;
public static const DEBUG:int = 0;
private static const _logLevels:Array = new Array("DEBUG", "INFO", "WARN", "ERROR", "FATAL", "OFF");

public static function getLevelStr(_arg1:int):String{
return (_logLevels[_arg1]);
}
public static function getLevelValue(_arg1:String):int{
var _local2:int;
while (_local2 < _logLevels.length) {
if (_arg1 == _logLevels[_local2]){
return (_local2);
};
_local2++;
};
return (-1);
}

}
}//package com.tubemogul.inplay.log
package com.tubemogul.inplay.test.integ {
import com.tubemogul.inplay.log.*;

public class IntegLog extends AbstractLog {

public static var _log:IntegLog = null;

public static function init():void{
if (!_log){
_log = new (IntegLog)();
};
}
public static function debug(_arg1:Object):void{
if (_log){
_log.log(LogLevel.DEBUG, _arg1);
};
}
public static function fatal(_arg1:Object):void{
if (_log){
_log.log(LogLevel.FATAL, _arg1);
};
}
public static function warn(_arg1:Object):void{
if (_log){
_log.log(LogLevel.WARN, _arg1);
};
}
public static function error(_arg1:Object):void{
if (_log){
_log.log(LogLevel.ERROR, _arg1);
};
}
public static function dumpObject(_arg1:String, _arg2:Object):void{
if (_log){
_log.dumpObject(_arg1, _arg2);
};
}
public static function logException(_arg1:String, _arg2:int, _arg3:Error):void{
if (_log){
_log.logException(_arg1, _arg2, _arg3);
};
}
public static function info(_arg1:Object):void{
if (_log){
_log.log(LogLevel.INFO, _arg1);
};
}

}
}//package com.tubemogul.inplay.test.integ
package com.tubemogul.inplay.test.integ {
import flash.events.*;

public class IntegApi implements IEventDispatcher {

private static var _integApi:IntegApi = null;

private var _dispatcher:EventDispatcher = null;
private var _testMode:Boolean = false;

public function IntegApi(_arg1:Boolean){
if (!_arg1){
return;
};
_testMode = _arg1;
_dispatcher = new EventDispatcher();
}
public static function get api():IntegApi{
return (_integApi);
}
public static function init(_arg1:Boolean):void{
if (!_integApi){
_integApi = new IntegApi(_arg1);
};
}

public function dispatchEvent(_arg1:Event):Boolean{
var event:* = _arg1;
if (!_testMode){
return (false);
};
try {
IntegLog.debug(("***** Dispatching integ API event: " + event.toString()));
(event as IntegEvent).validate();
return (_dispatcher.dispatchEvent(event));
} catch(err:TestFailedError) {
IntegLog.error("Got TestFailedError. Calling dispatchIntegEvent.");
} catch(err:Error) {
IntegLog.error(("Got exception: " + err.message));
};
return (false);
}
public function dispatchIntegEvent(_arg1:String, _arg2:Object=null):Boolean{
return (dispatchEvent(new IntegEvent(_arg1, _arg2)));
}
public function removeEventListener(_arg1:String, _arg2:Function, _arg3:Boolean=false):void{
_dispatcher.removeEventListener(_arg1, _arg2, _arg3);
}
public function willTrigger(_arg1:String):Boolean{
return (_dispatcher.willTrigger(_arg1));
}
public function hasEventListener(_arg1:String):Boolean{
return (_dispatcher.hasEventListener(_arg1));
}
public function addEventListener(_arg1:String, _arg2:Function, _arg3:Boolean=false, _arg4:int=0, _arg5:Boolean=false):void{
_dispatcher.addEventListener(_arg1, _arg2, _arg3, _arg4, _arg5);
}

}
}//package com.tubemogul.inplay.test.integ
package com.tubemogul.inplay.test.integ {
import flash.events.*;
import com.tubemogul.inplay.log.*;

public class InPlayIntegTestRunner {

private var _integLogBroadcaster:UserLogBroadcaster;

public function InPlayIntegTestRunner(_arg1:Boolean, _arg2:EventDispatcher){
IntegApi.init(_arg1);
if (!_arg1){
return;
};
IntegLog.init();
IntegLog._log.level = LogLevel.INFO;
_integLogBroadcaster = new UserLogBroadcaster(IntegLog._log, _arg2);
var _local3:InPlayCoreTest = new InPlayCoreTest();
_local3.run();
}
public static function run(_arg1:Boolean, _arg2:EventDispatcher):void{
var _local3:InPlayIntegTestRunner = new InPlayIntegTestRunner(_arg1, _arg2);
}

}
}//package com.tubemogul.inplay.test.integ
package com.tubemogul.inplay.test.integ {
import flash.events.*;
import com.tubemogul.inplay.*;
import com.tubemogul.inplay.util.*;

public class IntegEvent extends Event {

public static const TIMEOUT:String = "TIMEOUT";
public static const SHUT_OFF:String = "SHUT_OFF";
public static const PLAYER_REFERRER_URL:String = "PLAYER_REFERRER_URL";
public static const KEY:String = "KEY";
public static const DELAY:String = "DELAY";
public static const PLAYER_UPDATE:String = "PLAYER_UPDATE";
public static const PLAYER_INIT:String = "PLAYER_INIT";
public static const PLAYER_BROWSER_URL:String = "PLAYER_BROWSER_URL";
public static const FAILED:String = "FAILED";
public static const PLAYER_SETUP:String = "PLAYER_SETUP";

private static var _idAlloc:int = 1;

private var _params:Object;
private var _id:int;

public function IntegEvent(_arg1:String, _arg2:Object=null){
super(_arg1);
_params = _arg2;
_id = _idAlloc++;
}
public static function get STREAM_LOAD():String{
return ("STREAM_LOAD");
}
public static function get STREAM_METADATA():String{
return ("STREAM_METADATA");
}
public static function get STREAM_PLAY():String{
return ("STREAM_PLAY");
}
public static function get STREAM_CLOSE():String{
return ("STREAM_CLOSE");
}
public static function get STREAM_PAUSE():String{
return ("STREAM_PAUSE");
}
public static function get STREAM_STOP():String{
return ("STREAM_STOP");
}
public static function get ACTIVITY_REPORT():String{
return ("ACTIVITY_REPORT");
}
public static function get STREAM_SETUP():String{
return ("STREAM_SETUP");
}
public static function get STREAM_SEEK():String{
return ("STREAM_SEEK");
}
public static function get STREAM_REWIND():String{
return ("STREAM_REWIND");
}
public static function get STREAM_INIT():String{
return ("STREAM_INIT");
}

public function get params():Object{
return (_params);
}
public function get id():int{
return (_id);
}
override public function toString():String{
return (formatToString("IntegEvent", "type", "bubbles", "cancelable", "params", "id"));
}
public function validate():void{
switch (type){
case PLAYER_INIT:
case PLAYER_BROWSER_URL:
case PLAYER_REFERRER_URL:
CoreUtils.assertNotNull(params, (type + " event missing parameters"));
CoreUtils.assertNotNull(params.player, (type + " event missing player parameter"));
break;
case PLAYER_SETUP:
case PLAYER_UPDATE:
CoreUtils.assertNotNull(params, (type + " event missing parameters"));
CoreUtils.assertNotNull(params.player, (type + " event missing player parameter"));
CoreUtils.assertNotNull(params.req, (type + " event missing req parameter"));
break;
case STREAM_INIT:
case STREAM_LOAD:
case STREAM_PLAY:
case STREAM_METADATA:
case STREAM_PAUSE:
case STREAM_SEEK:
case STREAM_STOP:
case STREAM_REWIND:
case STREAM_CLOSE:
CoreUtils.assertNotNull(params, (type + " event missing parameters"));
CoreUtils.assertNotNull(params.stream, (type + " event missing stream parameter"));
break;
case STREAM_SETUP:
case ACTIVITY_REPORT:
CoreUtils.assertNotNull(params, (type + " event missing parameters"));
CoreUtils.assertNotNull(params.stream, (type + " event missing stream parameter"));
CoreUtils.assertNotNull(params.req, (type + " event missing req parameter"));
break;
case TIMEOUT:
case FAILED:
case DELAY:
case KEY:
case SHUT_OFF:
break;
default:
CoreUtils.assert(false, ("Received unknown IntegEvent type: " + type));
};
}

}
}//package com.tubemogul.inplay.test.integ
package com.tubemogul.inplay.test.integ {
import com.tubemogul.inplay.model.*;
import com.tubemogul.inplay.*;
import com.tubemogul.inplay.request.*;
import com.tubemogul.inplay.util.*;

public class InPlayCoreTest extends IntegTest {

private var _prevStream:Stream;

public function onStop(_arg1:IntegEvent):void{
callToAction("Thank you. If your player supports replaying the video, please do so.");
expectEvent(IntegEvent.STREAM_PLAY, null, false, onReplay, DEF_TIMEOUT, onStop2);
expectEvent(IntegEvent.STREAM_SETUP, null, false, onReplayStreamSetup);
}
public function onStreamParamsDone(_arg1:IntegEvent):void{
callToAction("Thank you. Please resume the video.");
expectEvent(IntegEvent.STREAM_PLAY, null, true, onResume);
}
private function onDone(_arg1:IntegEvent):void{
done();
}
public function onActRept(_arg1:IntegEvent):void{
var _local2:ActivityReport = _arg1.params.req;
assert((_local2.playTimeStart == 0), "Playhead start time not 0.");
assert((_local2.playTimeEnd > 0), "Playhead end time not > 0.");
assert(_local2.wentForward(), "Playhead did not advance.");
callToAction("Thank you. Please press pause now.");
expectEvent(IntegEvent.ACTIVITY_REPORT, null, true, onActRept2);
expectEvent(IntegEvent.STREAM_PAUSE, null, true, onPause);
}
override public function run():void{
IntegLog.info("********** Starting InPlay Integration Test Suite **********");
expectEvent(IntegEvent.SHUT_OFF, null, false, onShutoff, NO_TIMEOUT);
expectEvent(IntegEvent.PLAYER_INIT, null, true, onPlayerInit);
expectEvent(IntegEvent.PLAYER_BROWSER_URL, null, true, onBrowserURL);
expectEvent(IntegEvent.PLAYER_REFERRER_URL, null, true, onReferrerURL);
expectEvent(IntegEvent.PLAYER_SETUP, null, true, onPlayerSetup);
}
public function onPlayerInit(_arg1:IntegEvent):void{
expectEvent(IntegEvent.STREAM_INIT, null, true, null, NO_TIMEOUT);
expectEvent(IntegEvent.STREAM_LOAD, null, true, null, NO_TIMEOUT);
expectEvent(IntegEvent.STREAM_METADATA, null, true, null, NO_TIMEOUT);
}
public function onStop2(_arg1:IntegEvent):void{
callToAction("Thank you. If your player supports playlists, please play another video.");
expectEvent(IntegEvent.STREAM_PLAY, null, false, null, DEF_TIMEOUT, onDone);
expectEvent(IntegEvent.STREAM_SETUP, null, false, onStreamSetup2);
}
public function onPause(_arg1:IntegEvent):void{
var _local2:Stream = _arg1.params.stream;
_arg1.params.stream.dumpParams(IntegLog._log);
callToAction("Please verify your stream-level parameters above. Resume the video when ready.", NO_TIMEOUT);
expectEvent(IntegEvent.STREAM_PLAY, null, true, onResume, NO_TIMEOUT);
warn(CoreUtils.notNull(_local2.videoInfo.videoID), "Did not get a videoID.");
warn(CoreUtils.notNull(_local2.videoInfo.publisherID), "Did not get a publisherID.");
warn(CoreUtils.notNull(_local2.videoInfo.displayName), "Did not get a displayName.");
}
public function onActReptReplay(_arg1:IntegEvent):void{
var _local2:ActivityReport = _arg1.params.req;
assert((_local2.playTimeStart == 0), "Playhead start time not 0.");
assert((_local2.playTimeEnd > 0), "Playhead end time not > 0.");
assert(_local2.wentForward(), "Playhead did not advance.");
callToAction("Thank you. Please seek / scrub close to the end of the video.");
expectEvent(IntegEvent.STREAM_SEEK, null, true, onSeek2);
expectEvent(IntegEvent.ACTIVITY_REPORT, null, true, null);
}
public function onSeek2(_arg1:IntegEvent):void{
callToAction("Thank you. Please let the video finish.", 120);
expectEvent(IntegEvent.ACTIVITY_REPORT, null, true, null, 120);
expectEvent(IntegEvent.STREAM_PLAY, null, true, null, 120);
expectEvent(IntegEvent.STREAM_STOP, null, true, onStop2, 120);
}
public function onShutoff(_arg1:IntegEvent):void{
fail("Player was shut off. Likely is not activated properly. Check with TubeMogul for assistance.");
}
public function onReplayStreamSetup(_arg1:IntegEvent):void{
var _local2:Stream = _arg1.params.stream;
IntegLog.debug("In onReplayStreamSetup.");
IntegLog.debug(("stream.videoInfo.fileName = " + _local2.videoInfo.fileName));
IntegLog.debug(("_prevStream.videoInfo.fileName = " + _prevStream.videoInfo.fileName));
assertNotNull(_local2.videoInfo.duration, "Did not get a duration from metadata.");
assert((_local2.videoInfo.duration == _prevStream.videoInfo.duration), "Duration does not match previous stream.");
assertNotNull(_local2.videoInfo.fileName, "Did not get a filename.");
assert((_local2.videoInfo.fileName == _prevStream.videoInfo.fileName), "Filename does not match previous stream.");
if (CoreUtils.notNull(_local2.videoInfo.videoID)){
assert((_local2.videoInfo.videoID == _prevStream.videoInfo.videoID), "videoID does not match previous stream.");
} else {
warn(false, "Did not get a videoID.");
};
if (CoreUtils.notNull(_local2.videoInfo.publisherID)){
assert((_local2.videoInfo.publisherID == _prevStream.videoInfo.publisherID), "publisherID does not match previous stream.");
} else {
warn(false, "Did not get a publisherID.");
};
if (CoreUtils.notNull(_local2.videoInfo.displayName)){
assert((_local2.videoInfo.displayName == _prevStream.videoInfo.displayName), "displayName does not match previous stream.");
} else {
warn(false, "Did not get a displayName.");
};
_prevStream = _local2;
IntegLog.debug(("++++++++++++++++++++ Storing previous stream: " + _prevStream.videoInfo.fileName));
}
public function onBrowserURL(_arg1:IntegEvent):void{
warn(CoreUtils.notNull(_arg1.params.browserURL), "Did not get the browser URL properly!");
}
public function onPlayerParamsDone(_arg1:IntegEvent):void{
callToAction("Please play a video in the player.");
expectEvent(IntegEvent.STREAM_PLAY, null, true, null);
expectEvent(IntegEvent.STREAM_SETUP, null, true, onStreamSetup);
}
public function onResume(_arg1:IntegEvent):void{
callToAction("Thank you. Please seek / scrub close to the end of the video.");
expectEvent(IntegEvent.STREAM_SEEK, null, true, onSeek);
expectEvent(IntegEvent.ACTIVITY_REPORT, null, true, null);
}
public function onReplay(_arg1:IntegEvent):void{
callToAction("Thank you.");
expectEvent(IntegEvent.ACTIVITY_REPORT, null, true, onActReptReplay);
}
public function onActRept2(_arg1:IntegEvent):void{
var _local2:ActivityReport = _arg1.params.req;
assert(_local2.wentForward(), "Playhead did not advance.");
}
public function onReferrerURL(_arg1:IntegEvent):void{
warn(CoreUtils.notNull(_arg1.params.referrerURL), "Did not get the referrer URL properly!");
}
public function onStreamSetup2(_arg1:IntegEvent):void{
var _local2:Stream = _arg1.params.stream;
IntegLog.debug("In onStreamSetup2.");
IntegLog.debug(("++++++++++++++++++++ stream.videoInfo.fileName = " + _local2.videoInfo.fileName));
IntegLog.debug(("++++++++++++++++++++ _prevStream.videoInfo.fileName = " + _prevStream.videoInfo.fileName));
assertNotNull(_local2.videoInfo.duration, "Did not get a duration from metadata.");
assertNotNull(_local2.videoInfo.fileName, "Did not get a filename.");
assert(!((_local2.videoInfo.fileName == _prevStream.videoInfo.fileName)), "Filename matches previous stream.");
callToAction("Please verify your stream-level parameters above. Pause the video when done.", NO_TIMEOUT);
expectEvent(IntegEvent.STREAM_PAUSE, null, true, onDone, NO_TIMEOUT);
if (CoreUtils.notNull(_local2.videoInfo.videoID)){
warn(!((_local2.videoInfo.videoID == _prevStream.videoInfo.videoID)), "videoID matches previous stream.");
} else {
warn(false, "Did not get a videoID.");
};
if (CoreUtils.notNull(_local2.videoInfo.publisherID)){
warn(!((_local2.videoInfo.publisherID == _prevStream.videoInfo.publisherID)), "publisherID matches previous stream.");
} else {
warn(false, "Did not get a publisherID.");
};
if (CoreUtils.notNull(_local2.videoInfo.displayName)){
warn(!((_local2.videoInfo.displayName == _prevStream.videoInfo.displayName)), "displayName matches previous stream.");
} else {
warn(false, "Did not get a displayName.");
};
}
public function onSeek(_arg1:IntegEvent):void{
callToAction("Thank you. Please let the video finish.", 120);
expectEvent(IntegEvent.ACTIVITY_REPORT, null, true, null, 120);
expectEvent(IntegEvent.STREAM_PLAY, null, true, null, 120);
expectEvent(IntegEvent.STREAM_STOP, null, true, onStop, 120);
}
override public function verify():void{
}
public function onPlayerSetup(_arg1:IntegEvent):void{
CoreUtils.assertNotNull(_arg1.params, "No parameters provided!");
CoreUtils.assertNotNull(_arg1.params.player, "No params.player provided!");
var _local2:Player = _arg1.params.player;
assert(((((CoreUtils.notNull(_local2.playerID)) && ((_local2.playerID.substr(0, 2) == "P-")))) && ((_local2.playerID.length == 9))), "Invalid playerID passed in!");
callToAction("Please verify your player-level parameters above. Play a video when ready.", NO_TIMEOUT);
expectEvent(IntegEvent.STREAM_PLAY, null, true, null, NO_TIMEOUT);
expectEvent(IntegEvent.STREAM_SETUP, null, true, onStreamSetup, NO_TIMEOUT);
}
public function onStreamSetup(_arg1:IntegEvent):void{
IntegLog.debug("In onStreamSetup.");
CoreUtils.assertNotNull(_arg1.params, "No parameters provided!");
CoreUtils.assertNotNull(_arg1.params.stream, "No params.stream provided!");
IntegLog.dumpObject("event.params", _arg1.params);
var _local2:Stream = _arg1.params.stream;
_prevStream = _local2;
IntegLog.debug(("Storing previous stream: " + _prevStream.videoInfo.fileName));
assertNotNull(_local2.videoInfo.duration, "Did not get a duration from metadata.");
assertNotNull(_local2.videoInfo.fileName, "Did not get a filename.");
callToAction("Thank you.");
expectEvent(IntegEvent.ACTIVITY_REPORT, null, true, onActRept);
}

}
}//package com.tubemogul.inplay.test.integ
package com.tubemogul.inplay.test.integ {
import com.tubemogul.inplay.*;
import com.tubemogul.inplay.request.*;
import flash.utils.*;
import com.tubemogul.inplay.util.*;

public class IntegTest {

public static const NO_TIMEOUT:int = -1;
public static const DEF_TIMEOUT:int = 30;

private static var RECEIVED:String = "RECEIVED";
private static var PENDING:String = "PENDING";
private static var TIMED_OUT:String = "TIMED_OUT";

private var _expectedEvents:Array;
private var _stopOnFailure:Boolean = true;
private var _delayInt:int = -1;
private var _executedTests:int = 0;
private var _passedTests:int = 0;
private var _failedTests:int = 0;
private var _keyListener:Object = null;
private var _warnings:int = 0;

public function IntegTest(){
_expectedEvents = new Array();
super();
IntegApi.api.addEventListener(IntegEvent.FAILED, onFailed);
IntegApi.api.addEventListener(IntegEvent.TIMEOUT, onTimeout);
}
private function getEventIdx(_arg1:IntegEvent):int{
var _local2:int;
while (_local2 < _expectedEvents.length) {
if ((((_expectedEvents[_local2].status == PENDING)) && ((_expectedEvents[_local2].event.id == _arg1.id)))){
return (_local2);
};
_local2++;
};
_local2 = 0;
while (_local2 < _expectedEvents.length) {
if ((((_expectedEvents[_local2].status == PENDING)) && ((_expectedEvents[_local2].event.type == _arg1.type)))){
return (_local2);
};
_local2++;
};
return (-1);
}
protected function expectEvent(_arg1:String, _arg2:Object=null, _arg3:Boolean=false, _arg4:Function=null, _arg5:int=30, _arg6:Function=null):void{
var _local7:IntegEvent = new IntegEvent(_arg1, _arg2);
var _local8:Object = new Object();
_local8.event = _local7;
_local8.required = _arg3;
if (_arg4 != null){
_local8.func = _arg4;
};
_local8.timeout = _arg5;
_local8.timeoutInt = NO_TIMEOUT;
if (_arg6 != null){
_local8.timeoutFunc = _arg6;
};
_local8.status = PENDING;
if (_arg1 == IntegEvent.KEY){
} else {
if (_arg1 == IntegEvent.DELAY){
_local8.timeoutInt = setInterval(localHandler, (_local8.timeout * 1000), IntegEvent.DELAY, {eventObj:_local8});
} else {
if (_local8.timeout != NO_TIMEOUT){
_local8.timeoutInt = setInterval(localHandler, (_local8.timeout * 1000), IntegEvent.TIMEOUT, {eventObj:_local8});
};
};
};
IntegApi.api.addEventListener(_arg1, onEvent);
var _local9:int = (_expectedEvents.push(_local8) - 1);
IntegLog.debug(((((((((("Expecting event[" + _local9) + "] ") + _local7.toString()) + ", timeout: ") + _local8.timeout) + ", timeoutInt: ") + _local8.timeoutInt) + ", required: ") + _local8.required));
IntegLog.debug(("Outstanding events: " + eventTypesStr(_expectedEvents, false, "event")));
}
private function onTimeout(_arg1:IntegEvent):void{
var eventObj:* = null;
var idx:* = 0;
var event:* = _arg1;
try {
eventObj = event.params.eventObj;
idx = getEventIdx(eventObj.event);
CoreUtils.assert(!((idx == -1)), "ERROR: should not hit this!");
cleanUpEventIdx(idx, TIMED_OUT);
if (eventObj.required){
IntegLog.debug(((((((((("Timeout event[" + idx) + "] ") + event.toString()) + ", ID: ") + eventObj.event.id) + ", timeout: ") + eventObj.timeout) + ", timeoutInt: ") + eventObj.timeoutInt));
IntegLog.debug(("Outstanding events: " + eventTypesStr(_expectedEvents, false, "event")));
fail((((eventObj.event.toString() + ", timed out after ") + eventObj.timeout) + "s."));
if (!_stopOnFailure){
if (eventObj.func){
eventObj.func(eventObj.event);
};
};
} else {
_expectedEvents.splice(idx, 1);
if (eventObj.timeoutFunc){
eventObj.timeoutFunc(eventObj.event);
};
IntegLog.debug(("Outstanding events: " + eventTypesStr(_expectedEvents, false, "event")));
};
} catch(err:TestFailedError) {
IntegLog.error("Got TestFailedError. Calling dispatchIntegEvent.");
IntegApi.api.dispatchIntegEvent(IntegEvent.FAILED, {msg:err.message});
} catch(err:Error) {
IntegLog.error(("Got exception: " + err.message));
};
}
protected function delay(_arg1:int, _arg2:Function):void{
expectEvent(IntegEvent.DELAY, null, false, _arg2, _arg1);
}
protected function assert(_arg1:Boolean, _arg2:String):void{
if (_arg1){
_passedTests++;
} else {
fail(_arg2);
};
}
private function getEventObjFromIdx(_arg1:int):Object{
return (_expectedEvents[_arg1]);
}
protected function done():void{
verify();
printTestResults();
}
public function run():void{
}
protected function warn(_arg1:Boolean, _arg2:String):void{
if (_arg1){
_passedTests++;
} else {
_warnings++;
IntegLog.warn((("Warning: " + _arg2) + " Continuing test."));
};
}
protected function callToAction(_arg1:String, _arg2:int=30):void{
if (_arg2 == NO_TIMEOUT){
IntegLog.info((("***** " + _arg1) + " Waiting..."));
} else {
IntegLog.info((((("***** " + _arg1) + " Waiting up to ") + _arg2) + "s..."));
};
}
protected function printTestResults():void{
IntegLog.info(" ");
IntegLog.info("******************** Test finished ********************");
IntegLog.info((" Passed : " + _passedTests));
IntegLog.info((" Failed : " + _failedTests));
IntegLog.info((" Warnings : " + _warnings));
IntegLog.info(" ");
if (_failedTests > 0){
IntegLog.error(" Please investigate the above failures.");
} else {
if (_warnings > 0){
IntegLog.warn(" Please investigate the above warnings.");
IntegLog.warn(" Otherwise, congratulations on integrating InPlay!");
} else {
IntegLog.info(" Congratulations on integrating InPlay!");
};
};
IntegLog.info("*******************************************************");
}
protected function assertNotNull(_arg1:Object, _arg2:String):void{
assert(CoreUtils.notNull(_arg1), _arg2);
}
protected function fail(_arg1:String):void{
_failedTests++;
IntegLog.error(("Throwing TestFailedError: " + _arg1));
throw (new TestFailedError(_arg1));
}
private function localHandler(_arg1:String, _arg2:Object):void{
var eventType:* = _arg1;
var params:* = _arg2;
try {
IntegApi.api.dispatchIntegEvent(eventType, params);
} catch(err:TestFailedError) {
IntegLog.error("Got TestFailedError. Calling dispatchIntegEvent.");
IntegApi.api.dispatchIntegEvent(IntegEvent.FAILED, params);
} catch(err:Error) {
IntegLog.error(("Got exception: " + err.message));
};
}
private function cleanUpEventIdx(_arg1:int, _arg2:String):void{
if (CoreUtils.isNull(_arg2)){
_arg2 = "PENDING";
};
var _local3:Object = getEventObjFromIdx(_arg1);
clearInterval(_local3.timeoutInt);
_local3.timeoutInt = NO_TIMEOUT;
_local3.status = _arg2;
if (getEventIdx(_local3.event) == -1){
IntegApi.api.removeEventListener(_local3.event.type, onEvent);
};
}
protected function waitForKey(_arg1:String, _arg2:Function):void{
callToAction((_arg1 + " Press a key when done."), NO_TIMEOUT);
expectEvent(IntegEvent.KEY, null, false, _arg2, NO_TIMEOUT);
}
private function verifyParams(_arg1:IntegEvent, _arg2:IntegEvent):void{
var _local4:String;
var _local3:Object = _arg1.params;
for (_local4 in _local3) {
assert((_local3[_local4] == _arg2.params[_local4]), ((_arg2.type + ": Expected event field ") + _local3[_local4]));
};
}
private function eventTypesStr(_arg1:Array, _arg2:Boolean, _arg3:String):String{
var _local4 = "";
var _local5:int;
while (_local5 < _arg1.length) {
if (((!(_arg2)) && (!((_arg1[_local5].status == PENDING))))){
} else {
if (_local5 != 0){
_local4 = (_local4 + ", ");
};
if (CoreUtils.isNull(_arg3)){
_local4 = (_local4 + _arg1[_local5].type);
} else {
_local4 = (_local4 + _arg1[_local5][_arg3].type);
};
};
_local5++;
};
return (_local4);
}
protected function assertIsNull(_arg1:Object, _arg2:String):void{
assert(CoreUtils.isNull(_arg1), _arg2);
}
public function verify():void{
}
private function getEventObj(_arg1:IntegEvent):Object{
var _local2:int = getEventIdx(_arg1);
return (getEventObjFromIdx(_local2));
}
private function onEvent(_arg1:IntegEvent):void{
var idx:* = 0;
var req:* = null;
var eventObj:* = null;
var event:* = _arg1;
try {
idx = getEventIdx(event);
if (idx == -1){
warn(false, ("Got unexpected event: " + event.toString()));
} else {
req = event.params.req;
if (req){
assert((req.errorResponse == false), ((("Got errored " + req.getType()) + ". HTTPStatus = ") + req.httpStatus));
};
eventObj = getEventObjFromIdx(idx);
IntegLog.debug(((((("**** Got event[" + idx) + "] ") + event.toString()) + ": matched ID: ") + eventObj.event.id));
cleanUpEventIdx(idx, RECEIVED);
verifyParams(eventObj.event, event);
IntegLog.debug(("Outstanding events: " + eventTypesStr(_expectedEvents, false, "event")));
if (eventObj.func){
eventObj.func(event);
};
_passedTests++;
};
} catch(err:TestFailedError) {
IntegLog.error("Got TestFailedError. Calling dispatchIntegEvent.");
IntegApi.api.dispatchIntegEvent(IntegEvent.FAILED, {msg:err.message});
} catch(err:Error) {
IntegLog.error(("Got exception: " + err.message));
};
}
private function onFailed(_arg1:IntegEvent):void{
if (_stopOnFailure == true){
IntegLog.fatal((("Failure: " + _arg1.params.msg) + " Stopping test."));
cleanUpEvents();
printTestResults();
} else {
IntegLog.error((("Failure: " + _arg1.params.msg) + " Continuing test."));
};
}
public function cleanUpEvents():void{
var _local1:int;
while (_local1 < _expectedEvents.length) {
cleanUpEventIdx(_local1, PENDING);
_local1++;
};
}

}
}//package com.tubemogul.inplay.test.integ
package com.tubemogul.inplay.test.integ {

public class TestFailedError extends Error {

public function TestFailedError(_arg1:String){
super(_arg1);
name = "TestFailedError";
message = ((_arg1) ? _arg1 : "Test case failed");
}
}
}//package com.tubemogul.inplay.test.integ
package com.tubemogul.inplay {
import flash.events.*;

public class InPlayLogEvent extends Event {

public static const DEBUG:String = "INPLAY_DEBUG";
public static const WARN:String = "INPLAY_WARN";
public static const ERROR:String = "INPLAY_ERROR";
public static const INFO:String = "INPLAY_INFO";

public var message:String = "";

public function InPlayLogEvent(_arg1:String, _arg2:String=""){
super(_arg1);
this.message = _arg2;
}
override public function toString():String{
return (((this.type + ": ") + this.message));
}

}
}//package com.tubemogul.inplay
package com.tubemogul.inplay {
import flash.events.*;

class InPlayEvent extends Event {

public static const START:String = "start";
public static const NS_PAUSE:String = "pause";
public static const CUE_POINT:String = "cuePoint";
public static const LAST_SECOND:String = "lastSecond";
public static const DELETE_STREAM:String = "deleteStream";
public static const SOUND_UPDATE:String = "soundUpdate";
public static const PLAY_STATUS:String = "playStatus";
public static const NEW_STREAM:String = "newStream";
public static const CALL_API:String = "callApi";
public static const CORE_READY:String = "coreReady";
public static const NS_CLOSE:String = "close";
public static const NS_RESUME:String = "resume";
public static const VAR_CHANGED:String = "variableChanged";
public static const NS_PLAY:String = "play";
public static const METADATA:String = "metadataReceived";
public static const CUSTOM:String = "custom";
public static const NET_STATUS:String = "netStatus";
public static const XMP_DATA:String = "xmpData";
public static const UPDATE_STREAM:String = "updateStream";
public static const STREAM_NUM_PLAYER:int = -1;
public static const NS_TOGGLE_PAUSE:String = "togglePause";
public static const STATE_CHANGE:String = "stateChange";

public var params:Object;
public var streamNum:int;

public function InPlayEvent(_arg1:String, _arg2:Object=null, _arg3:int=-1){
super(_arg1);
this.params = _arg2;
this.streamNum = _arg3;
}
override public function toString():String{
return (((("InPlayEvent: " + this.type) + ", streamNum: ") + this.streamNum));
}

}
}//package com.tubemogul.inplay
package com.tubemogul.inplay {
import flash.events.*;

public class InPlayApi extends EventDispatcher {

public static var api:InPlayApi = null;

}
}//package com.tubemogul.inplay
package com.tubemogul.inplay.model {
import flash.events.*;
import com.tubemogul.inplay.log.*;
import com.tubemogul.inplay.*;
import com.tubemogul.inplay.test.integ.*;
import com.tubemogul.inplay.request.*;
import flash.net.*;
import flash.utils.*;
import com.tubemogul.inplay.util.*;
import flash.external.*;

public class Player implements IPlayerObject {

public static var AS_VERSION:String = "AS3";

private var _placementID:String = "";
private var _fastWindow:int = 21;
private var _referrerURL:String = "";
private var _playerID:String = "";
private var _heartbeatIntervalId:int = 0;
private var _trackerIDs:String = "";
private var _bootloader:Object = null;
private var _tickTimer:Timer;
private var _bootloaderID:String;
private var _playerURL:String = "";
private var _adID:String = "";
private var _defaultReferrerURL:String = "";
public var needsRefresh:Boolean = false;
private var _playerInstanceID:String = "";
private var _isJavascriptOn:Boolean = true;
public var core:InPlayCore = null;
private var _params:Object;
private var _heartbeatPeriod:int = 60;
private var _streams:Array = null;
private var _siteID:String = "";
private var _browserURL:String = "";
private var _slowPeriod:int = 21;
private var _defaultBrowserURL:String = "";
private var _adActions:Actions = null;
private var _fastPeriod:int = 7;

public function Player(_arg1:InPlayCore, _arg2:Object){
var monitor:* = null;
var core_:* = _arg1;
var params:* = _arg2;
super();
core = core_;
CoreUtils.assertNotNull(params.bootloader, "No bootloader passed in!");
_bootloader = params.bootloader;
if (core.loaderInfo){
Log.debug(("core.loaderInfo.url = " + core.loaderInfo.url));
Log.debug(("core.loaderInfo.loaderURL = " + core.loaderInfo.loaderURL));
};
_params = CoreUtils.getLCParams();
playerID = CoreUtils.checkForParam("playerID", "");
bootloaderID = CoreUtils.checkForParam("bootloaderID", "");
browserURL = unescape(CoreUtils.checkForParam("browserURL", "", "adTagInfo.sourceurl"));
defaultBrowserURL = CoreUtils.checkForParam("defaultBrowserURL", "");
referrerURL = CoreUtils.checkForParam("referrerURL", "");
defaultReferrerURL = CoreUtils.checkForParam("defaultReferrerURL", "");
playerURL = CoreUtils.checkForParam("playerURL", core.loaderInfo.loaderURL);
trackerIDs = CoreUtils.checkForParam("trackerIDs", "");
placementID = CoreUtils.checkForParam("feedId", "", "adTagInfo.feedid");
adID = CoreUtils.checkForParam("promotedAdId", "", "inplayInfo.promotedAdId");
playerInstanceID = CoreUtils.checkForParam("playerInstanceId", "", "inplayInfo.playerInstanceId");
var previewMode:* = (((CoreUtils.checkForParam("previewMode", "false", "previewMode") == "true")) ? true : false);
if (previewMode){
core.pendingQ.shutOff();
};
CoreUtils.checkForParam("videoID", "");
CoreUtils.checkForParam("publisherID", "");
CoreUtils.checkForParam("displayName", "");
CoreUtils.checkForParam("psName", "");
CoreUtils.checkForParam("adSafe", "");
CoreUtils.checkForParam("categories", "");
CoreUtils.checkForParam("autoplay", "", "inplayInfo.autoplay");
var url:* = unescape(CoreUtils.checkForParam("bannerClickPixelURL", "", "adTagInfo.bannerclickpixelurl"));
if (CoreUtils.notNull(url)){
monitor = new Monitor(core, Monitor.TRIGGER_CLICK_THROUGH);
monitor.addPixel(Pixel.PIXEL_FLASH, url, false, "bannerClickPixelURL");
core.pixelMgr.addMonitor(monitor);
};
getBrowserURL();
getReferrerURL();
try {
ExternalInterface.addCallback("getPlayheadTime", getPlayheadTime);
} catch(err:Error) {
Log.logException("Player constructor", LogLevel.ERROR, err);
};
dumpParams(LogLevel.INFO);
_tickTimer = new Timer(1000, 0);
_tickTimer.addEventListener(TimerEvent.TIMER, processTick);
_tickTimer.start();
_heartbeatIntervalId = setInterval(checkHeartbeat, 1000);
_streams = new Array();
_adActions = new Actions();
}
public function set trackerIDs(_arg1:String):void{
_trackerIDs = _arg1;
}
public function set adID(_arg1:String):void{
_adID = _arg1;
}
public function writeHTML(_arg1:String):void{
var _local2:String = escape(_arg1);
Log.debug("In writeHTML");
Log.debug(("Regular HTML string: " + _arg1));
Log.debug(("Escaped HTML string: " + _local2));
var _local3 = (((((("function () {" + "var html = unescape(\"") + _local2) + "\");") + "var d = document.createElement(\"div\");") + "document.body.appendChild(d);") + "d.innerHTML = html; }");
var _local4:Object = _bootloader.extInterfaceCallRelay(_local3);
if (_local4){
Log.debug(("Direct callout returned = " + _local4.toString()));
};
}
public function get passedParams():Object{
return (_params);
}
public function get activeStream():Stream{
var _local1 = -1;
var _local2:uint;
while (_local2 < streams.length) {
if (((streams[_local2]) && (streams[_local2].isActive))){
if (_local1 == -1){
_local1 = _local2;
} else {
Log.error(("Somehow we have >1 active stream! streamNum = " + _local1));
};
};
_local2++;
};
return ((((_local1 == -1)) ? null : streams[_local1]));
}
public function get browserURL():String{
return (_browserURL);
}
private function getBrowserURL():void{
if (!isJavascriptOn){
return;
};
Log.debug("In getBrowserURL()");
var _local1:Object = browserURL;
if (!_local1){
Log.debug("Attempting with playerURL");
_local1 = callJavascript("document.location.href", playerURL);
};
browserURL = ((_local1) ? String(_local1) : defaultBrowserURL);
Log.info(("Got browser URL of " + browserURL));
IntegApi.api.dispatchIntegEvent(IntegEvent.PLAYER_BROWSER_URL, {
player:this,
browserURL:browserURL
});
}
public function get playerInstanceID():String{
return (_playerInstanceID);
}
public function writeScriptHTML(_arg1:String):void{
var _local2:String = escape(_arg1);
Log.debug("In writeScriptHTML");
Log.debug(("Regular src string: " + _arg1));
Log.debug(("Escaped src string: " + _local2));
var _local3 = (((((("function () {" + "var e = document.createElement(\"script\");") + "e.src = unescape(\"") + _arg1) + "\");") + "e.type=\"text/javascript\";") + "document.getElementsByTagName(\"head\")[0].appendChild(e); }");
var _local4:Object = _bootloader.extInterfaceCallRelay(_local3);
if (_local4){
Log.debug(("Direct callout returned = " + _local4.toString()));
};
}
public function endStream(_arg1:int):void{
if (!streams[_arg1]){
return;
};
streams[_arg1].statusHandler({state:Stream.STOPPED});
streams[_arg1] = null;
}
public function get fastPeriod():int{
return (_fastPeriod);
}
public function newStream(_arg1:int, _arg2:Object):Stream{
endStream(_arg1);
activeStream = (streams[_arg1] = new Stream(this, _arg1, _arg2));
return (streams[_arg1]);
}
public function set siteID(_arg1:String):void{
_siteID = _arg1;
}
public function set slowPeriod(_arg1:int):void{
if (_arg1 == _slowPeriod){
return;
};
Log.info(("Changing slowPeriod to " + _arg1));
_slowPeriod = _arg1;
resetCollectionTimers();
}
public function set activeStream(_arg1:Stream):void{
if (!_arg1){
return;
};
activeStream.isActive = false;
_arg1.isActive = true;
}
public function set browserURL(_arg1:String):void{
_browserURL = _arg1;
}
public function callAdJs(_arg1:String):Object{
var js:* = null;
var retVal:* = null;
var func:* = _arg1;
try {
Log.debug(("In callAdJs. inAdUnit = " + inAdUnit));
if (!inAdUnit){
return (null);
};
Log.debug(("Direct callout for " + func));
js = (("function() { return " + func) + "; }");
retVal = _bootloader.extInterfaceCallRelay(js);
if (retVal){
Log.debug(("Direct callout returned: " + retVal.toString()));
return (retVal);
};
return (null);
} catch(err:Error) {
Log.logException("Player.callAdJs", LogLevel.WARN, err);
};
return (null);
}
public function get defaultBrowserURL():String{
return (_defaultBrowserURL);
}
public function set passedParams(_arg1:Object):void{
_params = _arg1;
}
public function isStreamLevel():Boolean{
return (false);
}
public function get slowPeriod():int{
return (_slowPeriod);
}
public function get bootloaderID():String{
return (((_bootloaderID) ? _bootloaderID : ("NO_BOOT_LOADER_" + InPlayCore.CORE_VERSION)));
}
public function set playerInstanceID(_arg1:String):void{
_playerInstanceID = _arg1;
}
public function firePlayerAudit():void{
if (!inAdUnit){

[Aniblaze]

Oh man, Hebrew looks like a really tough language to learn!