@afterswf/playerglobal 0.0.0-stage → 0.2.460

package/lib/media/SoundChannel.ts

@@ -0,0 +1,160 @@
+import { EventDispatcher } from '../events/EventDispatcher';
+import { SoundTransform } from './SoundTransform';
+import { release } from '@awayfl/swf-loader';
+import { SecurityDomain } from '../SecurityDomain';
+import { Event } from '../events/Event';
+import { EventBase, IAudioChannel } from '@awayjs/core';
+import { ISoundSource, SoundMixer } from './SoundMixer';
+import { BaseAudioChannel } from '@awayjs/core/dist/lib/managers/BaseAudioChannel';
+
+/**
+ * Dispatched when a sound has finished playing.
+ * @eventType	flash.events.Event.SOUND_COMPLETE
+ * [Event(name="soundComplete", type="flash.events.Event")]
+ *
+ * The SoundChannel class controls a sound in an application. Every sound
+ * is assigned to a sound channel, and the application can have multiple
+ * sound channels that are mixed together.
+ * The SoundChannel class contains a <codeph class="+ topic/ph pr-d/codeph ">stop()</codeph> method,
+ * properties for monitoring the amplitude (volume) of the channel, and a property for assigning a
+ * SoundTransform object to the channel.
+ */
+export class SoundChannel extends EventDispatcher implements ISoundSource {
+	// for AVM1:
+	public axCallPublicProperty(value1: any, value2: any): any {
+		return null;
+	}
+
+	public axGetPublicProperty(value: any): any {
+		return null;
+	}
+
+	public axSetPublicProperty(value: any, value2: any): any {
+		return null;
+	}
+
+	public axHasPublicProperty(value: any): any {
+		return null;
+	}
+
+	public axDeletePublicProperty(value: any): any {
+		return null;
+	}
+
+	public axGetEnumerableKeys(): string[] {
+		return [];
+	}
+
+	private _soundTransform: SoundTransform;
+	private _channel: IAudioChannel;
+
+	/* internal */ init (channel: IAudioChannel | null, transform: SoundTransform) {
+		this._channel = channel;
+
+		if (!this._channel) {
+			return;
+		}
+
+		this._channel.addEventListener(BaseAudioChannel.COMPLETE, this.soundCompleteInternal.bind(this));
+
+		this.soundTransform = transform;
+
+		SoundMixer._registerSoundSource(this);
+	}
+
+	/**
+	 * The current amplitude (volume) of the left channel, from 0 (silent) to 1 (full amplitude).
+	 */
+	public get leftPeak(): number {
+		release || console.log('leftPeak not implemented yet in flash/SoundChannel');
+		return 0;
+	}
+
+	/**
+	 * When the sound is playing, the position property indicates in milliseconds the current point
+	 * that is being played in the sound file. When the sound is stopped or paused, the
+	 * position property indicates the last point that was played in the sound file.
+	 *
+	 *   A common use case is to save the value of the position property when the
+	 * sound is stopped. You can resume the sound later by restarting it from that saved position.
+	 * If the sound is looped, position is reset to 0 at the beginning of each loop.
+	 */
+	public get position(): number {
+		return this._channel ? this._channel.currentTime : 0;
+	}
+
+	/**
+	 * The current amplitude (volume) of the right channel, from 0 (silent) to 1 (full amplitude).
+	 */
+	public get rightPeak(): number {
+		release || console.log('rightPeak not implemented yet in flash/SoundChannel');
+		return 0;
+	}
+
+	/**
+	 * The SoundTransform object assigned to the sound channel. A SoundTransform object
+	 * includes properties for setting volume, panning, left speaker assignment, and right
+	 * speaker assignment.
+	 */
+	public get soundTransform(): SoundTransform {
+		//	we not create this in the constructor, because it gets overwritten from Sound in most cases anyway
+		//	but we still need a Soundtransform to be available in the getter
+		if (!this._soundTransform) {
+			this._soundTransform = new (<any> this.sec).flash.media.SoundTransform();
+		}
+		return this._soundTransform;
+	}
+
+	public set soundTransform(value: SoundTransform) {
+
+		if (this._channel) {
+			this._channel.volume = (value.volume == null) ? 0 : value.volume;
+			this._channel.pan = (value.pan == null) ? 0 : value.pan;
+		}
+
+		this._soundTransform = value;
+	}
+
+	private soundCompleteInternal(event: EventBase) {
+		this._stopInternally();
+		// we should dispatch sound events to channel, because some games use this
+		const complete = new (<SecurityDomain> this.sec).flash.events.Event(Event.SOUND_COMPLETE);
+		this.dispatchEvent(complete);
+	}
+
+	private _stopInternally() {
+		SoundMixer._unregisterSoundSource(this);
+	}
+
+	/**
+	 * Stops the sound playing in the channel.
+	 * @langversion	3.0
+	 * @playerversion	Flash 9
+	 * @playerversion	Lite 4
+	 * @refpath
+	 */
+	public stop() {
+		if (!this._channel) {
+			release || console.log('SoundChannel.stop: No sound exists');
+			return;
+		}
+
+		this._stopInternally();
+		this._channel.stop();
+	}
+
+	// for ISoundSource
+	stopSound() {
+		this.stop();
+	}
+
+	// for ISoundSource
+	updateSoundLevels(volume: number) {
+		if (!this._channel) {
+			return;
+		}
+
+		this._soundTransform.volume = volume;
+		this._channel.volume = volume;
+	}
+}

