chatlistener.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/module.h"
#include "twitchsdk/chat/chattypes.h"
#include <string>
#include <memory>
#include <map>

namespace ttv
{
    namespace chat
    {
        class IChatChannelListener;
        class IChatAPIListener;
        class IChatUserThreadsListener;
        class IChatReplayListener;

        struct ChatChannelListenerProxy;
    }
}


class ttv::chat::IChatAPIListener : public ttv::IModuleListener
{
public:
    virtual void ChatUserEmoticonSetsChanged(UserId userId, const std::vector<EmoticonSet>& emoticonSets) = 0;
};

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

class ttv::chat::IChatUserThreadsListener
{
public:
    virtual void ChatThreadRealtimeMessageReceived(UserId userId, const std::string& threadId, const WhisperMessage& messageList) = 0;
    virtual void ChatThreadParticipantsUpdated(UserId userId, const std::string& threadId, const std::vector<ChatUserInfo>& participants) = 0;
    virtual void ChatThreadUnreadMessageWindowChanged(UserId userId, const std::string& threadId, MessageId lastMessageId, MessageId lastReadMessageId) = 0;
    virtual void ChatThreadMutedStatusChanged(UserId userId, const std::string& threadId, bool muted) = 0;
    virtual void ChatThreadRemoved(UserId userId, const std::string& threadId) = 0;
    virtual void ChatThreadGlobalUnreadCountsChanged(UserId userId, const UnreadThreadCounts& counts) = 0;
};


class ttv::chat::IChatReplayListener
{
public:
    virtual void ChatReplayStateChanged(UserId userId, const std::string& vodId, ChatReplayState state, TTV_ErrorCode ec) = 0;
    virtual void ChatReplayCurrentTimeChanged(UserId userId, const std::string& vodId, Timestamp time) = 0;
    virtual void ChatReplayMessagesReceived(UserId userId, const std::string& vodId, const std::vector<ReplayMessage>& messageList) = 0;
    virtual void ChatReplayDeleteMessageComplete(UserId userId, const std::string& vodId, const std::string& messageId, TTV_ErrorCode ec) = 0;
};


struct ttv::chat::ChatChannelListenerProxy : public IChatChannelListener
{
    using ChatChannelStateChangedCallback = std::function<void(UserId userId, ChannelId channelId, ChatChannelState state, TTV_ErrorCode ec)>;
    using ChatChannelInfoChangedCallback = std::function<void(UserId userId, ChannelId channelId, const ChatChannelInfo& channelInfo)>;
    using ChatChannelRestrictionsChangedCallback = std::function<void(UserId userId, ChannelId channelId, const ChatChannelRestrictions& restrictions)>;
    using ChatChannelLocalUserChangedCallback = std::function<void(UserId userId, ChannelId channelId, const ChatUserInfo& userInfo)>;
    using ChatChannelSubscriptionNoticeReceivedCallback = std::function<void(UserId userId, ChannelId channelId, const SubscriptionNotice& notice)>;
    using ChatChannelFirstTimeChatterNoticeReceivedCallback = std::function<void(UserId userId, ChannelId channelId, const FirstTimeChatterNotice& notice)>;
    using ChatChannelRaidNoticeReceivedCallback = std::function<void(UserId userId, ChannelId channelId, const RaidNotice& notice)>;
    using ChatChannelUnraidNoticeReceivedCallback = std::function<void(UserId userId, ChannelId channelId, const UnraidNotice& notice)>;
    using ChatChannelMessagesReceivedCallback = std::function<void(UserId userId, ChannelId channelId, const std::vector<LiveChatMessage>& messageList)>;
    using ChatChannelMessagesClearedCallback = std::function<void(UserId userId, ChannelId channelId)>;
    using ChatChannelUserMessagesClearedCallback = std::function<void(UserId userId, ChannelId channelId, UserId clearUserId)>;
    using ChatChannelHostTargetChangedCallback = std::function<void(UserId userId, ChannelId channelId, const std::string& targetChannel, uint32_t numViewers)>;
    using ChatChannelNoticeReceivedCallback = std::function<void(UserId userId, ChannelId channelId, const std::string& noticeId, const std::map<std::string, std::string>& params)>;
    using ChatChannelSetBroadcasterLanguageChatEnabledCompleteCallback = std::function<void(UserId userId, ChannelId channelId, TTV_ErrorCode ec)>;

    // IChatChannelListener implementation
    virtual void ChatChannelStateChanged(UserId userId, ChannelId channelId, ChatChannelState state, TTV_ErrorCode ec) override
    {
        if (chatChannelStateChangedCallback != nullptr)
        {
            chatChannelStateChangedCallback(userId, channelId, state, ec);
        }
    }

    virtual void ChatChannelInfoChanged(UserId userId, ChannelId channelId, const ChatChannelInfo& channelInfo) override
    {
        if (chatChannelInfoChangedCallback != nullptr)
        {
            chatChannelInfoChangedCallback(userId, channelId, channelInfo);
        }
    }
    
