chatchannel.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/types/coretypes.h"
#include "twitchsdk/core/types/errortypes.h"
#include "twitchsdk/core/user/user.h"
#include "twitchsdk/core/concurrentqueue.h"
#include "twitchsdk/core/channel/channelrepository.h"

#include "twitchsdk/chat/chatlistener.h"
#include "twitchsdk/chat/internal/bitsconfigrepository.h"
#include "twitchsdk/chat/internal/chatconnection.h"
#include "twitchsdk/chat/internal/chathelpers.h"
#include "twitchsdk/chat/internal/task/chatpropertiestask.h"


namespace ttv
{
    class IThread;
    class User;
    class SettingRepository;

    namespace chat
    {
        class ChatAPI;
        class ChatChannel;
        class ChatSession;
        class IChatTransport;
        class ChatUserBlockList;
        class BitsConfigRepository;
    }
}


class ttv::chat::ChatChannel : public ChatConnection::Listener
{
private:
    struct State
    {
        enum Enum
        {
            Initialized,
            Connecting,
            Connected,
            ShuttingDown,
            ShutDown,
        };
    };

public:
    using FetchUserListCallback = std::function<void(TTV_ErrorCode ec, UserList&& userList)>;
    using SetBroadcasterLanguageChatCallback = std::function<void(TTV_ErrorCode ec)>;
    using LookupId = uint64_t;
    
    ChatChannel(const std::shared_ptr<User>& user, ChannelId channelId, std::shared_ptr<IChatChannelListener> chatCallbacks, std::shared_ptr<TaskRunner> taskRunner);
    virtual ~ChatChannel();

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

    TTV_ErrorCode Connect();
    TTV_ErrorCode Disconnect();
    TTV_ErrorCode FlushClientEvents();
    bool IsShutdown() const { return mChatThread == nullptr; }
    TTV_ErrorCode SendChatMessage(const std::string& message);

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

    inline UserId GetChannelId() const { return mChannelId; }

    void SetMessageFlushInterval(uint64_t milliseconds) { mUserMessageFlushInterval = milliseconds; }
    uint64_t GetMessageFlushInterval() const { return mUserMessageFlushInterval; }

    ChatChannelState GetState() const { return mReportedClientState; }

    std::shared_ptr<IChatChannelListener> GetChannelListener() { return mChatCallbacks; }
    std::shared_ptr<User> GetUser() { return mUser.lock(); }

    // ChatConnection::Listener implementation
    virtual void OnConnected(ChatConnection* source) override;
    virtual void OnConnectionFailed(ChatConnection* source, TTV_ErrorCode ec) override;
    virtual void OnConnectionLost(ChatConnection* source, TTV_ErrorCode ec) override;
    virtual void OnCleared(ChatConnection* source, const std::string& username, const std::map<std::string, std::string>& messageTags) override;
    virtual void OnPrivateMessageReceived(ChatConnection* source, const std::string& username, const std::string& message, const std::map<std::string, std::string>& messageTags, bool action) override;
    virtual void OnUserNoticeReceived(ChatConnection* source, const std::string& message, const std::map<std::string, std::string>& messageTags) override;
    virtual void OnUserStateChanged(ChatConnection *source, const std::map<std::string, std::string>& messageTags) override;
    virtual void OnChatRestrictionsChanged(ChatConnection* source, const ChatChannelRestrictions& restrictions) override;
    virtual void OnPermanentBanChanged(ChatConnection* source, bool banned) override;
    virtual void OnTemporaryBanChanged(ChatConnection* source, bool temporarilyBanned, uint32_t timeout) override;
    virtual void OnBadgesChanged(ChatConnection* source, const std::string& username, const std::string& badgesMessageTag) override;
    virtual void OnHostTargetChanged(ChatConnection* source, const std::string& targetChannel, uint32_t numViewers) override;
    virtual void OnNoticeReceived(ChatConnection* source, const std::string& id, const std::map<std::string, std::string>& params) override;
    virtual void OnIgnoreChanged(ChatConnection* source, const std::string& blockUserName, bool ignore) override;

private:
    void FlushUserMessages(bool force);

    void ForceShutdown();
    TTV_ErrorCode ProcessClientRequestQueue();
    TTV_ErrorCode ProcessClientChatMessage(const std::string& msg);
    TTV_ErrorCode FetchChannelInfo();
    TTV_ErrorCode FetchChatProperties();
    TTV_ErrorCode FetchBitsConfiguration();
    TTV_ErrorCode ProcessDisconnectRequest();
    TTV_ErrorCode ProcessOptInToBroadcasterLanguageChatRequest(const std::string& language);
    TTV_ErrorCode ProcessSetLocalLanguageRequest(const std::string& language);
    TTV_ErrorCode ProcessChannelInfoFetchResult(const ChannelInfo& channelInfo);
    TTV_ErrorCode ProcessChatPropertyFetchResult(TTV_ErrorCode ec, std::shared_ptr<ChatPropertiesTask::Result> result);
    TTV_ErrorCode ProcessBitsConfigFetchResult(TTV_ErrorCode ec, const std::shared_ptr<BitsConfiguration>& config);
    void SetClientChannelInfo(const ChatChannelInfo& channelInfo);
    void SetClientChatRestrictions(const ChatChannelRestrictions& restrictions);
    
