chatapi.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/coreapi.h"
#include "twitchsdk/core/module.h"
#include "twitchsdk/chat/chattypes.h"
#include "twitchsdk/chat/chatlistener.h"
#include "twitchsdk/chat/chaterrortypes.h"
#include "twitchsdk/chat/internal/channel/bitsstatus.h"
#include "twitchsdk/chat/internal/channel/followersstatus.h"
#include "twitchsdk/chat/internal/channel/subscribersstatus.h"

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

namespace ttv
{
    class TaskRunner;
    class UserRepository;
    class SettingRepository;

    namespace chat
    {
        class ChatAPI;
        class ChatAPITaskHost;
        class ChatChannel;
        class BitsConfigRepository;
        class IChatObjectFactory;
        class ChatChannelSet;
        class ChatUserThreads;
        class ChatUserThread;
        class ChatUserBlockList;
        class IChannelChatRoomManager;
        class IChannelChatRoomManagerListener;
        class IChatRoom;
        class IChatRoomListener;
        class IChatRoomNotifications;
        class IChatRoomNotificationsListener;
        class IChatChannel;
        class IChatReplay;
        class IChatRaid;
        class IChatRaidListener;
        class IBitsStatus;
        class IBitsListener;
        class IFollowersStatus;
        class IFollowersListener;
        class ISubscribersStatus;
        class ISubscribersListener;
        class IChatChannelProperties;
        class IChatChannelPropertyListener;
        struct ChatAPIInternalData;
    }
}


class ttv::chat::ChatAPI : public ttv::ModuleBase
{
public:
    using FetchUserListCallback = std::function<void(TTV_ErrorCode ec, UserList&& userList)>;
    
    using BlockChangeCallback = std::function<void(TTV_ErrorCode ec)>;
    
    using FetchEmoticonSetsCallback = std::function<void(TTV_ErrorCode ec, const std::vector<EmoticonSet>& sets)>;
    
    using FetchBadgesCallback = std::function<void(TTV_ErrorCode ec, BadgeSet&& badges)>;
    
    using FetchBitsConfigurationCallback = std::function<void(TTV_ErrorCode ec, const std::shared_ptr<BitsConfiguration>& bitsConfig)>;
    
    using SetBroadcasterLanguageChatEnabledCallback = std::function<void(TTV_ErrorCode ec)>;
    
    using SendMessageCallback = std::function<void(TTV_ErrorCode ec, MessageId messageID)>;
    
    using FetchThreadDataPageCallback = std::function<void(TTV_ErrorCode ec, const std::vector<ThreadData>& threadPage, uint32_t total)>;
    
    using FetchThreadDataCallback = std::function<void(TTV_ErrorCode ec, const ThreadData& threadData)>;
    
    using FetchThreadMessagesCallback = std::function<void(TTV_ErrorCode ec, const std::vector<WhisperMessage>& message)>;
    
    using SetLastMessageReadIdCallback = std::function<void(TTV_ErrorCode ec)>;
    
    using SetThreadMutedCallback = std::function<void(TTV_ErrorCode ec)>;
    
    using SetThreadArchivedCallback = std::function<void(TTV_ErrorCode ec)>;
    
    using FetchThreadUnreadCountsCallback = std::function<void(TTV_ErrorCode ec, const UnreadThreadCounts& counts)>;
    
    using FetchBlockedUsersCallback = std::function<void(TTV_ErrorCode ec, const std::vector<UserInfo>& blockedUsers)>;
    
    using BanUserCallback = std::function<void(TTV_ErrorCode ec, BanUserError&& error)>;
    
    using UnbanUserCallback = std::function<void(TTV_ErrorCode ec, UnbanUserError&& error)>;
    
    using ModUserCallback = std::function<void(TTV_ErrorCode ec, ModUserError&& error)>;
    
    using UnmodUserCallback = std::function<void(TTV_ErrorCode ec, UnmodUserError&& error)>;
    
    using UpdateUserColorCallback = std::function<void(TTV_ErrorCode ec)>;
    
    using FetchChannelModeratorsCallback = std::function<void(TTV_ErrorCode ec, const std::vector<std::string>& modNames, const std::string& nextCursor)>;

    ChatAPI();
    virtual ~ChatAPI();

    // IModule implementation
    virtual std::string GetModuleName() const override;
    virtual TTV_ErrorCode Initialize(const InitializeCallback& callback) override;
    virtual TTV_ErrorCode Shutdown(const ShutdownCallback& callback) override;
    virtual TTV_ErrorCode Update() override;

    TTV_ErrorCode SetCoreApi(const std::shared_ptr<CoreAPI>& coreApi);
    
    TTV_ErrorCode SetListener(const std::shared_ptr<IChatAPIListener>& listener);
    
    TTV_ErrorCode SetEnabledFeatures(const FeatureFlags& features);
    
    TTV_ErrorCode SetTokenizationOptions(const TokenizationOptions& options);

    TTV_ErrorCode SetUserThreadsListener(UserId userId, const std::shared_ptr<IChatUserThreadsListener>& listener);

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

