@afterswf/playerglobal 0.0.0-stage → 0.2.460

package/lib/system/ApplicationDomain.ts

@@ -0,0 +1,279 @@
+import { ByteArray, AssetBase } from '@awayjs/core';
+import { Font, SceneImage2D } from '@awayjs/scene';
+import { MovieClip as AwayMovieClip } from '@awayjs/scene';
+import { WaveAudio } from '@awayjs/core';
+import { Sound } from '../media/Sound';
+import { AXClass, ASObject, Multiname, AXApplicationDomain } from '@awayfl/avm2';
+import { SecurityDomain } from '../SecurityDomain';
+
+/**
+ * The ApplicationDomain class is a container for discrete groups of class definitions.
+ * Application domains are used to partition classes that are in the same security domain.
+ * They allow multiple definitions of the same class to exist and allow children to reuse parent
+ * definitions.
+ *
+ *   <p class="- topic/p ">Application domains are used when an external SWF file is loaded through the Loader class.
+ * All ActionScript 3.0 definitions in the loaded SWF file are stored in the application
+ * domain, which is specified by the applicationDomain property of the LoaderContext
+ * object that you pass as a context parameter of the Loader object's load() or
+ * loadBytes() method. The LoaderInfo object also contains an
+ * applicationDomain property, which is read-only.
+ * All code in a SWF file is defined to exist in an application domain. The current application
+ * domain is where your main application runs. The system domain contains all application domains,
+ * including the current domain, which means that it contains all Flash Player classes.Every application domain,
+ * except the system domain, has an associated parent domain.
+ * The parent domain of your main application's application domain is the system domain.
+ * Loaded classes are defined only when their parent doesn't already define them.
+ * You cannot override a loaded class definition with a newer definition.
+ * For usage examples of application domains, see the.
+ * The ApplicationDomain() constructor function allows you to create an ApplicationDomain object.</p>
+ *
+ * @internal	Security considerations for application domains are discussed in the
+ *   applicationDomain property entries of URLRequest and LoaderInfo.
+ */
+export class ApplicationDomain extends ASObject {
+
+	private static _systemDomain: ApplicationDomain;
+	private static getSystemDomain(): ApplicationDomain {
+		if (ApplicationDomain._systemDomain == null) {
+			if (!ApplicationDomain._currentDomain) {
+				return null;
+			}
+
+			ApplicationDomain._systemDomain =
+				new (<SecurityDomain> this._currentDomain.sec).flash.system.ApplicationDomain(null, true);
+		}
+
+		return ApplicationDomain._systemDomain;
+	}
+
+	private static _currentDomain: ApplicationDomain;
+
+	private _parentDomain: ApplicationDomain;
+	private _definitions: Object;
+	private _font_definitions: Object;
+	private _audio_definitions: Object;
+	private _memoryView: DataView;
+	private _memory: ByteArray;
+
+	/*internal*/ axApplicationDomain: AXApplicationDomain;
+
+	/**
+	 * Creates a new application domain.
+	 * @param	parentDomain	If no parent domain is passed in,
+	 * this application domain takes the system domain as its parent.
+	 */
+	constructor (parentDomain: ApplicationDomain = null, isSystemDomain: boolean = false) {
+		super();
+
+		if (!isSystemDomain && parentDomain == null && ApplicationDomain._currentDomain != null) {
+			//ApplicationDomain.currentDomain;
+			parentDomain = ApplicationDomain.getSystemDomain();
+		}
+
+		if (!ApplicationDomain._currentDomain)
+			ApplicationDomain._currentDomain = this;
+
+		this._parentDomain = parentDomain;
+		this._definitions = {};
+		this._font_definitions = {};
+		this._audio_definitions = {};
+
+		if (isSystemDomain) {
+			this.axApplicationDomain = this.sec.system;
+		} else if (!parentDomain) {
+			this.axApplicationDomain = this.sec.application;
+		} else {
+			this.axApplicationDomain =  new AXApplicationDomain(this.sec, this.parentDomain.axApplicationDomain);
+		}
+
+		//@ts-ignore
+		// store crossref back
+		this.axApplicationDomain.awayApplicationDomain = this;
+	}
+
+	/**
+	 * Gets the current application domain in which your code is executing.
+	 * @internal	Question: Do you call System.currentDomain? or Loader.currentDomain or request.currentDomain?
+	 */
+	public static get currentDomain (): ApplicationDomain {
+		/*if(ApplicationDomain._systemDomain==null)
+			ApplicationDomain._systemDomain=new ApplicationDomain();
+		if(ApplicationDomain._currentDomain==null)
+			ApplicationDomain._currentDomain=new ApplicationDomain(ApplicationDomain._systemDomain);*/
+		return ApplicationDomain._currentDomain;
+	}
+
+	public static set currentDomain (value: ApplicationDomain) {
+		ApplicationDomain._currentDomain = value;
+	}
+
+	/**
+	 * Gets and sets the object on which domain-global memory operations
+	 * will operate within this ApplicationDomain.
+	 */
+	public get domainMemory(): ByteArray {
+		console.log('[UNSAFE IMPLEMENTATION!] domainMemory:flash/ApplicationDomain');
+		return this._memory;
+	}
+
+	public set domainMemory(mem: ByteArray) {
+		console.log('[UNSAFE IMPLEMENTATION!] domainMemory:flash/ApplicationDomain');
+
+		// Missed types! ByteArray has buffer instead arraybuffer
+		if (mem && this._memory && (<any> this._memory).buffer !== (<any>mem).buffer) {
+			this._memoryView = new DataView((<any>mem).buffer);
+		}
+		this._memory = mem;
+	}
+
+	/**
+	 * Internal DataView for using domainMemory in runtime
+	 */
+	public get internal_memoryView(): DataView {
+		return this._memoryView;
+	}
+
+	/**
+	 * Gets the minimum memory object length required to be used as
+	 * ApplicationDomain.domainMemory.
+	 */
+	public static get MIN_DOMAIN_MEMORY_LENGTH (): number {
+		console.log('MIN_DOMAIN_MEMORY_LENGTH not implemented yet in flash/ApplicationDomain');
+		return 0;
+	}
+
+	/**
+	 * Gets the parent domain of this application domain.
+	 */
+	public get parentDomain (): ApplicationDomain {
+		return this._parentDomain;
+	}
+
+	public addDefinition (name: string, asset: AssetBase): void {
+		this._definitions[name] = asset;
+	}
+
+	public addAudioDefinition (name: string, asset: WaveAudio): void {
+		this._audio_definitions[name] = asset;
+	}
+
+	public addFontDefinition (name: string, asset: Font): void {
+		this._font_definitions[name] = asset;
+	}
+
+	public hasSymbolForClass(className: string): boolean {
+		return this._definitions[className] || this._font_definitions[className] || this._audio_definitions[className] || this._parentDomain?.hasSymbolForClass(className);
+	}
+
+	public getSymbolAdaptee(className: string): any {
+		const symbol = this._definitions[className];
+
+		if (symbol) {
+			if (symbol.isAsset && symbol.isAsset(SceneImage2D) || !symbol.adapter) {
+				return symbol;
+			}
+
+			const clone = symbol.adapter.clone();
+			if (clone.adaptee.isAsset(AwayMovieClip)) {
+				(<AwayMovieClip>clone.adaptee).currentFrameIndex = 0;
+			}
+			return clone.adaptee;
+		} else if (this._font_definitions[className]) {
+			return this._font_definitions[className];
+		} else if (this._audio_definitions[className]) {
+			return this._audio_definitions[className];
+		}
+		return this._parentDomain?.getSymbolAdaptee(className);
+	}
+
+	public getSymbolDefinition(className: string): any {
+		const symbol = this._definitions[className];
+
+		if (symbol) {
+			if (symbol.isAsset && symbol.isAsset(SceneImage2D)) {
+				return symbol;
+			}
+
+			const clone = symbol.adapter.clone();
+			if (clone.adaptee.isAsset(AwayMovieClip)) {
+				(<AwayMovieClip>clone.adaptee).currentFrameIndex = 0;
+			}
+			return clone;
+		} else if (this._font_definitions[className]) {
+			return this._font_definitions[className];
+		} else if (this._audio_definitions[className]) {
+			const sound = new Sound();
+			sound.adaptee = this._audio_definitions[className];
+			//sound.adaptee.adapter=sound;
+			return sound;
+		}
+		return this._parentDomain?.getSymbolDefinition(className);
+	}
+
+	/**
+	 * Gets a public definition from the specified application domain.
+	 * The definition can be that of a class, a namespace, or a function.
+	 * @param	name	The name of the definition.
+	 * @return	The object associated with the definition.
+	 * @internal	throws SecurityError The definition belongs to a domain to which
+	 *   the calling code does not have access.
+	 * @throws	ReferenceError No public definition exists with the
+	 *   specified name.
+	 */
+	public getDefinition (name: string): AXClass {
+		/**
+		 * @todo Cache a FromSimpleName
+		 */
+		return this.axApplicationDomain.getClass(Multiname.FromSimpleName(name)) || this._parentDomain?.getDefinition(name);
+	}
+
+	public getFontDefinition (name: string): Font {
+		return this._font_definitions[name] || this._parentDomain?.getFontDefinition(name);
+	}
+
+	public getAwayJSAudio(name: string): WaveAudio {
+		return this._audio_definitions[name] || this._parentDomain?.getAwayJSAudio(name);
+	}
+
+	public getAudioDefinition (name: string): Sound {
+		const sound: Sound = new Sound();
+		sound.adaptee = this._audio_definitions[name] || this._parentDomain?.getAudioDefinition(name);
+		//sound.adaptee.adapter=sound;
+		return sound;
+	}
+
+	public getQualifiedDefinitionNames (): string[] {
+		const allDefinitionsnames: string[] = [];
+		for (const key in this._definitions) {
+			if (this._definitions.hasOwnProperty(key)) {
+				allDefinitionsnames[allDefinitionsnames.length] = key;
+			}
+		}
+		return allDefinitionsnames;
+	}
+
+	/**
+	 * Checks to see if a public definition exists within the specified application domain.
+	 * The definition can be that of a class, a namespace, or a function.
+	 * @param	name	The name of the definition.
+	 * @return	A value of true if the specified definition exists; otherwise, false.
+	 */
+	public hasDefinition (name: string): boolean {
+		// Exception will thrown when definition not exist.
+		try {
+			// slow, because run lookup
+			return !!this.getDefinition(name);
+		} catch (e) {
+			return false;
+		}
+	}
+
+	public hasFontDefinition (name: string): boolean {
+		return this._font_definitions.hasOwnProperty(name);
+	}
+
+	public hasAudioDefinition (name: string): boolean {
+		return this._audio_definitions.hasOwnProperty(name);
+	}
+}

