chatchannelset.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/chat/chattypes.h"
#include "twitchsdk/chat/chatlistener.h"
#include "twitchsdk/chat/ichatchannel.h"

#include <string>
#include <vector>
#include <unordered_set>
#include <map>
#include <memory>
#include <atomic>

namespace ttv
{
    class TaskRunner;
    class User;
    class SettingRepository;
    class ChannelRepository;

    namespace chat
    {
        class ChatChannel;
        class IChatObjectFactory;
        class ChatChannelSet;
        class ChatChannelWrapper;
        class BitsConfigRepository;
    }
}


class ttv::chat::ChatChannelSet : public ttv::UserComponent
{
public:
    using FetchUserListCallback = std::function<void(TTV_ErrorCode ec, UserList&& userList)>;
    using SetBroadcasterLanguageChatCallback = std::function<void(TTV_ErrorCode ec)>;
    
    ChatChannelSet(const std::shared_ptr<User>& user);
    virtual ~ChatChannelSet() override;

    void SetTokenizationOptions(const TokenizationOptions& tokenizationOptions) { mTokenizationOptions = tokenizationOptions; }
    void SetChatObjectFactory(std::shared_ptr<IChatObjectFactory> factory) { mChatObjectFactory = factory; }
    void SetSettingRepository(std::shared_ptr<SettingRepository> settings) { mSettingRepository = settings; }
    void SetChannelRepository(const std::shared_ptr<ChannelRepository>& channelRepository) { mChannelRepository = channelRepository; }
    void SetBitsConfigRepository(std::shared_ptr<BitsConfigRepository> repository) { mBitsConfigRepository = repository; }

    virtual void Update() override;
    virtual TTV_ErrorCode Shutdown() override;

    TTV_ErrorCode Connect(ChannelId channelId, const std::shared_ptr<IChatChannelListener>& listener);
    TTV_ErrorCode Disconnect(ChannelId channelId);
    TTV_ErrorCode SendChatMessage(ChannelId channelId, const std::string& message);
    TTV_ErrorCode FetchUserList(ChannelId channelId, const FetchUserListCallback& callback);

    TTV_ErrorCode SetBroadcasterLanguageChatEnabled(ChannelId channelId, bool enabled, const SetBroadcasterLanguageChatCallback& callback);
    TTV_ErrorCode OptInToBroadcasterLanguageChat(ChannelId channelId, const std::string& language);
    TTV_ErrorCode SetLocalLanguage(const std::string& language);

    void SetMessageFlushInterval(uint64_t milliseconds);
    uint64_t GetMessageFlushInterval() const { return mUserMessageFlushInterval; }
    
    virtual std::string GetLoggerName() const override;
    static std::string GetComponentName() { return "ttv::chat::ChatChannelSet"; }

protected:
    virtual bool CheckShutdown() override;
    virtual void CompleteShutdown() override;

private:
    struct ChannelEntry
    {
        std::shared_ptr<ChatChannel> channel;
        std::shared_ptr<IChatChannelListener> channelListener;
    };

    class InternalChannelListener : public IChatChannelListener
    {
    public:
        InternalChannelListener(ChatChannelSet* owner);

        // IChatChannelListener implementation
        virtual void ChatChannelStateChanged(UserId userId, ChannelId channelId, ChatChannelState state, TTV_ErrorCode ec) override;
        virtual void ChatChannelInfoChanged(UserId userId, ChannelId channelId, const ChatChannelInfo& channelInfo) override;
        virtual void ChatChannelRestrictionsChanged(UserId userId, ChannelId channelId, const ChatChannelRestrictions& restrictions) override;
        virtual void ChatChannelLocalUserChanged(UserId userId, ChannelId channelId, const ChatUserInfo& userInfo) override;
        virtual void ChatChannelMessagesReceived(UserId userId, ChannelId channelId, const std::vector<LiveChatMessage>& messageList) override;
        virtual void ChatChannelSubscriptionNoticeReceived(UserId userId, ChannelId channelId, const SubscriptionNotice& notice) override;
        virtual void ChatChannelFirstTimeChatterNoticeReceived(UserId userId, ChannelId channelId, const FirstTimeChatterNotice& notice) override;
        virtual void ChatChannelRaidNoticeReceived(UserId userId, ChannelId channelId, const RaidNotice& notice) override;
        virtual void ChatChannelUnraidNoticeReceived(UserId userId, ChannelId channelId, const UnraidNotice& notice) override;
        virtual void ChatChannelMessagesCleared(UserId userId, ChannelId channelId) override;
        virtual void ChatChannelUserMessagesCleared(UserId userId, ChannelId channelId, UserId clearUserId) override;
        virtual void ChatChannelHostTargetChanged(UserId userId, ChannelId channelId, const std::string& targetChannelName, uint32_t numViewers) override;
        virtual void ChatChannelNoticeReceived(UserId userId, ChannelId channelId,  const std::string& id, const std::map<std::string, std::string>& params) override;

