chatuserblocklist.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/types/coretypes.h"
#include "twitchsdk/core/types/errortypes.h"
#include "twitchsdk/core/component.h"
#include "twitchsdk/chat/internal/chathelpers.h"
#include "twitchsdk/chat/internal/task/chatgetblocklisttask.h"

#include <unordered_set>


namespace ttv
{
    class TaskRunner;
    class User;
    class UserRepository;

    namespace chat
    {
        class ChatUserBlockList;
        class UserBlockListListenerProxy;
        class ChatChangeUserBlockTask;
    }
}


class ttv::chat::ChatUserBlockList : public ttv::UserComponent
{
public:
    using BlockChangeCallback = std::function<void(TTV_ErrorCode ec)>;
    using FetchBlockedUsersCallback = std::function<void(TTV_ErrorCode ec, const std::vector<UserInfo>& blockedUsers)>;

    ChatUserBlockList(std::shared_ptr<User> user);
    virtual ~ChatUserBlockList();
    
    TTV_ErrorCode UpdateList();

    TTV_ErrorCode BlockUser(UserId userId, const std::string& reason, bool whisper, const BlockChangeCallback& = nullptr);
    TTV_ErrorCode BlockUser(const std::string& userName, const std::string& reason, bool whisper, const BlockChangeCallback& = nullptr);
    TTV_ErrorCode UnblockUser(UserId userId, const BlockChangeCallback& = nullptr);
    TTV_ErrorCode UnblockUser(const std::string& userName, const BlockChangeCallback& = nullptr);
    TTV_ErrorCode FetchBlockedUsers(const FetchBlockedUsersCallback& callback = nullptr);

    bool IsUserBlocked(UserId userId);
    void GetBlockedUsers(std::unordered_set<UserId>& result) const;

    void SetRefreshInterval(uint64_t milliseconds);
    uint64_t GetRefreshInterval() const { return mRefreshIntervalMilliseconds; }

    std::shared_ptr<User> GetUser() { return mUser.lock(); }

    static std::string GetComponentName() { return "ttv::chat::ChatUserBlockList"; }

    // Component overrides
    virtual void Update() override;
    virtual TTV_ErrorCode Shutdown() override;

    // UserComponent overrides
    virtual std::string GetLoggerName() const override;

private:
    typedef std::shared_ptr< std::unordered_set<UserId> > SetReference;

    // Component overrides
    virtual bool CheckShutdown() override;

    bool IsRefreshInProgress() const;
    void FetchPage(uint offset, uint limit);
    void RefreshComplete(TTV_ErrorCode ec);
    void CancelRequestsForUser(UserId blockUserId);
    void ScheduleRequest(UserId blockUserId, bool block, const std::string& reason, bool whisper, const BlockChangeCallback& callback);
    void ProcessNextRequest();
    void SetLocalValue(SetReference set, UserId blockUserId, bool block);

    struct ChangeRequest
    {
        std::string reason;
        BlockChangeCallback callback;
        UserId userId;
        bool block;
        bool whisper;
    };
    
    std::weak_ptr<UserRepository> mUserRepository;
    SetReference mBlockedUsers; 
    SetReference mRefreshUsers; 
    std::vector<UserInfo> mUserInfoList; 
    std::vector<ChangeRequest> mQueuedChanges; 
    CallbackQueue<FetchBlockedUsersCallback> mBlockedUsersCallbacks;
    std::shared_ptr<ChatChangeUserBlockTask> mRunningChangeTask;
    std::shared_ptr<ChatGetBlockListTask> mRunningGetListTask;
    std::shared_ptr<ChatGetBlockListTask::Result> mRefreshResult;
    WaitForExpiry mRefreshTimer;
    uint64_t mRefreshIntervalMilliseconds;
};