    TTV_ErrorCode BlockUser(UserId userId, UserId blockUserId, const std::string& reason, bool whisper, const BlockChangeCallback& callback);
    
    TTV_ErrorCode UnblockUser(UserId userId, UserId blockUserId, const BlockChangeCallback& callback);
    
    TTV_ErrorCode GetUserBlocked(UserId userId, UserId blockUserId, bool& blocked);

    TTV_ErrorCode FetchBlockedUsers(UserId userId, const FetchBlockedUsersCallback& callback);
    
    TTV_ErrorCode FetchUserEmoticonSets(UserId userId, bool forceRefetch, const FetchEmoticonSetsCallback& callback);

    TTV_ErrorCode FetchGlobalBadges(const FetchBadgesCallback& callback);
    
    TTV_ErrorCode FetchChannelBadges(ChannelId channelId, const FetchBadgesCallback& callback);

    TTV_ErrorCode FetchGlobalBitsConfiguration(const FetchBitsConfigurationCallback& callback);
    
    TTV_ErrorCode FetchChannelBitsConfiguration(ChannelId channelId, const FetchBitsConfigurationCallback& callback);

    TTV_ErrorCode SetBroadcasterLanguageChatEnabled(UserId userId, ChannelId channelId, bool enabled, const SetBroadcasterLanguageChatEnabledCallback& callback);
    
    TTV_ErrorCode OptInToBroadcasterLanguageChat(UserId userId, ChannelId channelId, const std::string& language);

    TTV_ErrorCode GenerateThreadId(UserId userId, UserId otherUserId, std::string& threadId);
    
    TTV_ErrorCode SendMessageToUser(UserId userId, UserId otherUserId, const std::string& message, WhisperMessage& placeholderMessage, const SendMessageCallback& callback);
    
    TTV_ErrorCode FetchThreadDataPage(UserId userId, uint32_t offset, uint32_t pageSize, const FetchThreadDataPageCallback& callback);
    
    TTV_ErrorCode FetchUserThreadData(UserId userId, const std::string& threadId, const FetchThreadDataCallback& callback);

    TTV_ErrorCode FetchThreadMessages(UserId userId, const std::string& threadId, MessageId start, uint32_t beforeCount, const FetchThreadMessagesCallback& callback);

    TTV_ErrorCode SetLastMessageReadId(UserId userId, const std::string& threadId, MessageId lastReadMessageId, const SetLastMessageReadIdCallback& callback);
    
    TTV_ErrorCode SetThreadMuted(UserId userId, const std::string& threadId, bool muted, const SetThreadMutedCallback& callback);
    
    TTV_ErrorCode SetThreadArchived(UserId userId, const std::string& threadId, bool archived, const SetThreadArchivedCallback& callback);

    TTV_ErrorCode FetchThreadUnreadCounts(UserId userId, const FetchThreadUnreadCountsCallback& callback);

    TTV_ErrorCode SetMessageFlushInterval(uint64_t milliseconds);
    
    uint64_t GetMessageFlushInterval() const;

    TTV_ErrorCode GetEmoticonUrl(uint32_t emoticonId, float scale, std::string& result);

    TTV_ErrorCode CreateChatChannel(UserId userId, ChannelId channelId, const std::shared_ptr<IChatChannelListener>& listener, std::shared_ptr<IChatChannel>& result);

    TTV_ErrorCode CreateChatChannelProperties(UserId userId, ChannelId channelId, const std::shared_ptr<IChatChannelPropertyListener>& listener, std::shared_ptr<IChatChannelProperties>& result);

    TTV_ErrorCode CreateChatReplay(UserId userId, const std::string& vodId, const std::shared_ptr<IChatReplayListener>& listener, std::shared_ptr<IChatReplay>& result);
    
    TTV_ErrorCode CreateChannelChatRoomManager(UserId userId, ChannelId channelId, const std::shared_ptr<IChannelChatRoomManagerListener>& listener, std::shared_ptr<IChannelChatRoomManager>& result);
    
    TTV_ErrorCode CreateChatRoom(UserId userId, const std::string& roomId, ChannelId channelId, const std::shared_ptr<IChatRoomListener>& listener, std::shared_ptr<IChatRoom>& result);

    TTV_ErrorCode CreateChatRoomNotifications(UserId userId, const std::shared_ptr<IChatRoomNotificationsListener>& listener, std::shared_ptr<IChatRoomNotifications>& result);

    TTV_ErrorCode CreateChatRaid(UserId userId, ChannelId channelId, const std::shared_ptr<IChatRaidListener>& listener, std::shared_ptr<IChatRaid>& result);

    TTV_ErrorCode CreateBitsStatus(UserId userId, ChannelId channelId, const std::shared_ptr<IBitsListener>& listener, std::shared_ptr<IBitsStatus>& result);

    TTV_ErrorCode CreateFollowersStatus(UserId userId, ChannelId channelId, const std::shared_ptr<IFollowersListener>& listener, std::shared_ptr<IFollowersStatus>& result);

