@afterswf/playerglobal 0.0.0-stage → 0.2.460

package/lib/net/URLLoader.ts

@@ -0,0 +1,144 @@
+import { URLLoader as URLLoaderAway, URLLoaderEvent } from '@awayjs/core';
+
+import { EventDispatcher } from '../events/EventDispatcher';
+import { IEventMapper } from '../events/IEventMapper';
+import { Event } from '../events/Event';
+import { ProgressEvent } from '../events/ProgressEvent';
+import { IOErrorEvent } from '../events/IOErrorEvent';
+import { AXClass, ASObject } from '@awayfl/avm2';
+import { URLRequest } from './URLRequest';
+import { SecurityDomain } from '../SecurityDomain';
+import { IRedirectRule, matchRedirect } from '@awayfl/swf-loader';
+import { URLLoaderDataFormat } from './URLLoaderDataFormat';
+
+export class URLLoader extends EventDispatcher {
+	static redirectRules: IRedirectRule[] = [];
+	static axClass: typeof URLLoader & AXClass;
+
+	private _adaptee: URLLoaderAway;
+	private _dataIsNull: boolean = true;
+
+	// AS bind, defined in trite
+	public $BgdataFormat: string;
+
+	constructor() {
+		super();
+		this._adaptee = new URLLoaderAway();
+
+		this._completeCallbackDelegate = (event: URLLoaderEvent) => this.completeCallback(event);
+		this._progressCallbackDelegate = (event: URLLoaderEvent) => this.progressCallback(event);
+		this._loadErrorDelegate = (event: URLLoaderEvent) => this.loadErrorDelegate(event);
+		this.eventMapping[Event.COMPLETE] = (<IEventMapper>{
+			adaptedType:URLLoaderEvent.LOAD_COMPLETE,
+			addListener:this.initListener,
+			removeListener:this.removeListener,
+			callback:this._completeCallbackDelegate });
+		this.eventMapping[ProgressEvent.PROGRESS] = (<IEventMapper>{
+			adaptedType:URLLoaderEvent.LOAD_PROGRESS,
+			addListener:this.initListener,
+			removeListener:this.removeListener,
+			callback:this._progressCallbackDelegate });
+		this.eventMapping[IOErrorEvent.IO_ERROR] = (<IEventMapper>{
+			adaptedType:URLLoaderEvent.LOAD_ERROR,
+			addListener:this.initListener,
+			removeListener:this.removeListener,
+			callback:this._loadErrorDelegate });
+
+		Object.defineProperty(this, '$Bgdata', {
+			get: this.getData.bind(this),
+			set: this.setData.bind(this)
+		});
+	}
+
+	public close() {
+		console.log('not mimplemented: URLoader.close');
+	}
+
+	public setData(v: ASObject): void {
+		this._dataIsNull = this._dataIsNull || v === null;
+	}
+
+	// trait not have data as get/set, we should redefine it in constructor
+	public getData(): any {
+		if (this._dataIsNull)
+			return null;
+
+		const rawData = this._adaptee.data;
+
+		switch (this.$BgdataFormat) {
+			case URLLoaderDataFormat.VARIABLES: {
+				return new (<SecurityDomain> this.sec).flash.net.URLVariables(rawData);
+			}
+			case URLLoaderDataFormat.BINARY: {
+				console.warn('[URLLoader] Binary not supported');
+				return null;
+			}
+
+			default: {
+				return rawData;
+			}
+
+		}
+	}
+
+	private initListener(type: string, callback: (event: any) => void): void {
+		this._adaptee.addEventListener(type, callback);
+	}
+
+	private removeListener(type: string, callback: (event: any) => void): void {
+		this._adaptee.removeEventListener(type, callback);
+	}
+
+	public addEventListener(type: string, callback: (event: any) => void): void {
+		super.addEventListener(type, callback);
+	}
+
+	private _loadErrorDelegate: (event: URLLoaderEvent) => void;
+	private loadErrorDelegate(event: URLLoaderEvent = null): void {
+		this._dataIsNull = false;
+
+		const newEvent: IOErrorEvent = new (<SecurityDomain> this.sec).flash.events.IOErrorEvent(IOErrorEvent.IO_ERROR);
+		newEvent.currentTarget = this;
+		this.dispatchEvent(newEvent);
+	}
+
+	private _progressCallbackDelegate: (event: URLLoaderEvent) => void;
+	private progressCallback(event: URLLoaderEvent = null): void {
+		this._dataIsNull = false;
+
+		const newEvent = new (<SecurityDomain> this.sec).flash.events.
+			ProgressEvent(ProgressEvent.PROGRESS, null, null, event.urlLoader.bytesLoaded, event.urlLoader.bytesTotal);
+
+		newEvent.currentTarget = this;
+		this.dispatchEvent(newEvent);
+	}
+
+	private _completeCallbackDelegate: (event: URLLoaderEvent) => void;
+
+	private completeCallback(event: URLLoaderEvent = null): void {
+		this._dataIsNull = false;
+
+		const newEvent: Event = new (<SecurityDomain> this.sec).flash.events.Event(Event.COMPLETE);
+		newEvent.currentTarget = this;
+		newEvent.target = this;
+		this.dispatchEvent(newEvent);
+	}
+
+	public load(request: URLRequest): void {
+		const directUrl = request.url || '';
+		const redirect = matchRedirect(directUrl, URLLoader.redirectRules);
+
+		if (redirect) {
+			console.log('[URL LOADER] Override loading url:', redirect.url);
+			request.adaptee.url = redirect.url;
+		} else {
+			console.log('[URL LOADER] start loading the url:', directUrl);
+		}
+
+		// remap AS to JS before real request,
+		// this is needed because some games fill data object after assigment
+		request.mapToJSData();
+
+		this._adaptee.load(request.adaptee);
+	}
+}