    private:
        ChatChannelSet* mOwner;
    };

    // Private IChatChannelListener implementation
    void ChatChannelStateChanged(UserId userId, ChannelId channelId, ChatChannelState state, TTV_ErrorCode ec);
    void ChatChannelInfoChanged(UserId userId, ChannelId channelId, const ChatChannelInfo& channelInfo);
    void ChatChannelRestrictionsChanged(UserId userId, ChannelId channelId, const ChatChannelRestrictions& restrictions);
    void ChatChannelLocalUserChanged(UserId userId, ChannelId channelId, const ChatUserInfo& userInfo);
    void ChatChannelMessagesReceived(UserId userId, ChannelId channelId, const std::vector<LiveChatMessage>& messageList);
    void ChatChannelSubscriptionNoticeReceived(UserId userId, ChannelId channelId, const SubscriptionNotice& notice);
    void ChatChannelFirstTimeChatterNoticeReceived(UserId userId, ChannelId channelId, const FirstTimeChatterNotice& notice);
    void ChatChannelRaidNoticeReceived(UserId userId, ChannelId channelId, const RaidNotice& notice);
    void ChatChannelUnraidNoticeReceived(UserId userId, ChannelId channelId, const UnraidNotice& notice);
    void ChatChannelMessagesCleared(UserId userId, ChannelId channelId);
    void ChatChannelUserMessagesCleared(UserId userId, ChannelId channelId, UserId clearUserId);
    void ChatChannelHostTargetChanged(UserId userId, ChannelId channelId, const std::string& targetChannelName, uint32_t numViewers);
    void ChatChannelNoticeReceived(UserId userId, ChannelId channelId, const std::string& id, const std::map<std::string, std::string>& params);

    TTV_ErrorCode LookupChannel(ChannelId channelId, std::shared_ptr<ChatChannel>& channel);
    TTV_ErrorCode FlushChannelEvents();
    std::shared_ptr<ChannelEntry> CreateChannel(ChannelId channelId);
    
    std::shared_ptr<IChatObjectFactory> mChatObjectFactory; 
    std::shared_ptr<IChatChannelListener> mInternalChannelListener; 
    std::shared_ptr<SettingRepository> mSettingRepository;
    std::shared_ptr<ChannelRepository> mChannelRepository;
    std::shared_ptr<BitsConfigRepository> mBitsConfigRepository;
    std::map<ChannelId, std::shared_ptr<ChannelEntry>> mChannels; 
    std::vector<std::shared_ptr<ChannelEntry>> mCleanupChannels; 
    
    std::string mLocalLanguage; 
    
    TokenizationOptions mTokenizationOptions;

    uint64_t mUserMessageFlushInterval; 
};


class ttv::chat::ChatChannelWrapper : public IChatChannel
{
public:
    using DisposerFunc = std::function<void()>;

public:
    ChatChannelWrapper(const std::shared_ptr<User>& user, ChannelId channelId, const std::shared_ptr<IChatChannelListener>& listener);
    virtual ~ChatChannelWrapper();

    void SetDisposer(DisposerFunc&& func) { mDisposerFunc = func; }
    std::shared_ptr<ChatChannelSet> GetChatChannelSet() const { return mChatChannelSet; }

    // IChatChannel implementation
    virtual TTV_ErrorCode Dispose() override;
    virtual TTV_ErrorCode Connect() override;
    virtual TTV_ErrorCode Disconnect() override;
    virtual TTV_ErrorCode SendMessage(const std::string& message) override;
    virtual TTV_ErrorCode SetBroadcasterLanguageChatEnabled(bool enabled, const SetBroadcasterLanguageChatEnabledCallback& callback) override;
    virtual TTV_ErrorCode OptInToBroadcasterLanguageChat(const std::string& language) override;

private:
    DisposerFunc mDisposerFunc;
    std::shared_ptr<ChatChannelSet> mChatChannelSet;
    std::shared_ptr<IChatChannelListener> mChatChannelListener;
    ChannelId mChannelId;
};