chatuserthreads.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-2017 Twitch Interactive, Inc.
*********************************************************************************************/

#pragma once

#include "twitchsdk/chat/chattypes.h"
#include "twitchsdk/chat/chatlistener.h"
#include "twitchsdk/chat/ichatobjectfactory.h"
#include "twitchsdk/chat/internal/bitsconfigrepository.h"
#include "twitchsdk/chat/internal/chatuserthread.h"
#include "twitchsdk/chat/internal/chathelpers.h"
#include "twitchsdk/core/eventsource.h"
#include "twitchsdk/core/component.h"
#include "twitchsdk/core/pubsub/pubsubclient.h"
#include <string>
#include <vector>
#include <unordered_set>
#include <map>
#include <memory>
#include <atomic>

namespace ttv
{
    class TaskRunner;
    class Task;
    class User;
    class UserRepository;
    class SettingRepository;
    class PagedRequestFetcher;

    namespace chat
    {
        class ChatUserThreads;
        class ChatGetDisplayInfoTask;
        class ChatGetUserThreadsTask;
        class ChatGetUnreadMessageCountTask;
        class BitsConfigRepository;
    }
}


class ttv::chat::ChatUserThreads : public UserComponent
{
public:
    using SendMessageCallback = std::function<void(TTV_ErrorCode ec, MessageId messageId)>;
    using FetchThreadDataPageCallback = std::function<void(TTV_ErrorCode ec, const std::vector<ThreadData>& page, uint32_t total)>;
    using FetchThreadDataCallback = std::function<void(TTV_ErrorCode ec, const ThreadData& data)>;
    using FetchUnreadCountsCallback = std::function<void(TTV_ErrorCode ec, const UnreadThreadCounts& counts)>;
    
    ChatUserThreads(std::shared_ptr<User> user);
    virtual ~ChatUserThreads();
    
    void SetTokenizationOptions(const TokenizationOptions& options) { mTokenizationOptions = options; }
    void SetUserRepository(std::shared_ptr<UserRepository> repository) { mUserRepository = repository; }
    void SetSettingRepository(std::shared_ptr<SettingRepository> settings);
    void SetBitsConfigRepository(std::shared_ptr<BitsConfigRepository> repository) { mBitsConfigRepository = repository; }
    void SetListener(std::shared_ptr<IChatUserThreadsListener> listener);
    
    // Component overrides
    virtual TTV_ErrorCode Initialize() override;
    virtual void Update() override;
    virtual TTV_ErrorCode Shutdown() override;
    virtual std::string GetLoggerName() const override;
    virtual void OnUserInfoFetchComplete(TTV_ErrorCode ec) override;

    TTV_ErrorCode SendMessageToUser(UserId userId, const std::string& message, WhisperMessage& placeholderMessage, const SendMessageCallback& callback);

    TTV_ErrorCode FetchThreadDataPage(uint32_t offset, uint32_t pageSize, const FetchThreadDataPageCallback& callback);
    TTV_ErrorCode FetchThreadData(const std::string& threadId, const FetchThreadDataCallback& callback);

    TTV_ErrorCode RemoveThread(const std::string& threadId);

    TTV_ErrorCode RemoveThreadWithUser(UserId userId);

    TTV_ErrorCode FetchUnreadCounts(const FetchUnreadCountsCallback& callback);
    
    TTV_ErrorCode FetchChatDisplayInfo();
    
    TTV_ErrorCode FetchEmoteSets();
    
    std::shared_ptr<ChatUserThread> GetThread(const std::string& threadId);

    static std::string GenerateThreadId(UserId a, UserId b);
    
    static std::string GetComponentName() { return "ttv::chat::ChatUserThreads"; }

protected:
    // Component overrides
    virtual bool CheckShutdown() override;
    virtual void CompleteShutdown() override;

private:
    class PubSubTopicListener : public PubSubClient::ITopicListener
    {
    public:
        PubSubTopicListener(ChatUserThreads* owner);

        // PubSubClient::ITopicListener implementation
        virtual void OnTopicSubscribeStateChanged(PubSubClient* source, const std::string& topic, PubSubClient::SubscribeState::Enum state, TTV_ErrorCode ec) override;
        virtual void OnTopicMessageReceived(PubSubClient* source, const std::string& topic, const json::Value& msg) override;
        virtual void OnTopicListenerRemoved(PubSubClient* source, const std::string& topic, TTV_ErrorCode ec) override;

    private:
        ChatUserThreads* mOwner;
    };