package/lib/net/URLLoaderDataFormat.ts

@@ -0,0 +1 @@
+export { URLLoaderDataFormat } from '@awayjs/core';

package/lib/net/URLRequest.ts

@@ -0,0 +1,135 @@
+import { URLRequest as URLRequestAway, URLVariables as URLVariablesAway } from '@awayjs/core';
+import { ASObject, ASArray, axCoerceString, transformJSValueToAS, transformASValueToJS } from '@awayfl/avm2';
+import { URLVariables } from './URLVariables';
+
+/**
+ * Copyright 2014 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// Class: URLRequest
+
+export class URLRequest extends ASObject {
+
+	// Called whenever the class is initialized.
+	static axClass: typeof URLRequest;
+
+	private _adaptee: URLRequestAway;
+	private _data: ASObject;
+
+	constructor (url: string = null) {
+		super();
+		this._adaptee = new URLRequestAway(url);
+	}
+
+	get adaptee(): URLRequestAway {
+		return this._adaptee;
+	}
+
+	set adaptee(value: URLRequestAway) {
+		this._adaptee = value;
+	}
+
+	get url(): string {
+		return this._adaptee.url;
+	}
+
+	set url(value: string) {
+		value = axCoerceString(value);
+		this._adaptee.url = value;
+	}
+
+	get data(): ASObject {
+		const adapteeData = this._adaptee.data;
+		let returnData = this._adaptee.data;
+
+		if (adapteeData instanceof URLVariablesAway) {
+			returnData = new URLVariables();
+			for (const key in this._adaptee.data.variables) {
+				returnData['$Bg' + key] = this._adaptee.data.variables[key];
+			}
+		} else if (typeof adapteeData === 'object') {
+			returnData = transformJSValueToAS(this.sec, adapteeData, true);
+		}
+
+		return this._data = returnData;
+	}
+
+	set data(value: ASObject) {
+		this._data = value;
+
+		this.mapToJSData();
+	}
+
+	/**
+	 * Query data for request, taht mapped onto JS, this is because we can't convert data to JS in assigment
+	 * data is object, and AS sometimes fill data after assigment
+	 */
+	mapToJSData(): any {
+		const value = this._data;
+		let jsValue;
+
+		if ((<any> this.sec).flash.net.URLVariables.axIsType(value)) {
+			jsValue = new URLVariablesAway();
+			for (const key in value) {
+				if (key.indexOf('$Bg') == 0 && !(typeof value[key] === 'function')) {
+					jsValue.variables[key.replace('$Bg', '')] = value[key];
+				}
+			}
+		} else {
+			jsValue = transformASValueToJS(this.sec, value, true);
+		}
+
+		this._adaptee.data = jsValue;
+		return jsValue;
+	}
+
+	get method(): string {
+		return this._adaptee.method;
+	}
+
+	set method(value: string) {
+		this._adaptee.method = value;
+	}
+
+	get contentType(): string {
+		console.log('TODO: URLRequest.contentType');
+		return '';//this._adaptee.contentType;
+	}
+
+	set contentType(value: string) {
+		console.log('TODO: URLRequest.contentType');
+		//this._adaptee.contentType = value;
+	}
+
+	get requestHeaders(): ASArray {
+		console.log('TODO: URLRequest.requestHeaders');
+		return null;//this._adaptee.contentType;
+	}
+
+	set requestHeaders(value: ASArray) {
+		console.log('TODO: URLRequest.requestHeaders');
+		//this._adaptee.contentType = value;
+	}
+
+	get digest(): string {
+		console.log('TODO: URLRequest.digest');
+		return null;//this._adaptee.contentType;
+	}
+
+	set digest(value: string) {
+		console.log('TODO: URLRequest.digest');
+		//this._adaptee.contentType = value;
+	}
+
+}