package/lib/media/SoundLoaderContext.ts

@@ -0,0 +1,104 @@
+
+/**
+ * The SoundLoaderContext class provides security checks for files that load sound.
+ * SoundLoaderContext objects are passed as an argument to the constructor and the
+ * <codeph class="+ topic/ph pr-d/codeph ">load()</codeph> method of the Sound class.
+ *
+ */
+export class SoundLoaderContext {
+
+	/**
+	 * Creates a new sound loader context object.
+	 * @param	bufferTime	The number of seconds to preload a streaming sound into a buffer
+	 *   before the sound starts to stream.
+	 * @param	checkPolicyFile	Specifies whether the existence of a URL policy file
+	 *   should be checked upon loading the object (true) or not.
+	 */
+	constructor (bufferTime: number = 1000, checkPolicyFile: boolean = false) {
+
+	}
+
+	/**
+	 * The number of milliseconds to preload a streaming sound into a buffer
+	 * before the sound starts to stream.
+	 *
+	 *   Note that you cannot override the value of SoundLoaderContext.bufferTime
+	 * by setting the global SoundMixer.bufferTime property.
+	 * The SoundMixer.bufferTime property affects the buffer time
+	 * for embedded streaming sounds in a SWF file and is independent of dynamically created
+	 * Sound objects (that is, Sound objects created in ActionScript).
+	 * @langversion	3.0
+	 * @playerversion	Flash 9
+	 * @playerversion	Lite 4
+	 */
+	public bufferTime: number;
+
+	/**
+	 * Specifies whether the application should try to download a URL policy file from the
+	 * loaded sound's server before beginning to load the sound. This property applies to
+	 * sound that is loaded from outside
+	 * the calling file's own domain using the Sound.load() method.
+	 *
+	 *   Set this property to true when you load a sound from outside the
+	 * calling file's own domain and code in the calling file needs low-level access to
+	 * the sound's data. Examples of low-level access to a sound's data
+	 * include referencing the Sound.id3 property to get an
+	 * ID3Info object or calling the SoundMixer.computeSpectrum() method to get
+	 * sound samples from the loaded sound. If you try to access sound data without
+	 * setting the checkPolicyFile property to true at loading time,
+	 * you may get a SecurityError exception because the required policy file has not been downloaded.
+	 * If you don't need low-level access to the sound data that you are loading, avoid setting
+	 * checkPolicyFile to true. Checking for a policy file consumes
+	 * network bandwidth
+	 * and might delay the start of your download, so it should only be done when necessary.
+	 * When you call Sound.load() with SoundLoaderContext.checkPolicyFile set
+	 * to true, Flash Player or AIR  must
+	 * either successfully download a relevant URL policy file or determine that no such policy file
+	 * exists before it begins downloading the specified sound.
+	 * Flash Player or AIR performs the following
+	 * actions, in this order, to verify the existence of a policy file:Flash Player or AIR considers policy
+	 * files that have already been downloaded.Flash Player or AIR tries
+	 * to download any pending policy files specified in calls to
+	 * Security.loadPolicyFile().Flash Player or AIR tries to download a
+	 * policy file from the default location that corresponds to the sound's URL, which is
+	 * /crossdomain.xml on the same server as URLRequest.url.
+	 * (The sound's URL is specified in the url property of the URLRequest object
+	 * passed to Sound.load() or the Sound() constructor function.)In all cases, Flash Player or AIR
+	 * requires that an appropriate policy file exist on the sound's server, that it provide access
+	 * to the sound file at URLRequest.url by virtue of the policy file's location, and
+	 * that it allow the domain of the calling file to access the sound, through one or more
+	 * <allow-access-from> tags.
+	 * If you set checkPolicyFile to true,
+	 * Flash Player or AIR waits until the policy file is verified
+	 * before loading the sound. You should wait to perform
+	 * any low-level operations on the sound data, such as calling Sound.id3 or
+	 * SoundMixer.computeSpectrum(), until progress and complete
+	 * events are dispatched from the Sound object.
+	 * If you set checkPolicyFile to true but no appropriate policy file is found,
+	 * you will not receive an error until you perform an operation that requires
+	 * a policy file, and then Flash Player or AIR throws a
+	 * SecurityError exception. After you receive a complete
+	 * event, you can test whether a relevant policy file was found by getting the value
+	 * of Sound.id3 within a try block and seeing if a
+	 * SecurityError is thrown.Be careful with checkPolicyFile if you are downloading sound from a URL that
+	 * uses server-side HTTP redirects. Flash Player or AIR tries to retrieve policy files that
+	 * correspond to the url property of the URLRequest object
+	 * passed to Sound.load(). If the final
+	 * sound file comes from a different URL because of HTTP redirects, then the initially downloaded
+	 * policy files might not be applicable to the sound's final URL, which is the URL that matters
+	 * in security decisions.If you find yourself in this situation, here is one possible solution.
+	 * After you receive a progress or complete event, you can examine the value of
+	 * the Sound.url property, which contains the sound's final URL.
+	 * Then call the Security.loadPolicyFile() method
+	 * with a policy file URL that you calculate based on the sound's final URL. Finally, poll the value
+	 * of Sound.id3 until no exception is thrown.This does not apply to content in the AIR application sandbox.
+	 * Content in the application sandbox always has programatic access to sound content, regardless
+	 * of its origin.For more information related to security, see the Flash Player Developer Center Topic:
+	 * Security.
+	 * @langversion	3.0
+	 * @playerversion	Flash 9
+	 * @playerversion	Lite 4
+	 * @internal	: please review at same time: checkPolicyFile property in LoaderContext, NetStream
+	 */
+	public checkPolicyFile: boolean;
+}

