chattypes.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/chaterrortypes.h"
#include "twitchsdk/core/types/coretypes.h"
#include "twitchsdk/core/coreutilities.h"

#include <map>
#include <regex>


namespace ttv
{
    namespace chat
    {
        using EmoticonId = uint32_t;
        using EmoticonSetId = uint32_t;
        using MessageId = uint32_t;
        
        struct FeatureFlags
        {
            FeatureFlags();
            
            static FeatureFlags All();
            static FeatureFlags None();
            
            bool conversations:1;   
        };
        
        struct TokenizationOptions
        {
            TokenizationOptions();
            
            static TokenizationOptions All();
            static TokenizationOptions None();
            
            bool Any() const;
            
            bool emoticons:1;       
            bool mentions:1;        
            bool urls:1;            
            bool bits:1;            
        };

        
        enum class ChatChannelState
        {
            Disconnected,
            Connecting,
            Connected,
            Disconnecting
        };


        enum class ChatMode
        {
            Slow,                   
            R9k,                    
            EmotesOnly              
        };

        
        struct ChatModeInfo
        {
            ChatModeInfo();
            
            uint32_t slowModeDurationSeconds;           
            bool r9kMode;                               
            bool emotesOnlyMode;                        
        };
        
        
        struct UserMode
        {
            UserMode();
            
            bool operator==(const UserMode& rhs) const;
            bool operator!=(const UserMode& rhs) const;
            
            bool moderator:1;               
            bool broadcaster:1;             
            bool administrator:1;           
            bool staff:1;                   
            bool system:1;                  
            bool globalModerator:1;         
            bool banned:1;
        };
        
        
        struct SubscriptionStatus
        {
            SubscriptionStatus();
            
            bool operator==(const SubscriptionStatus& rhs) const;
            bool operator!=(const SubscriptionStatus& rhs) const;
            
            bool subscriber:1;              
            bool turbo:1;                   
        };
        
        
        struct ChatUserInfo
        {
            ChatUserInfo();
            
            bool operator==(const ChatUserInfo& rhs) const;
            bool operator!=(const ChatUserInfo& rhs) const;
            
            std::string userName;
            std::string displayName;        
            Color nameColorARGB;                                
            UserId userId;                                      
            UserMode userMode;                      
            SubscriptionStatus subscriptionStatus;      
        };
        
        
        struct RestrictionReason
        {
            RestrictionReason();
            
            bool operator==(const RestrictionReason& rhs) const;
            bool operator!=(const RestrictionReason& rhs) const;
            
            bool anonymous:1;               
            bool subscribersOnly:1;         
            bool slowMode:1;                
            bool timeout:1;                 
            bool banned:1;                  
            bool language:1;                
        };


        struct ChatChannelInfo
        {
            std::string name;                                           
            std::string broadcasterLanguage;                            
            RestrictionReason localUserRestriction;                     
        };
        
        
        struct ChatChannelRestrictions
        {
            ChatChannelRestrictions();
            
            std::string chatLanguage;                                   
            uint32_t followersDuration;                                 
            uint32_t slowModeDuration;                                  
            bool emoteOnly;                                             
            bool followersOnly;                                         
            bool subscribersOnly;                                       
            bool slowMode;                                              
            bool r9k;                                                   
        };


        class MessageToken
        {
        public:
            enum class Type
            {
                Text,
                Emoticon,
                Mention,
                Url,
                Bits
            };
            
            virtual std::unique_ptr<MessageToken> Clone() const = 0;
            virtual Type GetType() const = 0;
        };
        
        bool TokensEqual(const std::unique_ptr<MessageToken>& lhs, const std::unique_ptr<MessageToken>& rhs);
        
        struct TextToken : public Cloneable<MessageToken, TextToken>
        {
            TextToken() = default;
            TextToken(const std::string& text);
            
            std::string text;
            
