chatconnection.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/chat/internal/chatnetworkevent.h"
#include "twitchsdk/chat/internal/chathelpers.h"

namespace ttv
{
    class User;

    namespace chat
    {
        class ChatConnection;
        class ChatConnectionListenerProxy;

        class ChatAPI;
        class ChatChannel;
        class ChatSession;
        class ChatReader;
        class ChatWriter;
        class IChatTransport;
        class IChatObjectFactory;
    }
}


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

private:
    enum ConnectionState
    {
        CONNECTIONSTATE_DISCONNECTED,
        CONNECTIONSTATE_CONNECTING,
        CONNECTIONSTATE_WELCOMING,
        CONNECTIONSTATE_WELCOMED,
        CONNECTIONSTATE_JOINING,
        CONNECTIONSTATE_CONNECTED,
        CONNECTIONSTATE_CONNECTION_FAILED,
        CONNECTIONSTATE_CONNECTION_LOST,
    };

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

    void SetListener(Listener* listener) { mListener = listener; }
    void SetChatObjectFactory(std::shared_ptr<IChatObjectFactory> factory);
    void SetChannelName(const std::string& channelName);

    TTV_ErrorCode Connect(const std::string& uri);
    TTV_ErrorCode Disconnect();
    TTV_ErrorCode SendChatMessage(const std::string& message, const ChatUserInfo& localUserInfo);

    TTV_ErrorCode Update();

    std::string GetLocalUserName() const { return mUserName; }

    // IChatReceiveNetworkEvent implementation
    virtual void ReceiveEvent(const ChatNetworkEvent& evt);

    static TTV_ErrorCode CheckFactoryAvailability(const std::string& uri);

private:
    void SetState(ConnectionState state);
    
    void Join();

    void HandleCapMessage(const ChatNetworkEvent& evt);
    void HandlePrivateMessage(const ChatNetworkEvent& evt);
    void HandleUserState(const ChatNetworkEvent& evt);
    void HandleNotice(const ChatNetworkEvent& evt);
    void HandleClearChatMessage(const ChatNetworkEvent& evt);
    void HandleHostTargetMessage(const ChatNetworkEvent& evt);
    void HandleUserNotice(const ChatNetworkEvent& evt);
    
    void HandleMessageTags(const ChatNetworkEvent& evt);
    void HandleRoomState(const ChatNetworkEvent& evt);

    void CreateObjects();
    void ReleaseObjects();

    std::string CreateAnonymousUserName();

    std::shared_ptr<ChatReader> mReader; 
    std::shared_ptr<ChatWriter> mWriter; 
    std::shared_ptr<ChatSession> mSession; 
    std::shared_ptr<IChatObjectFactory> mChatObjectFactory; 

    std::shared_ptr<IChatTransport> mTransport; 

    WaitForEventWithTimeout mWelcomeMessageTimeout;
    WaitForEventWithTimeout mJoinAttemptTimeout;

    std::string mIrcChannelName;
    std::string mUserName; 

    ConnectionState mConnectionState;
    Listener* mListener;
    TTV_ErrorCode mConnectionError;

    std::shared_ptr<User> mUser;

    ChannelId mChannelId;
    ChatChannelRestrictions mChatRestrictions;                      

    bool mAnonymous; 
    bool mDisconnectionRequested; 
    bool mFireConnectionErrorEvents; 
};


class ttv::chat::ChatConnectionListenerProxy : public ChatConnection::Listener
{
public:
    typedef std::function<void(ChatConnection* source)> OnConnectedFunc;
    typedef std::function<void(ChatConnection* source, TTV_ErrorCode ec)> OnConnectionFailedFunc;
    typedef std::function<void(ChatConnection* source, TTV_ErrorCode ec)> OnConnectionLostFunc;
    typedef std::function<void(ChatConnection* source, const std::string& username, const std::map<std::string, std::string>& messageTags)> OnClearedFunc;
    typedef std::function<void(ChatConnection* source, const std::string& username, const std::string& message, const std::map<std::string, std::string>& messageTags, bool action)> OnPrivateMessageReceivedFunc;
    typedef std::function<void(ChatConnection* source, const std::string& message, const std::map<std::string, std::string>& messageTags)> OnUserNoticeReceivedFunc;
    typedef std::function<void(ChatConnection* source, const std::map<std::string, std::string>& messageTags)> OnUserStateChangedFunc;
    typedef std::function<void(ChatConnection* source, const std::string& username, const std::string& message, const std::map<std::string, std::string>& messageTags, bool action)> OnWhisperReceivedFunc;
    typedef std::function<void(ChatConnection* source, const std::string& receivingUserName, const std::string& message, const std::map<std::string, std::string>& messageTags, bool action)> OnWhisperSentFunc;
    typedef std::function<void(ChatConnection* source, ChatChannelRestrictions)> OnChatRestrictionsChangedFunc;
    typedef std::function<void(ChatConnection* source, bool banned)> OnPermanentBanChangedFunc;
    typedef std::function<void(ChatConnection* source, bool temporarilyBanned, uint32_t timeout)> OnTemporaryBanChangedFunc;
    typedef std::function<void(ChatConnection* source, const std::string& username, const std::vector<EmoticonSetId>& emoticonSets)> OnEmoticonSetsChangedFunc;
    typedef std::function<void(ChatConnection* source, const std::string& username, const std::string& badgesMessageTag)> OnBadgesChangedFunc;
    typedef std::function<void(ChatConnection* source, const std::string& targetChannel, uint32_t numViewers)> OnHostTargetChangedFunc;
    typedef std::function<void(ChatConnection* source, const std::string& id, const std::map<std::string, std::string>& params)> OnNoticeReceivedFunc;
    typedef std::function<void(ChatConnection* source, const std::string& blockUserName, bool ignore)> OnIgnoreChangedFunc;

public:
    virtual void OnConnected(ChatConnection* source) override
    {
        if (mOnConnectedFunc != nullptr)
        {
            mOnConnectedFunc(source);
        }
    }