    void HandleMessageReceived(const std::string& username, const std::string& message, const std::map<std::string, std::string>& messageTags, const MessageInfo::Flags& flags);
    void HandleUserNotice(const std::string& message, const std::map<std::string, std::string>& messageTags);
    void HandleSubscriptionNotice(SubscriptionNotice::Type type, const std::string& message, const std::map<std::string, std::string>& messageTags);
    void HandleFirstTimeChatterNotice(const std::string& message, const std::map<std::string, std::string>& messageTags);
    void HandleRaidNotice(const std::string& message, const std::map<std::string, std::string>& messageTags);
    void HandleUnraidNotice(const std::string& message, const std::map<std::string, std::string>& messageTags);
    void GenerateUserInfo(const std::string& username, const std::map<std::string, std::string>& messageTags, ChatUserInfo& userInfo);
    void GenerateMessage(MessageInfo& msg, const TokenizationOptions& tokenizationOptions, const ChatUserInfo& userInfo, const std::string& message, const std::map<std::string, std::string>& messageTags, const MessageInfo::Flags& flags);
    void GenerateLiveMessage(LiveChatMessage& msg, const TokenizationOptions& tokenizationOptions, const ChatUserInfo& userInfo, const std::string& message, const std::map<std::string, std::string>& messageTags, const MessageInfo::Flags& flags);

    void ThreadProc();
    void CompleteShutdown();
    bool UpdateRestriction();
    void UpdateBroadcasterLanguageChatState();
    TTV_ErrorCode AttemptConnection();
    void CloseConnection();

    void SetState(State::Enum state);
    void HandleConnectionIssue(bool recoverableError);

    std::string mBroadcasterName;

    std::shared_ptr<IChatChannelListener> mChatCallbacks; 
    std::shared_ptr<ChatPropertiesTask::Result> mChatProperties; 
    std::vector<std::string> mHosts; 
    
    std::shared_ptr<IChatObjectFactory> mChatObjectFactory; 
    std::shared_ptr<IThread> mChatThread; 
    std::shared_ptr<ChatConnection> mChatConnection; 
    std::shared_ptr<ChannelRepository> mChannelRepository;
    std::shared_ptr<SettingRepository> mSettingRepository;
    std::shared_ptr<BitsConfigRepository> mBitsConfigRepository;
    std::shared_ptr<TaskRunner> mTaskRunner;
    std::shared_ptr<TaskRunner> mBackgroundTaskRunner;

    WaitForExpiry mFetchChatPropertiesTimer; 
    WaitForExpiry mFetchBitsConfigTimer; 
    RetryTimer mConnectionRetryTimer; 
    int mNextChatHostIndex; 
    
    using ThreadEvent = std::function<void()>;
    ConcurrentQueue<ThreadEvent>    mToMainQ; 
    ConcurrentQueue<ThreadEvent>    mToChatQ; 

    std::vector<LiveChatMessage> mUserMessageBatch; 

    uint64_t mUserMessageFlushInterval; 
    WaitForExpiry mNextUserMessageFlush; 
    ChatMessagePacer mMessagePacer; 
    WaitForExpiry mSlowModeTimer; 
    WaitForExpiry mTimeoutTimer; 
    
    TTV_ErrorCode mConnectionError;

    State::Enum mChannelState; 
    ChatChannelState mReportedClientState; 

    ChatUserInfo mSystemUserInfo;                       
    ChatUserInfo mClientLocalUserInfo;                  
    ChatUserInfo mServerLocalUserInfo;                  
    ChatChannelInfo mClientChannelInfo;                 
    ChatChannelInfo mServerChannelInfo;                 
    ChatChannelRestrictions mClientChatRestrictions;    
    ChatChannelRestrictions mServerChatRestrictions;    

    std::weak_ptr<User> mUser; 
    std::vector< std::string > mQueuedChatMessages; // The list of messages that were sent from the client to the chat thread while a reconnect was pending.
    std::shared_ptr<BitsConfiguration> mBitsConfiguration;

    std::string mLocalLanguage; 
    
    TokenizationOptions mTokenizationOptions; 
    LookupId mBitsConfigFetchToken; 
    ChannelId mChannelId; 

    std::atomic<uint32_t> mNumOutstandingTasks;

    bool mApplySlowMode;
    bool mAnonymous; 
    bool mDisconnectionRequested; 
    bool mBroadcasterLanguageMatch; 
    bool mBroadcasterLanguageOptedIn; 
};