chatuserthread.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/chattypes.h"
#include "twitchsdk/core/eventsource.h"
#include "twitchsdk/core/component.h"
#include "twitchsdk/core/timer.h"
#include <string>
#include <vector>
#include <unordered_set>
#include <map>
#include <memory>

namespace ttv
{
    class TaskRunner;
    class Task;
    class User;

    namespace chat
    {
        class ChatUserThreads;
        class ChatUserThread;
        class ChatGetUserThreadsTask;
    }
}


class ttv::chat::ChatUserThread : public UserComponent
{
public:
    class Listener
    {
    public:
        virtual void OnMetadataFetchComplete(ChatUserThread* source, TTV_ErrorCode ec) = 0;
                
        virtual void OnRealtimeMessageReceived(ChatUserThread* source, const WhisperMessage& messageList) = 0;
        
        virtual void OnParticipantsUpdated(ChatUserThread* source, const std::vector<ChatUserInfo>& participants) = 0;
        
        virtual void OnMuteStatusChanged(ChatUserThread *source, bool muted) = 0;
        
        virtual void OnUnreadMessageWindowChanged(ChatUserThread* source, MessageId lastMessageId, MessageId lastReadMessageId) = 0;
    };

public:
    using FetchMessagesCallback = std::function<void(TTV_ErrorCode ec, const std::vector<WhisperMessage>& messages)>;
    using SetMutedCallback = std::function<void(TTV_ErrorCode ec)>;
    using SetArchivedCallback = std::function<void(TTV_ErrorCode ec)>;
    using SetLastMessageReadIdCallback = std::function<void(TTV_ErrorCode ec)>;
    
    ChatUserThread(const std::string& threadId, const std::shared_ptr<User>& user, const ThreadData& data);
    ChatUserThread(const std::string& threadId, const std::shared_ptr<User>& user);
    virtual ~ChatUserThread();

    std::string GetId() const { return mThreadId; }

    void SetTokenizationOptions(const TokenizationOptions& tokenizationOptions) { mTokenizationOptions = tokenizationOptions; }
    void SetBitsConfiguration(std::shared_ptr<BitsConfiguration> bitsConfiguration) { mBitsConfiguration = bitsConfiguration; }

    bool GetPlaceholder() const { return mPlaceholder; }
    bool GetFetchFailed() const { return mFetchMetadataFailed; }
    void SetFailedSend(bool failed) { mFailedSend = failed; }
    bool GetFailedSend() const { return mFailedSend; }

    void AddListener(std::shared_ptr<Listener> listener);
    void RemoveListener(std::shared_ptr<Listener> listener);

    // IComponent implementation
    virtual void Update() override;
    virtual std::string GetLoggerName() const override;

    void UpdateMetadata(const ThreadData& thread);
    
    TTV_ErrorCode FetchMessages(MessageId start, uint32_t beforeCount, const FetchMessagesCallback& callback);

    void AddRealtimeMessage(const WhisperMessage& message);

    void GetMetadata(ThreadData& thread) const;

    bool GetLocalParticipant(ChatUserInfo& userInfo) const;

    const std::vector<ChatUserInfo>& GetParticipants() { return mParticipants; }
    Timestamp GetLastUpdateTimestamp() const { return mLastUpdateTimestamp; }
    MessageId GetLastMessageId() const { return mLastMessageId; }
    MessageId GetLastReadMessageId() const { return mLastReadMessageId; }

    TTV_ErrorCode SetMuted(bool muted, const SetMutedCallback& callback);
    TTV_ErrorCode SetArchived(bool archived, const SetMutedCallback& callback);
    TTV_ErrorCode SetLastMessageReadId(MessageId id, const SetLastMessageReadIdCallback& callback);

    void SetUnreadMessageWindow(MessageId lastMessageId, MessageId lastReadMessageId);

private:
    ChatUserThread(const std::string& threadId, const std::shared_ptr<User>& user, bool placeholder);

    void BumpLastMessage(const WhisperMessage& message);
    void UpdateParticipants(const WhisperMessage& message);
    void ScheduleFetch();
    TTV_ErrorCode FetchMetadata();

    // Component overrides
    virtual void CompleteShutdown() override;

    EventSource<Listener> mListeners;
    std::shared_ptr<BitsConfiguration> mBitsConfiguration;
    
    std::shared_ptr<WhisperMessage> mLastMessage;
    std::vector<ChatUserInfo> mParticipants;

    std::string mThreadId;
    WaitForExpiry mMetadataFetchTimer;

    MessageId mLastMessageId;
    MessageId mLastReadMessageId;
    Timestamp mLastUpdateTimestamp;
    Timestamp mLastFetchedTimestamp;
    
    TokenizationOptions mTokenizationOptions;
    
    bool mMuted;
    bool mArchived;
    bool mParticipantsUpdated;
    bool mLastMessageUpdated;
    bool mUnreadMessageWindowUpdate;
    bool mPlaceholder;
    bool mFetchMetadataFailed;
    bool mFailedSend;
};