@afterswf/playerglobal 0.0.0-stage → 0.2.460

package/lib/net/FileReference.ts

@@ -0,0 +1,293 @@
+import { URLRequest } from './URLRequest';
+import { EventDispatcher } from '../events/EventDispatcher';
+import { ByteArray } from '../utils/ByteArray';
+import { FileFilter } from './FileFilter';
+import { ASObject } from '@awayfl/avm2';
+import { SecurityDomain } from '../SecurityDomain';
+import { Event } from '../events/Event';
+import { Settings } from '../Settings';
+
+const USE_FILE_PICKER = ('showSaveFilePicker' in self) && Settings.ENABLE_FILE_PICKER;
+
+if (USE_FILE_PICKER) {
+	console.debug('[FileReference] `showSaveFilePicker` used for save()');
+}
+
+export class FileReference extends EventDispatcher {
+	public static forceNativeMethods = true;
+
+	private _creationDate: Date;
+	private _modificationDate: Date;
+	private _name: string;
+	private _size: number;
+	private _creator: string;
+	private _type: string;
+	private _permissionStatus: string;
+	private _extension: string;
+	private _data: ByteArray;
+
+	constructor() {
+		super();
+	}
+
+	public get size(): number {
+		return this._size;
+	}
+
+	public set size(value: number) {
+		this._size = value;
+	}
+
+	public get data(): ByteArray {
+		return this._data;
+	}
+
+	public set data(value: ByteArray) {
+		this._data = value;
+	}
+
+	public get extension(): string {
+		return this._extension;
+	}
+
+	public set extension(value: string) {
+		this._extension = value;
+	}
+
+	public get permissionStatus(): string {
+		return this._permissionStatus;
+	}
+
+	public set permissionStatus(value: string) {
+		this._permissionStatus = value;
+	}
+
+	public get type(): string {
+		return this._type;
+	}
+
+	public set type(value: string) {
+		this._type = value;
+	}
+
+	public get creator(): string {
+		return this._creator;
+	}
+
+	public set creator(value: string) {
+		this._creator = value;
+	}
+
+	public get name(): string {
+		return this._name;
+	}
+
+	public set name(value: string) {
+		this._name = value;
+	}
+
+	public get modificationDate(): Date {
+		return this._modificationDate;
+	}
+
+	public set modificationDate(value: Date) {
+		this._modificationDate = value;
+	}
+
+	public get creationDate(): Date {
+		return this._creationDate;
+	}
+
+	public set creationDate(value: Date) {
+		this._creationDate = value;
+	}
+
+	private static knownMimeTypes = {
+		'.jpeg': { 'mime': 'image/jpeg', 'description': 'JPEG images' },
+		'.jpg': { 'mime': 'image/jpeg', 'description': 'JPEG images' },
+		'.txt': { 'mime': 'text/plain', 'description': 'Text documents' },
+	}
+
+	//Displays a file-browsing dialog box that lets the user select a file to upload.
+	public browse(typelist: FileFilter[]): boolean {
+		const knownTypes = FileReference.knownMimeTypes;
+		const openDialog: (options: OpenFilePickerOptions) => Promise<[FileSystemFileHandle]> = window.showOpenFilePicker;
+
+		if (!openDialog) {
+			console.warn('[flash/net/FileReference] FileSystem API not supported!');
+			return false;
+		}
+
+		const types = [];
+		for (let i = 0; i < typelist.length; i++) {
+			const filter = typelist[i];
+			const extension = filter.extension.slice(filter.extension.lastIndexOf('.'));
+			const mime = extension in knownTypes ? knownTypes[extension]['mime'] : 'application/unknown';
+			types.push({
+				description: filter.description,
+				accept: { [mime]: extension }
+			});
+		}
+
+		const options: OpenFilePickerOptions = {
+			types
+		};
+
+		openDialog(options)
+			.then((fileHandler) => {
+				this._sendSelectEvent();
+				return fileHandler[0].getFile();
+			})
+			.then((file) => {
+				this.modificationDate = new Date(file.lastModified);
+				this.name = file.name;
+				this.size = file.size;
+				this.type = file.type;
+
+				const extIndex = file.name.lastIndexOf('.');
+				this.extension = extIndex >= 0 ? file.name.slice(extIndex + 1) : null;
+
+				return file.arrayBuffer();
+			})
+			.then((buf)=>{
+				this.data = new ByteArray(buf.byteLength);
+				this.data.setArrayBuffer(buf);
+				this._sendCompleteEvent();
+			})
+			.catch((e: DOMException) => {
+				if (e.code === 20 && e.message === 'The user aborted a request.') {
+					this._sendCancelEvent();
+					return;
+				}
+
+				console.warn('[flash/net/FileReference] FileSystem API Reject `showOpenFilePicker` request:', e);
+			});
+
+		return true;
+	}
+
+	//Starts the upload of the file to a remote server.
+	public upload(url: URLRequest): boolean {
+		console.log('upload not implemented yet in flash/FileReference');
+		return true;
+	}
+
+	//Starts the load of a local file selected by a user.
+	public load() {
+		console.log('load not implemented yet in flash/FileReference');
+	}
+
+	//Opens a dialog box that lets the user save a file to the local filesystem.
+	public save(data: string | ASObject, _defaultFileName: string = null) {
+		if (this._useFileSystemSave(data, _defaultFileName)) {
+			return;
+		}
+	}
+
+	private _useFileSystemSave(data: any, name: string = ''): boolean {
+		const knownTypes = FileReference.knownMimeTypes;
+		const isString = typeof data === 'string';
+		const isByteArray = data.getBytes !== undefined;
+		const ext = name.slice(name.lastIndexOf('.'));
+
+		if (!USE_FILE_PICKER)
+			return false;
+
+		// this is draft API
+		// https://web.dev/file-system-access/
+		const openDialog: (options?: SaveFilePickerOptions) => Promise<FileSystemFileHandle> = window.showSaveFilePicker;
+
+		if (!openDialog) {
+			console.warn('[flash/net/FileReference] FileSystem API not supported!');
+			return false;
+		}
+
+		if (!isString && !isByteArray) {
+			console.warn('[FileReference] Save is only supported for String and ByteArray');
+			return;
+		}
+
+		const types: FilePickerAcceptType[] = [];
+		if (ext in knownTypes) {
+			const mime = knownTypes[ext].mime;
+			types[0] = {
+				description: knownTypes[ext].description,
+				accept: { [mime] : ext as `.${string}` },
+			};
+		} else {
+			types[0] = {
+				description: '',
+				accept: { 'application/unknown' : ext as `.${string}` },
+			};
+		}
+
+		const options: SaveFilePickerOptions = {
+			suggestedName: name || '',
+			types
+		};
+
+		openDialog(options)
+			.then((fileHandler) => {
+				this._sendSelectEvent();
+				return fileHandler.createWritable();
+			})
+			.then((stream) => {
+				return stream
+					.write(isByteArray ? data.getBytes() : data)
+					.then(() => stream.close());
+			})
+			.then((_e)=>{
+				this._sendCompleteEvent();
+			})
+			.catch((e: DOMException) => {
+				if (e.code === 20 && e.message === 'The user aborted a request.') {
+					this._sendCancelEvent();
+					return;
+				}
+
+				console.warn('[flash/net/FileReference] FileSystem API Reject `showSaveFilePicker` request:', e);
+			});
+	}
+
+	private _sendCancelEvent() {
+		const event  = new (<SecurityDomain> this.sec).flash.events.Event(Event.CANCEL);
+
+		event.currentTarget = this;
+		event.target = this;
+
+		this.dispatchEvent(event);
+	}
+
+	private _sendCompleteEvent() {
+		const event  = new (<SecurityDomain> this.sec).flash.events.Event(Event.COMPLETE);
+		event.currentTarget = this;
+		event.target = this;
+
+		this.dispatchEvent(event);
+	}
+
+	private _sendSelectEvent() {
+		const event  = new (<SecurityDomain> this.sec).flash.events.Event(Event.SELECT);
+
+		event.currentTarget = this;
+		event.target = this;
+
+		this.dispatchEvent(event);
+	}
+
+	//Requests permission to access filesystem.
+	public requestPermission() {
+		console.log('upload not implemented yet in flash/FileReference');
+	}
+
+	//Opens a dialog box that lets the user download a file from a remote server.
+	public download(url: URLRequest, defaultFileName: string): boolean {
+		console.log('download not implemented yet in flash/FileReference');
+		return true;
+	}
+
+	//Cancels any ongoing upload or download operation on this FileReference object.
+	public cancel() {
+		console.log('cancel not implemented yet in flash/FileReference');
+	}
+}

