module.h

Go to the documentation of this file.

/********************************************************************************************
* Twitch Broadcasting SDK
*
* This software is supplied under the terms of a license agreement with Twitch Interactive, Inc. and
* may not be copied or used except in accordance with the terms of that agreement
* Copyright (c) 2012-2016 Twitch Interactive, Inc.
*********************************************************************************************/

#pragma once

#include "twitchsdk/core/coreutilities.h"
#include "twitchsdk/core/types/coretypes.h"
#include "twitchsdk/core/types/errortypes.h"
#include "twitchsdk/core/eventsource.h"

namespace ttv
{
    class IModule;
    class IModuleListener;

    class ModuleBase;
    class ComponentContainer;

    void ShutdownModulesSync(const std::vector<std::shared_ptr<ttv::IModule>>& modules);
}


class ttv::IModule
{
public:
    enum class State
    {
        Uninitialized,
        Initializing,
        Initialized,
        ShuttingDown
    };
    
    using InitializeCallback = std::function<void(TTV_ErrorCode ec)>;
    using ShutdownCallback = std::function<void(TTV_ErrorCode ec)>;

public:
    virtual ~IModule();

    virtual State GetState() const = 0;
    virtual std::string GetModuleName() const = 0;
    virtual TTV_ErrorCode Initialize(const InitializeCallback& callback) = 0;
    virtual TTV_ErrorCode Update() = 0;
    virtual TTV_ErrorCode Shutdown(const ShutdownCallback& callback) = 0;
};


class ttv::ModuleBase : public ttv::IModule
{
public:
    ModuleBase();
    virtual ~ModuleBase();

    // IModule implementation
    virtual State GetState() const override;
    virtual TTV_ErrorCode Initialize(const InitializeCallback& callback) override;
    virtual TTV_ErrorCode Update() override;
    virtual TTV_ErrorCode Shutdown(const ShutdownCallback& callback) override;

protected:
    void NotifyStateChange();
    void RegisterInitializeCallback(const InitializeCallback& callback)
    {
        mInitializeCallbacks.Push(callback);
    }
    
    void RegisterShutdownCallback(const ShutdownCallback& callback)
    {
        mShutdownCallbacks.Push(callback);
    }

    virtual bool CheckShutdown();
    virtual void CompleteShutdown();

    template <typename T>
    void Invoke(std::function<void(std::shared_ptr<T>)> callback)
    {
        mListeners.Invoke([callback](std::shared_ptr<IModuleListener> listener)
        {
            callback(std::static_pointer_cast<T>(listener));
        });
    }

    std::shared_ptr<ComponentContainer> GetComponentContainer() { return mComponentContainer; }

protected:
    EventSource<IModuleListener> mListeners;
    State mState;
    State mLastReportedState;
    
private:
    std::shared_ptr<ComponentContainer> mComponentContainer;
    
    CallbackQueue<InitializeCallback> mInitializeCallbacks;
    CallbackQueue<ShutdownCallback> mShutdownCallbacks;
};


class ttv::IModuleListener
{
public:
    virtual void ModuleStateChanged(IModule* source, IModule::State state, TTV_ErrorCode ec) = 0;
};