Embed vs Dynamically Loading sounds - actionscript-3

Question

Just wondering if anyone could help me with this. I'm new to actionscript, and am building an application that plays some sounds when buttons are clicked.
It's got 5 tabs, and will give the user the options to play about 10 sounds per tab.
I have initially been loading the sounds on runtime, so whenever the user clicked a button to play that sound, I would do something like:
var sound:Sound = new Sound(new URLRequest("assets/hello.mp3"));
sound.play();
I'm not sure, but I don't think this is very good, since I would be loading that sound over and over again if the user pressed the button too many times.
I then thought about embedding the sound in each of the views (I have one view per tab), so would embed the sounds whenever the view was loaded. I think this is a better options, but still am a bit unsure about how the embed works exactly.
[Embed('assets/hello.mp3')] private var hello_mp3:Class;
I suppose it simply embeds the mp3 files when the swf is compiled (making it bigger), but they would not be loaded anymore once the app starts, or once that view is initialized again.
My question is: Is this the right approach to take? Is there any better way I can accomplish this? Is embedding the right solution for my problem?
Thanks in advance

Answer 1

The first solution works fine, it won't make your SWf bigger and once the sound has been loaded once, it will be cached by Flash Player, so the sound is not loaded again and again.
This is a more efficient approach, sounds that are not played will not be loaded.
Bear in mind that when the button is pressed for the first time , you may experience a slight delay due to the sound being loaded.
In order to avoid this, you can load some sounds as external assets, meaning that after your SWF has loaded, you can call a function that will load some or all of the sounds, depending on the needs of the app. Your SWF will not be bloated and the button click will be more responsive.

Answer 2

Sounds like you need a SoundManager class, or something similar, that caches the sounds you need so that you can play them whenever you want and they only ever get loaded once. Classes like these, where you only ever need one instance of the class, are good candidates to be singletons. There are lots of ways to implement singleton design. In actionscript, my favorite way is like this:
//in SoundManager.as
public static var instance:SoundManager = new SoundManager();
Simple, and it works. Since the plan is that you'll only ever need one SoundManager, you can now get that one instance anywhere else in your code like this:
var soundManager:SoundManager = SoundManager.instance;
//or, more likely you can just use it in-line like this
SoundManager.instance.myMethod();
So now you've got your SoundManager. Let's set it up to keep a cache of sounds so that they only ever get loaded once:
// in SoundManager.as
private var _soundCache:Array = [];
public function getSound(soundName:String):Sound {
var testSound:Sound = _soundCache[soundName] as Sound;
if(!testSound) { //if the sound isn't loaded yet, testSound will be null
//the sound isn't there, so lets load it
var newSound:Sound = new Sound(new URLRequest(soundName));
_soundCache[soundName] = newSound;
return newSound;
}
//if we made it this far it means the sound was in the cache, so we return it
return testSound;
}
And presto, you only ever have to load the sound once! When you want to get a sound, it's as easy as:
var mySound:Sound = SoundManager.instance.getSound("mySound.mp3");
Let me know if you run into trouble with any of this code, but hopefully that's enough to get you on the right track.

Answer 3

In my opinion you should load all the sounds at the beggining and store references to each sound in a place you can access at anytime. A simple example would be storing each sound in an array. I've created a similar yet more robust application of this example:
sounds.xml
<?xml version="1.0" encoding="utf-8" ?>
<sounds>
<sound name="sound1" url="sound/sound1.mp3" />
<sound name="sound2" url="sound/sound2.mp3" />
<sound name="sound3" url="sound/sound3.mp3" />
<sound name="sound4" url="sound/sound4.mp3" />
<sound name="sound5" url="sound/sound5.mp3" />
</sounds>
Main.as(document class):
package
{
import flash.display.Sprite;
import flash.events.Event;
import flash.media.SoundChannel;
import flash.net.URLLoader;
import flash.net.URLRequest;
public class Main extends Sprite
{
private var _soundLibrary:SoundLibrary;
public function Main():void
{
if (stage) init() else addEventListener(Event.ADDED_TO_STAGE, init);
}// end function
private function init(e:Event = null):void
{
removeEventListener(Event.ADDED_TO_STAGE, init);
var urlLoader:URLLoader = new URLLoader(new URLRequest("xml/sounds.xml"));
urlLoader.addEventListener(Event.COMPLETE, onUrlLoaderComplete);
}// end function
private function onUrlLoaderComplete(e:Event):void
{
_soundLibrary = new SoundLibrary(XML(URLLoader(e.target).data));
_soundLibrary.addEventListener(Event.COMPLETE, onSoundLibraryComplete);
}// end function
private function onSoundLibraryComplete(e:Event):void
{
var soundChannel:SoundChannel = _soundLibrary.getSound("sound3").play();
}// end function
}// end class
}// end package
import flash.events.Event;
import flash.events.EventDispatcher;
import flash.media.Sound;
import flash.net.URLRequest;
internal class SoundLibrary extends EventDispatcher
{
private var _xml:XML;
private var _length:int;
private var _counter:int;
private var _soundLibraryItems:Vector.<SoundLibraryItem>;
public function SoundLibrary(xml:XML):void
{
_xml = xml;
_length = _xml.children().length();
_soundLibraryItems = new Vector.<SoundLibraryItem>();
loadSounds();
}// end function
public function getSound(name:String):Sound
{
var sound:Sound;
for (var i:int = 0; i < _soundLibraryItems.length; i++)
{
if (_soundLibraryItems[i].name == name)
sound = _soundLibraryItems[i].sound;
}// end for
if (!sound) throw new ArgumentError("No sound object matches specified name");
return sound;
}// end function
private function loadSounds():void
{
for (var i:int = 0; i < _length; i++)
{
var sound:Sound = new Sound(new URLRequest(_xml.children()[i].#url));
sound.addEventListener(Event.COMPLETE, onSoundComplete);
}// end for
}// end function
private function onSoundComplete(e:Event):void
{
_soundLibraryItems.push(new SoundLibraryItem(_xml.children()[_counter].#name, Sound(e.target)));
if (++_counter == _length) dispatchEvent(new Event(Event.COMPLETE));
}// end function
}// end class
internal class SoundLibraryItem
{
private var _name:String;
private var _sound:Sound;
public function get name():String { return _name }
public function get sound():Sound { return _sound }
public function SoundLibraryItem(name:String, sound:Sound)
{
_name = name; _sound = sound;
}// end function
}// class
[UPDATE]
Summary
First the the sounds.xml is loaded and then on its completion it is parsed to the new instance of SoundLibrary.
SoundLibrary handles loading the sounds from the xml and then parses each loaded Sound object to a new instance of SoundLibraryItem.
SoundLibraryItem simply stores the name of the Sound object as well as the Sound object itself. When all the SoundLibraryItem objects are created the SoundLibrary object dispatches an Event object with an Event.COMPLETE type.
When the event is dispatched the event listener on the SoundLibrary object calls the onSoundLibraryComplete() event handler.
Finally the SoundLibrary object's getSound() method is used to get one of the previously loaded Sound objects via the name argument. Then with a SoundChannel object the Sound object's play() method is called.

Answer 4

In my opinion
Embed things is never an approuch
Pros:
You have anything in the same file = 1 load (
well, this is not really a Pro... )
Cons:
It takes longer to load the whole
application ( users don't like to
wait )
If you want to change the sound you must compile everything again
Scalability benefits
I'm sure people can help me with a lot more Cons ;)
Hope it helps