package/lib/net/URLRequestMethod.ts

@@ -0,0 +1 @@
+export { URLRequestMethod } from '@awayjs/core';

package/lib/net/URLVariables.ts

@@ -0,0 +1,84 @@
+import { ASObject, Errors, axCoerceString, Multiname } from '@awayfl/avm2';
+
+/**
+ * Copyright 2014 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// Class: URLVariables
+
+declare let escape;
+declare let unescape;
+
+export class URLVariables extends ASObject {
+	static classInitializer: any = null;
+	static classSymbols: string [] = null; // [];
+	static instanceSymbols: string [] = null;
+
+	constructor (source: string = null) {
+		super();
+		this._ignoreDecodingErrors = false;
+		source && this.decode(source);
+	}
+
+	_ignoreDecodingErrors: boolean;
+
+	// class not has traits, and will crash
+	axSetProperty(mn: Multiname, value: any) {
+		this[mn.getMangledName()] = value ;
+	}
+
+	decode(source: string): void {
+		source = axCoerceString(source);
+		const variables = source.split('&');
+		for (let i = 0; i < variables.length; i++) {
+			const p = variables[i];
+			let j = p.indexOf('=');
+			if (j < 0) {
+				if (this._ignoreDecodingErrors) {
+					j = p.length;
+				} else {
+					this.sec.throwError('Error', Errors.DecodeParamError);
+				}
+			}
+			const name = unescape(p.substring(0, j).split('+').join(' '));
+			const value = unescape(p.substring(j + 1).split('+').join(' '));
+			const currentValue = this.axGetPublicProperty(name);
+			if (typeof currentValue === 'undefined') {
+				this.axSetPublicProperty(name, value);
+			} else if (Array.isArray(currentValue)) {
+				currentValue.push(value);
+			} else {
+				this.axSetPublicProperty(name, [currentValue, value]);
+			}
+		}
+	}
+
+	toString(): string {
+		const pairs = [];
+		const keys = this.axGetEnumerableKeys();
+		for (let i = 0; i < keys.length; i++) {
+			let name = keys[i].split(' ').join('+');
+			const value = this.axGetPublicProperty(name);
+			name = escape(name).split(' ').join('+');
+			if (Array.isArray(value)) {
+				for (let j = 0; j < value.length; j++) {
+					pairs.push(name + '=' + escape(value[j]));
+				}
+			} else {
+				pairs.push(name + '=' + escape(value));
+			}
+		}
+		return pairs.join('&');
+	}
+}

package/lib/net/navigateToURL.ts

@@ -0,0 +1,5 @@
+import { URLRequest } from './URLRequest';
+
+export function navigateToURL(url: URLRequest, target: string): void {
+	window.open(url.url, '_blank');
+}

package/lib/sampler/NewObjectSample.ts

@@ -0,0 +1,40 @@
+import { Sample } from './Sample';
+
+/**
+ * The NewObjectSample class represents objects that are created within a
+ * <codeph class="+ topic/ph pr-d/codeph ">getSamples()</codeph> stream.
+ * For Flash Player debugger version only.
+ */
+export class NewObjectSample extends Sample {
+	public id: number;
+
+	/**
+	 * The Class object corresponding to the object created within a getSamples() stream.
+	 * For Flash Player debugger version only.
+	 */
+	public type: any;
+
+	/**
+	 * The NewObjectSample object if it still exists. If the object has been garbage collected, this property is
+	 * undefined and a corresponding DeleteObjectSample exists. For Flash Player debugger version only.
+	 */
+	public get object (): any {
+		console.log('object not implemented yet in flash/NewObjectSample');
+		return null;
+
+	}
+
+	/**
+	 * The NewObjectSample object size. If the object has been garbagecollected, this property is
+	 * undefined and a corresponding DeleteObjectSample exists. For FlashPlayer debugger version only.
+	 */
+	public get size (): number {
+		console.log('size not implemented yet in flash/NewObjectSample');
+		return 0;
+
+	}
+
+	constructor () {
+		super();
+	}
+}

package/lib/sampler/Sample.ts

@@ -0,0 +1,23 @@
+
+/**
+ * The Sample class creates objects that hold memory analysis information over distinct durations.
+ * For Flash Player debugger version only.
+ */
+export class Sample {
+	/**
+	 * Contains information about the methods executed by Flash Player over a specified period of time.
+	 * The format for the
+	 * stack trace is similiar to the content shown in the exception dialog box of the Flash Player debugger version.
+	 * For Flash Player debugger version only.
+	 */
+	public stack: any[];
+
+	/**
+	 * The microseconds that define the duration of the Sample instance. For Flash Player debugger version only.
+	 */
+	public time: number;
+
+	constructor () {
+
+	}
+}