Wie verhindere ich, dass ein sound in AS3 zu spielen, anderen sound?

Ich hatte dieses problem - es war zum Verrücktwerden! In anderen Sprachen (java, C#) hätte ich verwendet, Synchronisation um einen kritischen Abschnitt. In Flash hatte ich es imitieren. Es ist nicht perfekt - noch eine kleine chance, dass der zweite Ton wird spielen über dem ersten, aber es ist sehr klein.

Hier ist der Schlüssel: implementieren Sie eine Kombination aus factory und singleton-Muster.

Eine wichtige Entdeckung, die ich machte, war, dass ich kopieren müssen meine member-Variablen in eine temporäre variable, bevor ich auf diese zu reagieren, bei einigen anderen Aufruf an das Objekt versucht zu tauschen, einen neuen Ton vor, ich bin mit dem Aufräumen fertig, die vorherigen. Hier ist ein snippet, dass bedeutet das:

    /** Seek into the audio to the given position in milliseconds. */
    public function seek(position:Number, resumePlay:Boolean) {
        trace("--> Seek(" + position + ") " + name);

        var tempAudioChannel:SoundChannel = audioChannel;
        audioChannel = null;
        if (tempAudioChannel != null) {
            tempAudioChannel.stop();
            tempAudioChannel.removeEventListener(Event.SOUND_COMPLETE, onAudioCompleteHandler);
        }
        audioLastPosition = position;

        if (resumePlay) {
            tempAudioChannel = audio.play(audioLastPosition);
            tempAudioChannel.addEventListener(Event.SOUND_COMPLETE, onAudioCompleteHandler);
            audioChannel = tempAudioChannel;
        }                   
    }

Hinweis, wie ich nicht nur kopieren von audioChannel zu tempAudioChannel, aber ich habe null heraus, audioChannel, bis die Methode ist nahezu abgeschlossen, setzen Sie den Wert anschließend wieder. Ich bin sicher von der Synchronisation Fehler während alle, aber die kurze Zeit zwischen, wenn ich zum testen den Wert von audioChannel und wenn ich damit fertig das kopieren und nulling, die überaus kurz.

Zurück zu meinem Kommentar über die Fabrik und das singleton-Muster. Während der eine Ton wird aufgeräumt - gestoppt und verworfen - der andere kann immer gestartet, also brauche ich mehr als eines wird nun vom Soundmanager. Damit ich Sie erstellen wird nun vom Soundmanager pro audio mit dem Namen. Jedes mal, wenn ich brauche, um zu handeln, auf eine audio-Datei, die wird nun vom Soundmanager Klasse sagt mir die manager-Instanz zu nennen, so dass ich nicht hören will, Duplikate das gleiche Geräusch begann als Ergebnis.

Folgende code ist eine vollständige wird nun vom Soundmanager von meinem aktuellen kommerziellen Projekt. Es verweist auf eine andere Klasse, die nicht gezeigt - Konfiguration, aber diese Klasse behandelt nur immer Pfade zu audio-Dateien aus einer config-Datei, und bekommen Verstärkung von Werten aus einer anderen XML-Datei. (Der AUFTRAGGEBER gelieferten Dateien, die nicht normalisiert wurden, um die gleiche Lautstärke, so hatten wir es zu tun haben.) So würden Sie ändern müssen alle Verweise auf das config-Objekt aus diesem code.

HINWEIS: ich verwende die temporäre variable trick ALLE ÜBER DEM PLATZ, auf mindestens zwei member-Variablen, audio-und audioChannel.

package com.vpg.rns.audio {
    import flash.system.System;
    import flash.events.*;
    import flash.media.Sound;
    import flash.media.SoundChannel;
    import flash.media.SoundTransform;
    import flash.net.NetStream;
    import flash.net.NetConnection;
    import flash.net.URLLoader;
    import flash.net.URLRequest;
    import flash.errors.IOError;



    /** Load a Sound from an MP3 file, then hold onto it and mediate playing and disposing of the object, and keep the several Sounds from interfering with one another. 
     *  This class stores each SoundManager instance in a collection keyed by the step name. 
     *
     *  Do not call the Constructor directly to acquire a SoundManager. Instead, use getInstance.
     */
    public class SoundManager {
        private static var allSounds:Object = new Object();

        public static function getInstance(name:String, config:Configuration) {
            var soundMgr:SoundManager = allSounds[name];
            if (soundMgr == null) {
                soundMgr = new SoundManager(name, config);
                addSoundManager(soundMgr);
            }
            return soundMgr;
        }

        private static function addSoundManager(soundMgr:SoundManager) {
            allSounds[soundMgr.name] = soundMgr;
        }

        private static function removeSoundManager(name) {
            var soundMgr:SoundManager = allSounds[name] as SoundManager;
            allSounds[name] = null;
            if (soundMgr != null) {
                soundMgr.dispose();
            }
        }

        public static function removeAllManagers() {
            var allSoundsTemp:Object = allSounds;
            allSounds = new Object();
            for (var prop:String in allSoundsTemp){
                var soundMgr:SoundManager = allSoundsTemp[prop] as SoundManager;
                if (soundMgr != null) {
                    soundMgr.dispose();
                }
            }
        }

        public static function stopManagers(exceptMgrName:String) {
            for (var prop:String in allSounds){
                var soundMgr:SoundManager = allSounds[prop] as SoundManager;
                if (soundMgr != null && soundMgr.name != exceptMgrName) {
                    soundMgr.stop();
                }
            }
        }

        private var mgrName:String;
        public function get name():String { return mgrName; }

        public var config:Configuration;
        public var audio:Sound;
        public var audioChannel:SoundChannel;
        public var audioLoadStatus:String; //States: no audio, loading, loaded, ready. "loaded" means loaded enough to start playing, but possibly still loading more.

        private var rootPath:String;
        private var dataPath:String;
        private var mediaPath:String;
        public var audioFilename:String;
        private var onLoadHandler:Function; //Called When loading file is complete
        private var onAudioCompleteHandler:Function; //Called When playing audio is complete

        public var duration:Number;
        public var audioLastPosition:Number;

        private var volumeAdjustment:Number;

        /** Construct a SoundManager. Do not call this directy. Use the factory method getInstance instead. */
        function SoundManager(name:String, config:Configuration) {
            mgrName = name;
            this.config = config;
            audioLoadStatus = "no audio";
            duration = 0;
            audioLastPosition = 0;
            volumeAdjustment = 1;
        }

        /*
         * Load the audio, then tigger the loading of the optional cue point xml file, and initialization of the controls.
         *
         * @param rootDirectory ...... Directory containing the config file. 
         * @param dataDirectory ...... Directory where cuepoint data is located. Expect the cuepoints file to be in the xml/cuepoints subdirectory. 
         * @param mediaDirectory ..... Directory where audio files are located. 
         * @param audioFile .......... Name of audio file with extension. Does not include path.
         * @param onLoadHandler ...... Called once the audio is loaded, so the caller can start playing it.
         */
        public function loadAudio(rootDirectory:String, dataDirectory:String, mediaDirectory:String, audioFile:String, onLoadHandler:Function, onAudioCompleteHandler:Function) {
            audioLoadStatus = "loading";
            //Load the audio file.
            this.rootPath = rootDirectory;
            this.dataPath = dataDirectory;
            this.mediaPath = mediaDirectory;
            this.audioFilename = audioFile;
            this.onLoadHandler = onLoadHandler;
            this.onAudioCompleteHandler = onAudioCompleteHandler;
            this.volumeAdjustment = config.getAmplification(this.audioFilename);

            var mySoundReq:URLRequest = new URLRequest(config.osSpecificPath(mediaPath + "/" + audioFilename));

            audio = new Sound();
            audio.addEventListener(IOErrorEvent.IO_ERROR, function(e:IOErrorEvent):void{ trace("SoundLoader.loadAudio ERROR!!!"); trace(e); });
            if (config.platform == "Flash_IDE") {
                audio.addEventListener(Event.COMPLETE, audioReady);
            }
            else {
                //We can't afford to wait for whole audio to load, so wait until some of it is loaded.
                audio.addEventListener(ProgressEvent.PROGRESS, audioProgress1);
                audio.addEventListener(Event.COMPLETE, audioCompletelyLoaded);
            }
            audio.load(mySoundReq);

        }       

        //A sufficient portion of the audio has loaded, so start playing.
        private function audioProgress1(evt:ProgressEvent) {
            var loadPercent:Number = Math.round(100 * evt.bytesLoaded / evt.bytesTotal);
            if (loadPercent > 10 && audioLoadStatus == "loading") { //TODO: Deduce a better threshold.
                var audioTemp:Sound = audio;
                audioTemp.removeEventListener(ProgressEvent.PROGRESS, audioProgress1);
                audioTemp.addEventListener(ProgressEvent.PROGRESS, audioProgress2);
                audioLoaded();
            }
        }       

        //As the audio continues to load, the duration lengthens, affecting the scrubber thumb position.
        private function audioProgress2(evt:ProgressEvent) {
            var loadPercent:Number = Math.round(100 * evt.bytesLoaded / evt.bytesTotal);
            if (audioLoadStatus == "loading" || audioLoadStatus == "loaded") {
                var audioTemp:Sound = audio;
                if (audioTemp != null) {
                    duration = audioTemp.length / 1000; //Convert from milliseconds to seconds.
                }
            }
        }       

        private function audioCompletelyLoaded(evt:Event) {
            var audioTemp:Sound = audio;
            if (audioTemp != null) {
                audioTemp.removeEventListener(Event.COMPLETE, audioCompletelyLoaded);
                audioTemp.removeEventListener(ProgressEvent.PROGRESS, audioProgress1);
                audioTemp.removeEventListener(ProgressEvent.PROGRESS, audioProgress2);
                duration = audioTemp.length / 1000;
            }
        }

        private function audioReady(evt:Event) {
            var audioTemp:Sound = audio;
            if (audioTemp != null) {
                audioTemp.removeEventListener(Event.COMPLETE, audioReady);
                audioLoaded();
            }
        }

        private function audioLoaded() {
            audioLoadStatus = "loaded";

            var audioTemp:Sound = audio;
            if (audioTemp != null) {
                duration = audioTemp.length / 1000; //Convert from milliseconds to seconds.
                var audioChannelTemp:SoundChannel;
                audioChannelTemp = audioTemp.play();
                audioChannelTemp.stop();
                audioChannel = null;
                audioLastPosition = 0;
                audioLoadStatus = "ready";
                onLoadHandler(this);
            }
        }

        public function play() {
            pause();
            trace("--> Play " + name);
            audioChannel = audio.play(audioLastPosition);
            audioChannel.addEventListener(Event.SOUND_COMPLETE, onAudioCompleteHandler);
        }

        /** Seek into the audio to the given position in milliseconds. */
        public function seek(position:Number, resumePlay:Boolean) {
            trace("--> Seek(" + position + ") " + name);

            var tempAudioChannel:SoundChannel = audioChannel;
            audioChannel = null;
            if (tempAudioChannel != null) {
                tempAudioChannel.stop();
                tempAudioChannel.removeEventListener(Event.SOUND_COMPLETE, onAudioCompleteHandler);
            }
            audioLastPosition = position;

            if (resumePlay) {
                tempAudioChannel = audio.play(audioLastPosition);
                tempAudioChannel.addEventListener(Event.SOUND_COMPLETE, onAudioCompleteHandler);
                audioChannel = tempAudioChannel;
            }                   
        }

        public function pause() {
            trace("--> Pause " + name);
            if (audioChannel != null) {
                audioLastPosition = audioChannel.position;
                audioChannel.stop();
                audioChannel.removeEventListener(Event.SOUND_COMPLETE, onAudioCompleteHandler);
                audioChannel = null;
            }
        }

        public function stop() {
            trace("--> Stop " + name);
            audioLastPosition = 0;
            if (audioChannel != null) {
                audioChannel.stop();
                audioChannel.removeEventListener(Event.SOUND_COMPLETE, onAudioCompleteHandler);
                audioChannel = null;
            }
        }       

        /** Elapsed time of audio in seconds. */
        public function get audioElapsed():Number {
            if (audioLoadStatus == "ready") {
                if (audioChannel != null) {
                    return audioChannel.position / 1000.0;
                }
                else {
                    return audioLastPosition / 1000.0;
                }
            }
            else {
                return 0;
            }
        }               

        /** Set the audio volume to a number between zero (mute) and one (loud). */
        public function setVolume(volume:Number, soundTransform:SoundTransform = null) {
            if (audioChannel != null) {
                if (soundTransform == null) {
                    soundTransform = new SoundTransform();
                }
                if (volumeAdjustment != 1.0) {
                    trace("setVolume using volume adjustment of " + volumeAdjustment);
                }
                soundTransform.volume = volume * volumeAdjustment;
                audioChannel.soundTransform = soundTransform;
            }
        }

        public function unloadAudio() {
            dispose();
        }               

        private function dispose() {
            audioLoadStatus = "no audio";
            var audioTemp:Sound = audio;
            audio = null;
            stop();
            if (audioTemp != null) {
                try {
                    audioTemp.close();
                }
                catch (error:IOError) {
                    trace("Error: Couldn't close audio stream: " + error.message);    
                }

            }
        }

    }

}