            virtual Type GetType() const override { return Type::Text; }
        };
        
        
        struct EmoticonToken : public Cloneable<MessageToken, EmoticonToken>
        {
            EmoticonToken();
            EmoticonToken(const std::string& emoticonText, EmoticonId emoticonId);
            
            std::string emoticonText;                               
            EmoticonId emoticonId;                                  
            
            virtual Type GetType() const override { return Type::Emoticon; }
        };
        
        
        struct MentionToken : public Cloneable<MessageToken, MentionToken>
        {
            MentionToken(const std::string& userName, const std::string& text, bool isLocalUser);
            
            std::string userName;                                   
            std::string text;                                       
            bool isLocalUser;                                       
            
            virtual Type GetType() const override { return Type::Mention; }
        };
        
        
        struct UrlToken : public Cloneable<MessageToken, UrlToken>
        {
            UrlToken();
            UrlToken(const std::string& url, bool hidden);
            
            std::string url;                        
            bool hidden;                        
            
            virtual Type GetType() const override { return Type::Url; }
        };
        
        
        struct BitsToken : public Cloneable<MessageToken, BitsToken>
        {
            BitsToken();
            BitsToken(const std::string& prefix, uint32_t numBits);
            
            std::string prefix;                                     
            uint32_t numBits;                                       
            
            virtual Type GetType() const override { return Type::Bits; }
        };
        
        
        struct MessageBadge
        {
            std::string name;               
            std::string version;                
        };

        
        struct MessageInfo
        {
            MessageInfo();
            MessageInfo(const MessageInfo& src);
            MessageInfo& operator=(const MessageInfo& src);
            
            struct Flags
            {
                Flags();
                
                bool operator==(const Flags& rhs) const;
                bool operator!=(const Flags& rhs) const;
                
                bool action:1;                          
                bool notice:1;                          
                bool ignored:1;                         
                bool deleted:1;                         
                bool containsBits:1;                    
            };
            
            std::string userName;                               
            std::string displayName;                            
            std::vector<std::unique_ptr<MessageToken>> tokens;  
            std::vector<MessageBadge> badges;                   
            UserMode userMode;                                  
            Flags flags;                                        
            Color nameColorARGB;                                
            Timestamp timestamp;                                
            UserId userId;                                      
            uint32_t numBitsSent;                               
        };
        
        
        struct LiveChatMessage
        {
            LiveChatMessage() {}
            LiveChatMessage(const LiveChatMessage& src);
            LiveChatMessage& operator=(const LiveChatMessage& src);
            
            MessageInfo messageInfo;                            
            std::string messageId;                              
        };
        
        
        struct WhisperMessage
        {
            WhisperMessage();
            WhisperMessage(const WhisperMessage& src);
            WhisperMessage& operator=(const WhisperMessage& src);
            
            MessageInfo messageInfo;                            
            std::string threadId;                               
            MessageId messageId;                                
        };
        
        
        struct ChatRoomMessage
        {
            MessageInfo messageInfo;                    
            std::string roomId;                         
            std::string roomMessageId;                  
        };
        
        
        struct SubscriptionNotice
        {
            SubscriptionNotice();
            SubscriptionNotice(const SubscriptionNotice& source);
            SubscriptionNotice& operator=(const SubscriptionNotice& source);
            
            enum class Type
            {
                Sub,
                Resub,
                SubGift,
                Charity,
                Unknown
            };
            
            enum class Plan
            {
                Prime,      
                Sub1000,    
                Sub2000,    
                Sub3000,    
                Unknown     
            };
            
            
            struct Recipient
            {
                Recipient();
                
                std::string userName;
                std::string displayName;
                UserId userId;
            };
            
            std::unique_ptr<MessageInfo> userMessage;       
            std::string systemMessage;                      
            std::string planDisplayName;                    
            std::string messageId;                          
            Recipient recipient;                            
            uint32_t subMonthCount;                         
            Type type;                                      
            Plan plan;                                      
        };
        
        
        struct FirstTimeChatterNotice
        {
            MessageInfo userMessage;                        
            std::string systemMessage;                      
            std::string messageId;                          
        };