    virtual void OnConnectionFailed(ChatConnection* source, TTV_ErrorCode ec) override
    {
        if (mOnConnectionFailedFunc != nullptr)
        {
            mOnConnectionFailedFunc(source, ec);
        }
    }

    virtual void OnConnectionLost(ChatConnection* source, TTV_ErrorCode ec) override
    {
        if (mOnConnectionLostFunc != nullptr)
        {
            mOnConnectionLostFunc(source, ec);
        }
    }

    virtual void OnCleared(ChatConnection* source, const std::string& username, const std::map<std::string, std::string>& messageTags) override
    {
        if (mOnClearedFunc != nullptr)
        {
            mOnClearedFunc(source, username, messageTags);
        }
    }

    virtual void OnPrivateMessageReceived(ChatConnection* source, const std::string& username, const std::string& message, const std::map<std::string, std::string>& messageTags, bool action) override
    {
        if (mOnPrivateMessageReceivedFunc != nullptr)
        {
            mOnPrivateMessageReceivedFunc(source, username, message, messageTags, action);
        }
    }
    
    virtual void OnUserNoticeReceived(ChatConnection* source, const std::string& message, const std::map<std::string, std::string>& messageTags) override
    {
        if (mOnUserNoticeReceivedFunc != nullptr)
        {
            mOnUserNoticeReceivedFunc(source, message, messageTags);
        }
    }
    
    virtual void OnUserStateChanged(ChatConnection* source, const std::map<std::string, std::string>& messageTags) override
    {
        if (mOnUserStateChangedFunc != nullptr)
        {
            mOnUserStateChangedFunc(source, messageTags);
        }
    }

    virtual void OnChatRestrictionsChanged(ChatConnection* source, const ChatChannelRestrictions& restrictions) override
    {
        if (mOnChatRestrictionsChangedFunc != nullptr)
        {
            mOnChatRestrictionsChangedFunc(source, restrictions);
        }
    }

    virtual void OnPermanentBanChanged(ChatConnection* source, bool banned) override
    {
        if (mOnPermanentBanChangedFunc != nullptr)
        {
            mOnPermanentBanChangedFunc(source, banned);
        }
    }

    virtual void OnTemporaryBanChanged(ChatConnection* source, bool temporarilyBanned, uint32_t timeout) override
    {
        if (mOnTemporaryBanChangedFunc != nullptr)
        {
            mOnTemporaryBanChangedFunc(source, temporarilyBanned, timeout);
        }
    }

    virtual void OnBadgesChanged(ChatConnection* source, const std::string& username, const std::string& badgesMessageTag) override
    {
        if (mOnBadgesChangedFunc != nullptr)
        {
            mOnBadgesChangedFunc(source, username, badgesMessageTag);
        }
    }

    virtual void OnHostTargetChanged(ChatConnection* source, const std::string& targetChannel, uint32_t numViewers) override
    {
        if (mOnHostTargetChangedFunc != nullptr)
        {
            mOnHostTargetChangedFunc(source, targetChannel, numViewers);
        }
    }

    virtual void OnNoticeReceived(ChatConnection* source, const std::string& id, const std::map<std::string, std::string>& params) override
    {
        if (mOnNoticeReceivedFunc != nullptr)
        {
            mOnNoticeReceivedFunc(source, id, params);
        }
    }

    virtual void OnIgnoreChanged(ChatConnection* source, const std::string& blockUserName, bool ignore) override
    {
        if (mOnIgnoreChangedFunc != nullptr)
        {
            mOnIgnoreChangedFunc(source, blockUserName, ignore);
        }
    }

public:
    OnConnectedFunc mOnConnectedFunc;
    OnConnectionFailedFunc mOnConnectionFailedFunc;
    OnConnectionLostFunc mOnConnectionLostFunc;
    OnClearedFunc mOnClearedFunc;
    OnPrivateMessageReceivedFunc mOnPrivateMessageReceivedFunc;
    OnUserNoticeReceivedFunc mOnUserNoticeReceivedFunc;
    OnUserStateChangedFunc mOnUserStateChangedFunc;
    OnWhisperReceivedFunc mOnWhisperReceivedFunc;
    OnWhisperSentFunc mOnWhisperSentFunc;
    OnChatRestrictionsChangedFunc mOnChatRestrictionsChangedFunc;
    OnPermanentBanChangedFunc mOnPermanentBanChangedFunc;
    OnTemporaryBanChangedFunc mOnTemporaryBanChangedFunc;
    OnBadgesChangedFunc mOnBadgesChangedFunc;
    OnHostTargetChangedFunc mOnHostTargetChangedFunc;
    OnNoticeReceivedFunc mOnNoticeReceivedFunc;
    OnIgnoreChangedFunc mOnIgnoreChangedFunc;
};