    virtual void ChatChannelRestrictionsChanged(UserId userId, ChannelId channelId, const ChatChannelRestrictions& restrictions) override
    {
        if (chatChannelRestrictionsChangedCallback != nullptr)
        {
            chatChannelRestrictionsChangedCallback(userId, channelId, restrictions);
        }
    }

    virtual void ChatChannelLocalUserChanged(UserId userId, ChannelId channelId, const ChatUserInfo& userInfo) override
    {
        if (chatChannelLocalUserChangedCallback != nullptr)
        {
            chatChannelLocalUserChangedCallback(userId, channelId, userInfo);
        }
    }

    virtual void ChatChannelSubscriptionNoticeReceived(UserId userId, ChannelId channelId, const SubscriptionNotice& notice) override
    {
        if (chatChannelSubscriptionNoticeReceivedCallback != nullptr)
        {
            chatChannelSubscriptionNoticeReceivedCallback(userId, channelId, notice);
        }
    }
    
    virtual void ChatChannelFirstTimeChatterNoticeReceived(UserId userId, ChannelId channelId, const FirstTimeChatterNotice& notice) override
    {
        if (chatChannelFirstTimeChatterNoticeReceivedCallback != nullptr)
        {
            chatChannelFirstTimeChatterNoticeReceivedCallback(userId, channelId, notice);
        }
    }

    virtual void ChatChannelRaidNoticeReceived(UserId userId, ChannelId channelId, const RaidNotice& notice) override
    {
        if (chatChannelRaidNoticeReceivedCallback != nullptr)
        {
            chatChannelRaidNoticeReceivedCallback(userId, channelId, notice);
        }
    }

    virtual void ChatChannelUnraidNoticeReceived(UserId userId, ChannelId channelId, const UnraidNotice& notice) override
    {
        if (chatChannelUnraidNoticeReceivedCallback != nullptr)
        {
            chatChannelUnraidNoticeReceivedCallback(userId, channelId, notice);
        }
    }

    virtual void ChatChannelMessagesReceived(UserId userId, ChannelId channelId, const std::vector<LiveChatMessage>& messageList) override
    {
        if (chatChannelMessagesReceivedCallback != nullptr)
        {
            chatChannelMessagesReceivedCallback(userId, channelId, messageList);
        }
    }

    virtual void ChatChannelMessagesCleared(UserId userId, ChannelId channelId) override
    {
        if (chatChannelMessagesClearedCallback != nullptr)
        {
            chatChannelMessagesClearedCallback(userId, channelId);
        }
    }

    virtual void ChatChannelUserMessagesCleared(UserId userId, ChannelId channelId, UserId clearUserId) override
    {
        if (chatChannelUserMessagesClearedCallback != nullptr)
        {
            chatChannelUserMessagesClearedCallback(userId, channelId, clearUserId);
        }
    }

    virtual void ChatChannelHostTargetChanged(UserId userId, ChannelId channelId, const std::string& targetChannel, uint32_t numViewers) override
    {
        if (chatChannelHostTargetChangedCallback != nullptr)
        {
            chatChannelHostTargetChangedCallback(userId, channelId, targetChannel, numViewers);
        }
    }

    virtual void ChatChannelNoticeReceived(UserId userId, ChannelId channelId, const std::string& noticeId, const std::map<std::string, std::string>& params) override
    {
        if (chatChannelNoticeReceivedCallback != nullptr)
        {
            chatChannelNoticeReceivedCallback(userId, channelId, noticeId, params);
        }
    }

    ChatChannelStateChangedCallback chatChannelStateChangedCallback;
    ChatChannelInfoChangedCallback chatChannelInfoChangedCallback;
    ChatChannelRestrictionsChangedCallback chatChannelRestrictionsChangedCallback;
    ChatChannelLocalUserChangedCallback chatChannelLocalUserChangedCallback;
    ChatChannelSubscriptionNoticeReceivedCallback chatChannelSubscriptionNoticeReceivedCallback;
    ChatChannelFirstTimeChatterNoticeReceivedCallback chatChannelFirstTimeChatterNoticeReceivedCallback;
    ChatChannelRaidNoticeReceivedCallback chatChannelRaidNoticeReceivedCallback;
    ChatChannelUnraidNoticeReceivedCallback chatChannelUnraidNoticeReceivedCallback;
    ChatChannelMessagesReceivedCallback chatChannelMessagesReceivedCallback;
    ChatChannelMessagesClearedCallback chatChannelMessagesClearedCallback;
    ChatChannelUserMessagesClearedCallback chatChannelUserMessagesClearedCallback;
    ChatChannelHostTargetChangedCallback chatChannelHostTargetChangedCallback;
    ChatChannelNoticeReceivedCallback chatChannelNoticeReceivedCallback;
    ChatChannelSetBroadcasterLanguageChatEnabledCompleteCallback chatChannelSetBroadcasterLanguageChatEnabledCompleteCallback;
};