CUSoundLoader.h

//
//  CUSoundLoader.h
//  Cornell Extensions to Cocos2D
//
//  This module provides a specific implementation of the Loader class to load
//  sounds. It uses the experimental AudioEngine instead of SimpleAudioEngine.
//  This method requires a few modifications to the Cocos2d platform files to
//  work properly.  As AudioEngine is marked as experimental anyway, we felt
//  this was okay.
//
//  As with all of our loaders, this loader is designed to be attached to a scene.
//  This is the natural was to do things, as Cocos2d is scene based.  However,
//  its asset loading is typically done through the director, which is global.
//  This makes is hard to determine when it is safe to unload an asset.  Even
//  though the current scene many not need it, it may be used by another active
//  scene. Unloading the asset would corrupt that scene.
//
//  This loader solves this problem by have a static coordinator behind the
//  scenes.  This coordinate is shared across all loader instances.  It decides
//  When an asset is truly ready to be unloaded.
//
//  Author: Walker White
//  Version: 12/10/15
//
#ifndef __CU_SOUND_LOADER__
#define __CU_SOUND_LOADER__
#include <unordered_set>
#include "CUSound.h"
#include "CULoader.h"

NS_CC_BEGIN

class CC_DLL SoundLoader : public Loader<Sound> {
private:
    CC_DISALLOW_COPY_AND_ASSIGN(SoundLoader);
    
protected:
#pragma mark -
#pragma mark Sound Coordinator

    class Coordinator {
    private:
        std::unordered_map<std::string,Sound*> _sources;
        std::unordered_map<std::string,int>    _refcnts;
        std::unordered_map<std::string,std::vector<std::function<void(Sound* s)>>> _callbacks;
    public:
        size_t instances;
        
        Coordinator();
        
        ~Coordinator();

        bool isLoaded(std::string source)  const { return _sources.find(source) != _sources.end(); }

        bool isPending(std::string source)  const { return _callbacks.find(source) != _callbacks.end(); }

        
#pragma mark Allocation Methods

        Sound* load(std::string source);
        
        void loadAsync(std::string source, std::function<void(Sound* s)> callback);

        void allocate(std::string source, bool success, bool preload = true);
        
        void release(Sound* sound);
    };
    
    static Coordinator* _gCoordinator;
    
#pragma mark -
#pragma mark Sound Loader

    std::unordered_set<std::string> _squeue;

    void allocate(std::string key, Sound* sound);

    
public:
#pragma mark Activation/Deactivation

    static SoundLoader* create();

    void start() override;
    
    void stop() override;
    
    
#pragma mark Loading/Unloading

    size_t waitCount() const override { return _squeue.size(); }

    Sound* load(std::string key, std::string source) override;
    
    void loadAsync(std::string key, std::string source) override;
    
    void unload(std::string key) override;
    
    void unloadAll() override;

    
CC_CONSTRUCTOR_ACCESS:
#pragma mark Initializers

    SoundLoader() : Loader<Sound>() {}

    virtual ~SoundLoader() { if (_active) { stop(); } }

};

NS_CC_END

#endif /* defined(__CU_SOUND_LOADER__) */