        struct RaidNotice
        {
            RaidNotice();
            
            std::string systemMessage;  
            UserInfo raidingUserInfo;   
            uint32_t viewerCount;       
        };
        
        
        struct UnraidNotice
        {
            std::string systemMessage;  
        };


        struct BadgeEntitlement
        {
            BadgeEntitlement();

            uint32_t newLevel;          
            uint32_t previousLevel;     
            bool isNewBadgeLevel;       
        };


        struct BitsReceivedEvent
        {
            // displayName, userMode not filled out in message
            MessageInfo message;        

            std::string channelName;    
            std::string context;        

            ChannelId channelId;        
            uint32_t bitsUsed;          
            uint32_t totalBitsUsed;     
            
            BadgeEntitlement badge;     
        };

        struct BitsSentEvent
        {
            BitsSentEvent();

            ChannelId channelId;        
            uint32_t userBitsBalance;   
            uint32_t channelBitsTotal;  
        };

        struct FollowerAddedEvent
        {
            std::string displayName;    
            std::string userName;       
            UserId userId;              
        };


        struct SubscriberAddedEvent
        {
            // userMode not filled out in subNotice.userMessage
            // systemMessage not filled out in subNotice
            SubscriptionNotice subNotice;   

            std::string userName;           
            std::string displayName;        
            std::string channelName;        
            UserId userId;                  
            ChannelId channelId;            
            Timestamp timestamp;            
        };
        

        struct ThreadData
        {
            ThreadData();
            ThreadData(const ThreadData& src);
            ThreadData& operator=(const ThreadData& src);
            
            std::string threadId;                                   
            std::vector<ChatUserInfo> participants;                 
            std::unique_ptr<WhisperMessage> lastMessage;            
            MessageId lastMessageId;                                
            MessageId lastReadMessageId;                            
            Timestamp lastUpdatedTimestamp;                         
            Timestamp lastFetchedTimestamp;                         
            uint32_t numUnreadMessages;
            bool archived;
            bool muted;
        };
        
        
        enum class ChatReplayState
        {
            Paused,
            Playing,
            Buffering,
            NoMessagesForVod
        };
        
        
        struct ReplayMessage
        {
            ReplayMessage();
            
            MessageInfo messageInfo;                                
            std::string messageId;                                  
            bool deleted;                                           
        };
        
        
        struct BadgeImage
        {
            BadgeImage();
            
            std::string url;                            
            float scale;                            
        };
        
        
        struct BadgeVersion
        {
            BadgeVersion();
            
            enum class Action
            {
                None,
                SubscribeToChannel,
                VisitUrl,
                Turbo
            };
            
            std::string name;
            std::string title;
            std::string description;
            std::string clickUrl;               
            std::vector<BadgeImage> images;
            Action clickAction;                 

            TTV_ErrorCode FindImage(float scale, BadgeImage& result) const;
        };
        
        
        struct Badge
        {
            std::string name;                                           
            std::map<std::string, BadgeVersion> versions;               
        };
        
        
        struct BadgeSet
        {
            std::string language;                           
            std::map<std::string, Badge> badges;                

            TTV_ErrorCode FindBadge(const MessageBadge& badge, BadgeVersion& result) const;

            TTV_ErrorCode FindBadgeImage(const MessageBadge& badge, float scale, BadgeImage& result) const;
        };

        
        struct Emoticon
        {
            Emoticon();
            bool operator==(const Emoticon& rhs) const;
            
            std::regex regex;
            std::string match;
            EmoticonId emoticonId;
            bool isRegex;
        };
        
                
        struct EmoticonSet
        {
            EmoticonSet();
            bool operator==(const EmoticonSet& rhs) const;
            bool operator<(const EmoticonSet& rhs) const;
            