package/lib/net/LocalConnection.ts

@@ -0,0 +1,267 @@
+import { EventDispatcher } from '../events/EventDispatcher';
+//import { LocalConnectionService, LocalConnectionConnectResult } from "../../base/utilities/LocalConnectionService";
+import {
+	axCoerceString,
+	axIsCallable,
+	axIsTypeString,
+	ASObject,
+	ASError,
+	ASArray,
+	Errors,
+	ByteArray
+} from '@awayfl/avm2';
+import { assert, notImplemented, release, warning } from '@awayfl/swf-loader';
+import { ErrorEvent } from '../events/ErrorEvent';
+
+/**
+ * Copyright 2015 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.
+ */
+
+const LocalConnectionService = {} as any;
+const LocalConnectionConnectResult = {} as any;
+
+const forbiddenNames = ['send', 'connect', 'close', 'allowDomain', 'allowInsecureDomain', 'client', 'domain'];
+Object.freeze(forbiddenNames);
+
+export class LocalConnection extends EventDispatcher {
+
+	static classInitializer = null;
+
+	constructor () {
+		super();
+		this._client = this;
+		this._connectionName = null;
+		this._allowedInsecureDomains = [];
+		this._allowedSecureDomains = [];
+
+		// tsc contains a definition for URL that's non-constructible.
+		const url = new (<any>URL)(document.baseURI /*getCurrentABC().env.url*/);
+		this._domain = url.hostname;
+		this._secure = url.protocol === 'https:';
+	}
+
+	static get isSupported() {
+		return true;
+	}
+
+	private _domain: string;
+	private _secure: boolean;
+
+	private _client: ASObject;
+	private _connectionName: string;
+
+	// Required because allowDomain can be called before a connection is made.
+	private _allowedInsecureDomains: string[];
+	private _allowedSecureDomains: string[];
+
+	close(): void {
+		const connectionName = this._connectionName;
+		if (!connectionName) {
+			this.sec.throwError('ArgumentError', Errors.CloseNotConnectedError);
+		}
+		release || assert(typeof connectionName === 'string' && connectionName.length > 0);
+		this._connectionName = null;
+		// TODO: verify that these really are reset. For now, we aim to err on the safe side.
+		this._allowedInsecureDomains = [];
+		this._allowedSecureDomains = [];
+
+		//LocalConnectionService.closeConnection(connectionName, this);
+
+		notImplemented('public flash.net.LocalConnection::close');
+	}
+
+	connect(connectionName: string): void {
+
+		notImplemented('public flash.net.LocalConnection::connect');
+		return;
+
+		connectionName = axCoerceString(connectionName);
+		if (connectionName === null) {
+			this.sec.throwError('TypeError', Errors.NullPointerError, 'connectionName');
+		}
+		if (connectionName === '') {
+			this.sec.throwError('TypeError', Errors.EmptyStringError, 'connectionName');
+		}
+		// The only disallowed character for the connection name is ":".
+		if (connectionName.indexOf(':') > -1) {
+			this.sec.throwError('ArgumentError', Errors.InvalidParamError);
+		}
+		if (this._connectionName) {
+			this.sec.throwError('ArgumentError', Errors.AlreadyConnectedError);
+		}
+
+		const result = LocalConnectionService.createConnection(connectionName, this);
+		if (result === LocalConnectionConnectResult.AlreadyTaken) {
+			this.sec.throwError('ArgumentError', Errors.AlreadyConnectedError);
+		}
+		this._connectionName = connectionName;
+		release || assert(result === LocalConnectionConnectResult.Success);
+		if (this._allowedInsecureDomains.length) {
+			LocalConnectionService.allowDomains(connectionName, this,
+				this._allowedInsecureDomains, false);
+		}
+		if (this._allowedSecureDomains.length) {
+			LocalConnectionService.allowDomains(connectionName, this,
+				this._allowedSecureDomains, true);
+		}
+	}
+
+	send(connectionName: string, methodName: string, ...args): void {
+
+		notImplemented('public flash.net.LocalConnection::send');
+		return;
+
+		connectionName = axCoerceString(connectionName);
+		methodName = axCoerceString(methodName);
+		if (connectionName === null) {
+			this.sec.throwError('TypeError', Errors.NullPointerError, 'connectionName');
+		}
+		if (connectionName === '') {
+			this.sec.throwError('TypeError', Errors.EmptyStringError, 'connectionName');
+		}
+		if (methodName === null) {
+			this.sec.throwError('TypeError', Errors.NullPointerError, 'methodName');
+		}
+		if (methodName === '') {
+			this.sec.throwError('TypeError', Errors.EmptyStringError, 'methodName');
+		}
+		if (forbiddenNames.indexOf(methodName) > -1) {
+			this.sec.throwError('ArgumentError', Errors.InvalidParamError);
+		}
+		const serializedArgs = new ByteArray();
+		serializedArgs.writeObject(this.sec.createArrayUnsafe(args));
+		if (serializedArgs.length > 40 * 1024) {
+			this.sec.throwError('ArgumentError', Errors.ArgumentSizeError);
+		}
+		const argsBuffer = serializedArgs.getBytes().buffer;
+		try {
+			LocalConnectionService.send(connectionName, methodName, argsBuffer, this,
+				this._domain, this._secure);
+		} catch (e) {
+			// Not sure what to do here, this shouldn't happen. We'll just ignore it with a warning.
+			warning('Unknown error occurred in LocalConnection#send', e);
+		}
+	}
+
+	get client(): ASObject {
+		return this._client;
+	}
+
+	set client(client: ASObject) {
+		if (!this.sec.AXObject.axIsType(client)) {
+			this.sec.throwError('ArgumentError', Errors.InvalidParamError);
+		}
+		this._client = client;
+	}
+
+	allowDomain(...domains: string[]): void {
+		this._allowDomains(domains, true);
+	}
+
+	allowInsecureDomain(...domains: string[]): void {
+		// allowInsecureDomain also allows secure domains.
+		this._allowDomains(domains, true);
+		this._allowDomains(domains, false);
+	}
+
+	private _allowDomains(domains: string[], secure: boolean) {
+
+		notImplemented('private flash.net.LocalConnection::_allowDomains');
+		return;
+
+		let result: string[] = [];
+		// If no connection has been made yet, store the domains for later retrieval.
+		if (!this._connectionName) {
+			result = secure ? this._allowedSecureDomains : this._allowedInsecureDomains;
+		}
+		for (let i = 0; i < domains.length; i++) {
+			const domain = domains[i];
+			if (!axIsTypeString(domain)) {
+				this.sec.throwError('ArgumentError', Errors.AllowDomainArgumentError);
+			}
+			if (result.indexOf(domain) === -1) {
+				result.push(domain);
+			}
+		}
+		if (this._connectionName) {
+			LocalConnectionService.allowDomains(this._connectionName, this, domains, secure);
+		}
+	}
+
+	public handleMessage(methodName: string, argsBuffer: ArrayBuffer): void {
+		const client = this._client;
+		let error: ASError;
+		if (!client.axHasPublicProperty(methodName) || forbiddenNames.indexOf(methodName) > -1) {
+			// Forbidden names really shouldn't reach this point, but should everything else fail,
+			// we just pretend not to have found them here.
+			error = <any> this.sec.createError('ReferenceError', Errors.ReadSealedError, methodName,
+				client.axClass.name.name);
+		} else {
+			const handler = client.axGetPublicProperty(methodName);
+			if (!axIsCallable(handler)) {
+				// Non-callable handlers are just ignored.
+				return;
+			}
+
+			const ba: ByteArray = new ByteArray(argsBuffer);
+			const args: ASArray = ba.readObject();
+			if (!this.sec.AXArray.axIsType(args)) {
+				error =
+          <any> this.sec.createError('TypeError', Errors.CheckTypeFailedError, args, 'Array');
+			} else {
+				try {
+					handler.apply(client, args.value);
+				} catch (e) {
+					error = e;
+				}
+			}
+		}
+		if (!error) {
+			return;
+		}
+		const errorEvent = new ErrorEvent('asyncError', false, false,
+			'Error #2095: flash.net.LocalConnection was' +
+                                              ' unable to invoke' +
+                                              ' callback ' + methodName + '.', error.errorID);
+		if (this.hasEventListener('asyncError')) {
+			try {
+				this.dispatchEvent(errorEvent);
+			} catch (e) {
+				console.warn('Exception encountered during asyncErrorEvent handling in ' +
+                      'LocalConnection sender.');
+			}
+		} else {
+			// TODO: add the error to the LoaderInfo#uncaughtErrorEvents list.
+			console.warn('No handler for asyncError on LocalConnection sender, not sending event',
+				errorEvent);
+		}
+	}
+
+	get domain(): string {
+		return this._domain;
+	}
+
+	get isPerUser(): boolean {
+		// We always return true, because everything else would be a lie.
+		return true;
+	}
+
+	set isPerUser(newValue: boolean) {
+		!!newValue;
+		// Ignored. See
+		// https://blogs.adobe.com/simplicity/2009/08/localconnectionisperuser_in_ai.html for an
+		// explanation.
+	}
+}