package/lib/media/SoundMixer.ts

@@ -0,0 +1,152 @@
+import { somewhatImplemented, release, notImplemented, isNullOrUndefined } from '@awayfl/swf-loader';
+import { ByteArray, ASObject } from '@awayfl/avm2';
+import { SoundTransform } from './SoundTransform';
+import { MovieClip as AwayMovieClip } from '@awayjs/scene';
+import { AudioManager } from '@awayjs/core';
+
+/**
+ * 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: SoundMixer
+
+export interface ISoundSource {
+	soundTransform: SoundTransform;
+	updateSoundLevels(volume: number);
+	stopSound();
+}
+
+export class SoundMixer extends ASObject {
+
+	// Called whenever the class is initialized.
+	static classInitializer: any = null;
+
+	// List of static symbols to link.
+	static classSymbols: string [] = null; // [];
+
+	// List of instance symbols to link.
+	static instanceSymbols: string [] = null; // [];
+
+	constructor () {
+		super();
+	}
+
+	private static _masterVolume = 1;
+	private static _registeredSoundSources: ISoundSource[] = [];
+	private static _bufferTime = 0;
+	static _soundTransform: SoundTransform;
+	// static _audioPlaybackMode: string;
+	// static _useSpeakerphoneForVoice: boolean;
+
+	static get bufferTime(): number /*int*/ {
+		release || notImplemented('public flash.media.SoundMixer::get bufferTime');
+		return SoundMixer._bufferTime;
+	}
+
+	static set bufferTime(bufferTime: number /*int*/) {
+		release || somewhatImplemented('public flash.media.SoundMixer::set bufferTime');
+		SoundMixer._bufferTime = bufferTime | 0;
+	}
+
+	static get soundTransform(): SoundTransform {
+		release || somewhatImplemented('public flash.media.SoundMixer::get soundTransform');
+		return isNullOrUndefined(SoundMixer._soundTransform) ?
+			new SoundTransform() :
+			new SoundTransform(SoundMixer._soundTransform.volume,
+				SoundMixer._soundTransform.pan);
+	}
+
+	static set soundTransform(sndTransform: SoundTransform) {
+		release || somewhatImplemented('public flash.media.SoundMixer::set soundTransform');
+		SoundMixer._soundTransform = isNullOrUndefined(sndTransform) ?
+			new SoundTransform() :
+			sndTransform;
+		SoundMixer._updateAllSoundSources();
+	}
+
+	static get audioPlaybackMode(): string {
+		release || notImplemented('public flash.media.SoundMixer::get audioPlaybackMode'); return;
+		// return SoundMixer._audioPlaybackMode;
+	}
+
+	static set audioPlaybackMode(_value: string) {
+		release || notImplemented('public flash.media.SoundMixer::set audioPlaybackMode'); return;
+		// SoundMixer._audioPlaybackMode = value;
+	}
+
+	static get useSpeakerphoneForVoice(): boolean {
+		release || notImplemented('public flash.media.SoundMixer::get useSpeakerphoneForVoice'); return;
+		// return SoundMixer._useSpeakerphoneForVoice;
+	}
+
+	static set useSpeakerphoneForVoice(_value: boolean) {
+		release || notImplemented('public flash.media.SoundMixer::set useSpeakerphoneForVoice'); return;
+		// SoundMixer._useSpeakerphoneForVoice = value;
+	}
+
+	static stopAll(): void {
+		SoundMixer._registeredSoundSources.forEach((e) => e.stopSound());
+		SoundMixer._registeredSoundSources = [];
+
+		AwayMovieClip.stopSounds();
+	}
+
+	static computeSpectrum(
+		outputArray: ByteArray,
+		_FFTMode: boolean = false,
+		_stretchFactor: number /*int*/ = 0
+	): void {
+		release || somewhatImplemented('public flash.media.SoundMixer::static computeSpectrum');
+		const data = new Float32Array(1024);
+		for (let i = 0; i < 1024; i++) {
+			data[i] = Math.random();
+		}
+		outputArray.writeRawBytes(<any>data);
+		outputArray.position = 0;
+	}
+
+	static areSoundsInaccessible(): boolean {
+		release || notImplemented('public flash.media.SoundMixer::static areSoundsInaccessible'); return;
+	}
+
+	static _getMasterVolume(): number {
+		return SoundMixer._masterVolume;
+	}
+
+	static _setMasterVolume(volume) {
+		volume = +volume;
+		SoundMixer._masterVolume = volume;
+		SoundMixer._updateAllSoundSources();
+	}
+
+	static _registerSoundSource(source: ISoundSource) {
+		SoundMixer._registeredSoundSources.push(source);
+	}
+
+	static _unregisterSoundSource(source: ISoundSource) {
+		const index =  SoundMixer._registeredSoundSources.indexOf(source);
+		if (index >= 0) {
+			SoundMixer._registeredSoundSources.splice(index, 1);
+		}
+	}
+
+	static _updateAllSoundSources() {
+		let volume = SoundMixer._getMasterVolume();
+		if (SoundMixer._soundTransform) {
+			volume *= SoundMixer._soundTransform.volume;
+		}
+
+		AudioManager.setVolume(volume, -1);
+	}
+}