            std::vector<Emoticon> emoticons;
            EmoticonSetId emoticonSetId;
        };
        
        
        class BitsConfiguration
        {
        public:
            struct BitsImage
            {
                BitsImage();
                
                std::string url;
                std::string background;
                std::string animationState;
                float scale;
            };
            
            struct ImageTier
            {
                ImageTier();
                
                std::vector<BitsImage> images;
                uint32_t minBits;
                Color color;
            };
            
            struct Action
            {
                Action();
                
                enum class Type
                {
                    GlobalFirstParty,
                    GlobalThirdParty,
                    ChannelCustom,
                    Unknown
                };
                
                std::string prefix;
                std::vector<ImageTier> tiers;
                std::vector<float> imageScales;
                std::vector<std::string> imageBackgrounds;
                std::vector<std::string> imageAnimationStates;
                uint32_t priority;      
                Type type;
            };

        public:
            BitsConfiguration(const std::vector<Action>& actions, ChannelId channelId);
            BitsConfiguration();
            
            TTV_ErrorCode GetBitsImageUrl(const std::string& prefix, uint32_t numBits, const std::string& animation, const std::string& background, float scale, std::string& url, Color& color) const;
            
            const std::vector<Action>& GetActions() const;  
            ChannelId GetChannelId() const;                 
            
        private:
            std::vector<Action> mActions;   
            ChannelId mChannelId;           
        };
        
        
        struct UnreadThreadCounts
        {
            UnreadThreadCounts();
            
            bool operator==(const UnreadThreadCounts&) const;
            bool operator!=(const UnreadThreadCounts&) const;
            
            uint32_t unreadThreadCount;
            uint32_t unreadMessageCount;
            bool exhaustive;
        };
        
        
        struct UserList
        {
            UserList();
            
            std::vector<std::string> moderators;
            std::vector<std::string> globalModerators;
            std::vector<std::string> staff;
            std::vector<std::string> admins;
            std::vector<std::string> viewers;
            
            uint32_t totalUserCount;
        };
        
        
        enum class RoomRole
        {
            Unknown,
            Everyone,
            Subscriber,
            Moderator
        };
        
        
        struct ChatRoomPermissions
        {
            ChatRoomPermissions();
            
            bool readMessages;                      
            bool sendMessages;                      
            bool moderate;                          
        };
        
        
        struct ChatRoomView
        {
            ChatRoomView();
            
            Timestamp lastReadAt;                   
            uint32_t unreadMentionCount;            
            ChatRoomPermissions permissions;        
            bool isMuted;                           
            bool isArchived;                        
            bool isUnread;                          
        };
        
        
        struct ChatRoomInfo
        {
            ChatRoomInfo();
            
            UserInfo owner;                                 
            ChatRoomView view;                              
            ChatModeInfo modes;                                 
            std::string id;                                 
            std::string name;                               
            std::string topic;                              
            RoomRole minimumAllowedRole;                    
            bool isPreviewable;                             
        };


        struct RoomMentionInfo
        {
            RoomMentionInfo();

            std::string roomOwnerName;
            std::string roomOwnerLogin;
            std::string senderName;
            std::string roomId;
            std::string roomName;
            std::string messageId;
            ChannelId roomOwnerId;
            UserId senderId;
            Timestamp sentAt;
        };
        
        
        struct RaidStatus
        {
            RaidStatus();

            bool operator==(const RaidStatus& other) const;
            bool operator!=(const RaidStatus& other) const;

            std::string raidId;                 
            UserId creatorUserId;               
            UserId sourceUserId;                
            UserId targetUserId;                
            Timestamp announceTime;             
            Timestamp raidTime;                 
            uint32_t remainingSecondsDuration;  
            uint32_t numUsersInRaid;            
            bool joined;                        
        };
        
        struct HostTargetChange
        {
            HostTargetChange();

            std::string targetChannelName;      
            ChannelId targetChannelId;          
            ChannelId previousChannelId;        
        };
    }
}