    TTV_ErrorCode CreateSubscribersStatus(UserId userId, ChannelId channelId, const std::shared_ptr<ISubscribersListener>& listener, std::shared_ptr<ISubscribersStatus>& result);

    TTV_ErrorCode BanUser(UserId userId, ChannelId channelId, const std::string& bannedUserName, uint32_t durationSeconds, const BanUserCallback& callback);
    
    TTV_ErrorCode UnbanUser(UserId userId, ChannelId channelId, const std::string& bannedUserName, const UnbanUserCallback& callback);
    
    TTV_ErrorCode ModUser(UserId userId, ChannelId channelId, const std::string& modUserName, const ModUserCallback& callback);
    
    TTV_ErrorCode UnmodUser(UserId userId, ChannelId channelId, const std::string& unmodUserName, const UnmodUserCallback& callback);
    
    TTV_ErrorCode UpdateUserColor(UserId userId, const std::string& color, const UpdateUserColorCallback& callback);
    
    TTV_ErrorCode FetchChannelModerators(ChannelId channelId, const std::string& cursor, const FetchChannelModeratorsCallback& callback);
    
    static void GetRequiredAuthScopes(std::vector<std::string>& scopes);
    
    void SetChatObjectFactory(const std::shared_ptr<IChatObjectFactory>& factory);

private:
    class CoreApiClient : public ICoreApiClient
    {
    public:
        CoreApiClient(ChatAPI* api);

        // ICoreApiClient implementation
        virtual std::string GetClientName() override;
        virtual void GetRequiredOAuthScopes(std::vector<std::string>& scopes) override;
        virtual void CoreUserLoggedIn(std::shared_ptr<User> user) override;
        virtual void CoreUserLoggedOut(std::shared_ptr<User> user) override;
        virtual void CoreLocalLanguageChanged(const std::string& language) override;

    private:
        ChatAPI* mApi;
    };
    
    TTV_ErrorCode GetChannelSet(UserId userId, std::shared_ptr<ChatChannelSet>& channelSet);

    std::shared_ptr<ChatUserBlockList> CreateUserBlockList(const std::shared_ptr<User>& user);

    // ICoreApiClient implementation
    void CoreUserLoggedIn(std::shared_ptr<User> user);
    void CoreUserLoggedOut(std::shared_ptr<User> user);
    void CoreLocalLanguageChanged(const std::string& language);

    // ModuleBase overrides
    virtual bool CheckShutdown() override;
    virtual void CompleteShutdown() override;
    
    TTV_ErrorCode GetBlockListForUser(UserId userId, std::shared_ptr<ChatUserBlockList>& blockList);
    TTV_ErrorCode GetUserThreadsForUser(UserId userId, std::shared_ptr<ChatUserThreads>& userThreads);
    TTV_ErrorCode GetThreadForUser(UserId userId, const std::string& threadId, std::shared_ptr<ChatUserThread>& thread);

    TTV_ErrorCode DisposeChatChannel(const std::shared_ptr<IChatChannel>& chatChannel);
    TTV_ErrorCode DisposeChatChannelProperties(const std::shared_ptr<IChatChannelProperties>& chatChannelProperties);
    TTV_ErrorCode DisposeChatReplay(const std::shared_ptr<IChatReplay>& chatReplay);
    TTV_ErrorCode DisposeChatRaid(const std::shared_ptr<IChatRaid>& chatRaid);
    TTV_ErrorCode DisposeChannelChatRoomManager(const std::shared_ptr<IChannelChatRoomManager>& channelChatRoomManager);
    TTV_ErrorCode DisposeChatRoom(const std::shared_ptr<IChatRoom>& chatRoom);
    TTV_ErrorCode DisposeChatRoomNotifications(const std::shared_ptr<IChatRoomNotifications>& chatRoomNotifications);
    TTV_ErrorCode DisposeBitsStatus(const std::shared_ptr<IBitsStatus>& bitsStatus);
    TTV_ErrorCode DisposeFollowersStatus(const std::shared_ptr<IFollowersStatus>& followersStatus);
    TTV_ErrorCode DisposeSubscribersStatus(const std::shared_ptr<ISubscribersStatus>& subscribersStatus);

    std::shared_ptr<CoreAPI> mCoreApi;
    std::shared_ptr<CoreApiClient> mCoreApiClient;
    std::shared_ptr<ChatAPIInternalData> mInternalData;
    std::shared_ptr<IChatObjectFactory> mChatObjectFactory; 
    std::shared_ptr<ChannelRepository> mChannelRepository; 
    std::shared_ptr<UserRepository> mUserRepository; 
    std::shared_ptr<SettingRepository> mSettingRepository;
    std::shared_ptr<BitsConfigRepository> mBitsConfigRepository;
    std::shared_ptr<ChatAPITaskHost> mTaskHost;

    std::shared_ptr<TaskRunner> mTaskRunner; 
    std::shared_ptr<TaskRunner> mUserBlocksTaskRunner; 

    FeatureFlags mEnabledFeatures;
    TokenizationOptions mTokenizationOptions;
};