package/lib/media/SoundTransform.ts

@@ -0,0 +1,137 @@
+import { ASObject, AXClass } from '@awayfl/avm2';
+
+/**
+ * The SoundTransform class contains properties for volume and panning.
+ *
+ */
+export class SoundTransform extends ASObject {
+
+	static axClass: typeof SoundTransform & AXClass;
+	// for AVM1:
+	public axCallPublicProperty(value1: any, value2: any): any {
+		console.log('axCallPublicProperty not implemented yet in flash/SoundTransform');
+		return null;
+	}
+
+	public axGetPublicProperty(value: any): any {
+		console.log('axGetPublicProperty not implemented yet in flash/SoundTransform');
+		return null;
+	}
+
+	public axSetPublicProperty(value: any, value2: any): any {
+		console.log('axSetPublicProperty not implemented yet in flash/SoundTransform');
+		return null;
+	}
+
+	public axHasPublicProperty(value: any): any {
+		console.log('axHasPublicProperty not implemented yet in flash/SoundTransform');
+		return null;
+	}
+
+	public axDeletePublicProperty(value: any): any {
+		console.log('axDeletePublicProperty not implemented yet in flash/SoundTransform');
+		return null;
+	}
+
+	public axGetEnumerableKeys(): string[] {
+		console.log('axGetEnumerableKeys not implemented yet in flash/SoundTransform');
+		return [];
+	}
+
+	private _vol: number = 1;
+	private _pan: number = 0;
+	/**
+	 * Creates a SoundTransform object.
+	 * @param	vol	The volume, ranging from 0 (silent) to 1 (full volume).
+	 * @param	panning	The left-to-right panning of the sound, ranging from -1 (full pan left)
+	 *   to 1 (full pan right). A value of 0 represents no panning (center).
+	 * @langversion	3.0
+	 * @playerversion	Flash 9
+	 * @playerversion	Lite 4
+	 * @refpath
+	 */
+	constructor (vol: number = 1, panning: number = 0) {
+		super();
+		this._vol = vol;
+		this._pan = panning;
+	}
+
+	/**
+	 * A value, from 0 (none) to 1 (all), specifying how much of the left input is played in the
+	 * left speaker.
+	 */
+	public get leftToLeft (): number {
+		console.log('leftToLeft not implemented yet in flash/SoundTransform');
+		return 0;
+	}
+
+	public set leftToLeft (leftToLeft: number) {
+		console.log('leftToLeft not implemented yet in flash/SoundTransform');
+	}
+
+	/**
+	 * A value, from 0 (none) to 1 (all), specifying how much of the left input is played in the
+	 * right speaker.
+	 */
+	public get leftToRight (): number {
+		console.log('leftToRight not implemented yet in flash/SoundTransform');
+		return 0;
+	}
+
+	public set leftToRight (leftToRight: number) {
+		console.log('leftToRight not implemented yet in flash/SoundTransform');
+	}
+
+	/**
+	 * The left-to-right panning of the sound, ranging from -1 (full pan left)
+	 * to 1 (full pan right). A value of 0 represents no panning (balanced center between
+	 * right and left).
+	 */
+	public get pan (): number {
+		return this._pan;
+	}
+
+	public set pan (value: number) {
+		this._pan = value;
+	}
+
+	/**
+	 * A value, from 0 (none) to 1 (all), specifying how much of the right input is played in the
+	 * left speaker.
+	 */
+	public get rightToLeft (): number {
+		console.log('rightToLeft not implemented yet in flash/SoundTransform');
+		return 0;
+	}
+
+	public set rightToLeft (rightToLeft: number) {
+		console.log('rightToLeft not implemented yet in flash/SoundTransform');
+	}
+
+	/**
+	 * A value, from 0 (none) to 1 (all), specifying how much of the right input is played in the
+	 * right speaker.
+	 */
+	public get rightToRight (): number {
+		console.log('rightToRight not implemented yet in flash/SoundTransform');
+		return 0;
+	}
+
+	public set rightToRight (rightToRight: number) {
+		console.log('rightToRight not implemented yet in flash/SoundTransform');
+	}
+
+	/**
+	 * The volume, ranging from 0 (silent) to 1 (full volume).
+	 */
+	public get volume (): number {
+		return this._vol;
+	}
+
+	public set volume (value: number) {
+		this._vol = (value > 1)
+			? 1
+			: (value < 0 ? 0 : value);
+	}
+
+}

package/lib/net/FileFilter.ts

@@ -0,0 +1,32 @@
+
+import { ASObject } from '@awayfl/avm2';
+export class FileFilter extends ASObject {
+
+	private _description: string;
+	private _extension: string;
+	private _macType: string;
+
+	public get description(): string {
+		return this._description;
+	}
+
+	public set description(value: string) {
+		this._description = value;
+	}
+
+	public get extension(): string {
+		return this._extension;
+	}
+
+	public set extension(value: string) {
+		this._extension = value;
+	}
+
+	public get macType(): string {
+		return this._macType;
+	}
+
+	public set macType(value: string) {
+		this._macType = value;
+	}
+}