package/lib/system/Capabilities.ts

@@ -0,0 +1,265 @@
+import { ASObject } from '@awayfl/avm2';
+import { release, notImplemented, somewhatImplemented, toKeyValueArray } from '@awayfl/swf-loader';
+import { TouchscreenType } from './TouchscreenType';
+
+/**
+ * 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: Capabilities
+
+declare let window;
+
+export const DEFAULT_CAPABILITIES = {
+	LANGUAGE: 'en',
+	PLAYER_TYPE: 'PlugIn',
+	SCREEN_DPI: 96,
+	IS_DEBUGGER: false,
+};
+
+export class Capabilities extends ASObject {
+
+	static classInitializer: any = null;
+
+	constructor () {
+		super();
+	}
+
+	// static _hasEmbeddedVideo: boolean;
+	// static _hasAudio: boolean;
+	// static _avHardwareDisable: boolean;
+	private static _hasAccessibility: boolean = false;
+	// static _hasAudioEncoder: boolean;
+	// static _hasMP3: boolean;
+	// static _hasPrinting: boolean;
+	// static _hasScreenBroadcast: boolean;
+	// static _hasScreenPlayback: boolean;
+	// static _hasStreamingAudio: boolean;
+	// static _hasStreamingVideo: boolean;
+	// static _hasVideoEncoder: boolean;
+	// static _localFileReadDisable: boolean;
+	private static _language: string = null;// DEFAULT_CAPABILITIES.LANGUAGE;
+	private static _manufacturer: string = 'Mozilla Research';
+	private static _os: string = null;
+	// static _cpuArchitecture: string;
+	private static _playerType: string = null;// DEFAULT_CAPABILITIES.PLAYER_TYPE;
+	private static _version: string = 'SHUMWAY 10,0,0,0';
+	// static _screenColor: string;
+	// static _pixelAspectRatio: number;
+	private static _screenDPI: number = 0;// = DEFAULT_CAPABILITIES.SCREEN_DPI;
+	// static _touchscreenType: string;
+	// static _hasIME: boolean;
+	// static _hasTLS: boolean;
+	// static _maxLevelIDC: string;
+	// static _supports32BitProcesses: boolean;
+	// static _supports64BitProcesses: boolean;
+	// static __internal: number /*uint*/;
+	static get isEmbeddedInAcrobat(): boolean {
+		return false;
+	}
+
+	static get hasEmbeddedVideo(): boolean {
+		release || notImplemented('public flash.system.Capabilities::get hasEmbeddedVideo'); return;
+		// return Capabilities._hasEmbeddedVideo;
+	}
+
+	static get hasAudio(): boolean {
+		// The documentation says "this property is always true".
+		return true;
+	}
+
+	static get avHardwareDisable(): boolean {
+		release || somewhatImplemented('public flash.system.Capabilities::get avHardwareDisable');
+		return true;
+	}
+
+	static get hasAccessibility(): boolean {
+		release || somewhatImplemented('public flash.system.Capabilities::get hasAccessibility');
+		return Capabilities._hasAccessibility;
+	}
+
+	static get hasAudioEncoder(): boolean {
+		release || somewhatImplemented('public flash.system.Capabilities::get hasAudioEncoder');
+		return false;
+	}
+
+	static get hasMP3(): boolean {
+		release || notImplemented('public flash.system.Capabilities::get hasMP3'); return;
+		// return Capabilities._hasMP3;
+	}
+
+	static get hasPrinting(): boolean {
+		release || somewhatImplemented('public flash.system.Capabilities::get hasPrinting');
+		return false;
+	}
+
+	static get hasScreenBroadcast(): boolean {
+		release || somewhatImplemented('public flash.system.Capabilities::get hasScreenBroadcast');
+		return false;
+	}
+
+	static get hasScreenPlayback(): boolean {
+		release || somewhatImplemented('public flash.system.Capabilities::get hasScreenPlayback');
+		return false;
+	}
+
+	static get hasStreamingAudio(): boolean {
+		release || notImplemented('public flash.system.Capabilities::get hasStreamingAudio'); return;
+		// return Capabilities._hasStreamingAudio;
+	}
+
+	static get hasStreamingVideo(): boolean {
+		release || notImplemented('public flash.system.Capabilities::get hasStreamingVideo'); return;
+		// return Capabilities._hasStreamingVideo;
+	}
+
+	static get hasVideoEncoder(): boolean {
+		release || somewhatImplemented('public flash.system.Capabilities::get hasVideoEncoder');
+		return false;
+	}
+
+	static get isDebugger(): boolean {
+		return DEFAULT_CAPABILITIES.IS_DEBUGGER;
+	}
+
+	static get localFileReadDisable(): boolean {
+		release || notImplemented('public flash.system.Capabilities::get localFileReadDisable'); return;
+		// return Capabilities._localFileReadDisable;
+	}
+
+	static get language(): string {
+		release || somewhatImplemented('public flash.system.Capabilities::get language');
+		return Capabilities._language || DEFAULT_CAPABILITIES.LANGUAGE;
+	}
+
+	static get manufacturer(): string {
+		release || somewhatImplemented('public flash.system.Capabilities::get manufacturer');
+		return Capabilities._manufacturer;
+	}
+
+	static get os(): string {
+		if (Capabilities._os === null) {
+			let os;
+			const userAgent = window.navigator.userAgent;
+			if (userAgent.indexOf('Macintosh') > 0) {
+				if (userAgent.indexOf('Mac OS X ') === -1) {
+					os = 'Mac OS 10.6';
+				} else {
+					const versionStr = userAgent.split('Mac OS X ')[1];
+					os = versionStr.substr(0, versionStr.indexOf(';'));
+				}
+			} else if (userAgent.indexOf('Windows') > 0) {
+				os = 'Windows XP';
+			} else if (userAgent.indexOf('Linux') > 0) {
+				os = 'Linux';
+			} else if (/(iPad|iPhone|iPod|Android)/.test(userAgent)) {
+				os = 'iPhone3,1';
+			} else {
+				release || somewhatImplemented('public flash.system.Capabilities::get os');
+				os = 'Generic OS';
+			}
+			Capabilities._os = os;
+		}
+		return Capabilities._os;
+	}
+
+	static get cpuArchitecture(): string {
+		release || somewhatImplemented('public flash.system.Capabilities::get cpuArchitecture');
+		return 'x86';
+	}
+
+	static get playerType(): string {
+		return Capabilities._playerType || DEFAULT_CAPABILITIES.PLAYER_TYPE;
+	}
+
+	static get serverString(): string {
+		const str = toKeyValueArray({ OS: Capabilities.os }).map(function (pair) {
+			return pair[0] + '=' + encodeURIComponent(pair[1]);
+		}).join('&');
+		release || somewhatImplemented('Capabilities.serverString: ' + str);
+		return str;
+	}
+
+	static get version(): string {
+		release || somewhatImplemented('public flash.system.Capabilities::get version');
+		return Capabilities._version;
+	}
+
+	/**
+   * This can be "color", "gray" or "bw" for black and white. I don't know when you'd have anything
+   * other than "color".
+   */
+	static get screenColor(): string {
+		return 'color';
+	}
+
+	static get pixelAspectRatio(): number {
+		release || somewhatImplemented('public flash.system.Capabilities::get pixelAspectRatio');
+		return 1;
+	}
+
+	static get screenDPI(): number {
+		release || somewhatImplemented('public flash.system.Capabilities::get screenDPI');
+		return Capabilities._screenDPI || DEFAULT_CAPABILITIES.SCREEN_DPI;
+	}
+
+	static get screenResolutionX(): number {
+		release || somewhatImplemented('public flash.system.Capabilities::get screenResolutionX');
+		return window.screen.width; // TODO check
+	}
+
+	static get screenResolutionY(): number {
+		release || somewhatImplemented('public flash.system.Capabilities::get screenResolutionY');
+		return window.screen.height; // TODO check
+	}
+
+	static get touchscreenType(): string {
+		return TouchscreenType.NONE;
+	}
+
+	static get hasIME(): boolean {
+		return false;
+	}
+
+	static get hasTLS(): boolean {
+		release || notImplemented('public flash.system.Capabilities::get hasTLS'); return;
+		// return Capabilities._hasTLS;
+	}
+
+	static get maxLevelIDC(): string {
+		release || notImplemented('public flash.system.Capabilities::get maxLevelIDC'); return;
+		// return Capabilities._maxLevelIDC;
+	}
+
+	static get supports32BitProcesses(): boolean {
+		release || notImplemented('public flash.system.Capabilities::get supports32BitProcesses'); return;
+		// return Capabilities._supports32BitProcesses;
+	}
+
+	static get supports64BitProcesses(): boolean {
+		release || notImplemented('public flash.system.Capabilities::get supports64BitProcesses'); return;
+		// return Capabilities._supports64BitProcesses;
+	}
+
+	static get _internal(): number /*uint*/ {
+		release || notImplemented('public flash.system.Capabilities::get _internal'); return;
+		// return Capabilities.__internal;
+	}
+
+	static hasMultiChannelAudio(type: string): boolean {
+		release || somewhatImplemented('public flash.system.Capabilities::static hasMultiChannelAudio');
+		return false;
+	}
+
+}

package/lib/system/FSCommand.ts

@@ -0,0 +1,20 @@
+import { axCoerceString } from '@awayfl/avm2';
+
+export interface IFSCommandListener {
+	executeFSCommand(command: string, args: string);
+}
+
+export function fscommand(sec: any, command: string, args: string): void {
+	command = axCoerceString(command);
+	args = axCoerceString(args);
+	console.log('FSCommand: ' + command + '; ' + args);
+	command = command.toLowerCase();
+	if (command === 'debugger') {
+		/* tslint:disable */
+		debugger;
+		/* tslint:enable */
+		return;
+	}
+
+	(<any>sec).player.executeFSCommand(command, args);
+}