    class InternalThreadListener : public ChatUserThread::Listener
    {
    public:
        InternalThreadListener(ChatUserThreads* owner);

        // ChatThread::Listener implementation
        virtual void OnMetadataFetchComplete(ChatUserThread* source, TTV_ErrorCode ec) override;
        virtual void OnRealtimeMessageReceived(ChatUserThread* source, const WhisperMessage& message) override;
        virtual void OnParticipantsUpdated(ChatUserThread* source, const std::vector<ChatUserInfo>& participants) override;
        virtual void OnMuteStatusChanged(ChatUserThread* source, bool muted) override;
        virtual void OnUnreadMessageWindowChanged(ChatUserThread* source, MessageId lastMessageId, MessageId lastReadMessageId) override;

    private:
        ChatUserThreads* mOwner;
    };

    // PubSubClient::ITopicListener implementation
    void OnTopicSubscribeStateChanged(const std::string& topic, PubSubClient::SubscribeState::Enum state, TTV_ErrorCode ec);
    void OnTopicMessageReceived(const std::string& topic, const json::Value& msg);

    // Private ChatThread::Listener implementation
    void OnMetadataFetchComplete(ChatUserThread* source, TTV_ErrorCode ec);
    void OnRealtimeMessageReceived(ChatUserThread* source, const WhisperMessage& message);
    void OnParticipantsUpdated(ChatUserThread* source, const std::vector<ChatUserInfo>& participants);
    void OnMuteStatusChanged(ChatUserThread* source, bool muted);
    void OnUnreadMessageWindowChanged(ChatUserThread* source, MessageId lastMessageId, MessageId lastReadMessageId);

    TTV_ErrorCode SubscribeTopics();
    TTV_ErrorCode SendMessageWithThread(const std::shared_ptr<ChatUserThread>& thread, UserId otherUserId, const std::string& message, const SendMessageCallback& callback);
    void ProcessSentNonce(const std::string& nonce, MessageId messageId, TTV_ErrorCode ec);
    void UpdateCachedThreadWithLiveMessage(const WhisperMessage& message);
    void MergeThreads(const std::vector<ThreadData>& threadList);
    std::shared_ptr<ChatUserThread> CreateThread(const std::string& threadId, const ThreadData* data);
    void BumpThread(const std::string& threadId);
    TTV_ErrorCode SyncCachedThreads();
    TTV_ErrorCode TokenizeLocalMessage(const std::shared_ptr<User>& user, const std::string& message, const std::string& threadId, WhisperMessage& chatMessage);
    TTV_ErrorCode FetchBitsConfig();
    void RequestUnreadCounts();

    std::weak_ptr<UserRepository> mUserRepository;
    std::shared_ptr<SettingRepository> mSettingRepository;
    std::shared_ptr<BitsConfigRepository> mBitsConfigRepository;
    std::shared_ptr<BitsConfiguration> mBitsConfiguration;
    std::map<std::string, std::shared_ptr<ChatUserThread>> mThreadMap; 
    std::vector<std::shared_ptr<ChatUserThread>> mThreadList; 
    std::map<std::string, SendMessageCallback> mPendingSentCallbacksByNonce; 
    std::shared_ptr<ChatGetUnreadMessageCountTask> mChatGetUnreadMessageCountTask;
    std::shared_ptr<ChatGetDisplayInfoTask> mChatGetDisplayInfoTask;
    std::shared_ptr<ChatUserThread::Listener> mInternalThreadListener;
    EventSource<IChatUserThreadsListener> mListeners;

    std::shared_ptr<PagedRequestFetcher> mThreadPageFetcher;

    std::shared_ptr<PubSubClient> mPubSub;
    std::shared_ptr<PubSubTopicListener> mPubSubTopicListener;
    std::shared_ptr<PubSubTopicListenerHelper> mPubSubTopicListenerHelper;
    std::string mWhisperPubSubTopic; 

    ChatUserInfo mChatUserInfo; 

    WaitForExpiry mUnreadSyncTimer; 
    WaitForExpiry mUserChatDisplayFetchTimer; 
    RetryTimer mCachedThreadSyncTimer; 
    RetryTimer mFetchBitsConfigRetryTimer;
    std::unique_ptr<UnreadThreadCache> mUnreadThreadCache;
    CallbackQueue<FetchUnreadCountsCallback> mUnreadCountCallbacks;
    uint32_t mMaxFetchedThreadOffset; 
    TokenizationOptions mTokenizationOptions;
    bool mBitsConfigFetchInFlight;
    bool mHasFetchedBitsConfig;
};