SBDGroupChannel.h

// Copyright (c) 2021 Sendbird, Inc. All rights reserved.
 
#ifndef SENDBIRD_SBDGROUPCHANNEL_H_
#define SENDBIRD_SBDGROUPCHANNEL_H_
 
#include "SBDBaseChannel.h"
#include "SBDBaseMessage.h"
#include "SBDUser.h"
#include "SBDError.h"
#include "SBDReadStatus.h"
#include "SBDMember.h"
#include "SBDGroupChannelListQuery.h"
#include "SBDGroupChannelParams.h"
 
class SBDUser;
class SBDGroupChannel;
class SBDGroupChannelListQuery;
class FSBDGroupChannel;
 
class SBDGroupChannel final : public SBDBaseChannel {
public:
    int64_t last_message_id;
 
    bool is_distinct;
 
    bool is_public;
 
    uint64_t unread_message_count;
 
    std::vector<SBDMember> members;
 
    uint64_t member_count;
 
    SBDUser inviter;
 
    bool has_inviter;
 
    bool is_hidden;
 
    SBDGroupChannelHiddenState hidden_state;
 
    static void CreateChannel(std::vector<std::wstring> user_ids, const std::wstring& name, bool is_distinct, const std::wstring& cover_url,
        const std::wstring& data, const std::wstring& custom_type, std::function<void(SBDGroupChannel*, SBDError*)> completion_handler);
 
    static void CreateChannel(const std::vector<std::wstring> user_ids, const std::wstring& name, bool is_distinct, const std::wstring& cover_image_file_path,
        const std::wstring& file_mime_type, const std::wstring& data, const std::wstring& custom_type,
        std::function<void(SBDGroupChannel*, SBDError*)> completion_handler);
 
    static void CreateChannel(SBDGroupChannelParams& params, std::function<void(SBDGroupChannel*, SBDError*)> completion_handler);
 
    void UpdateChannel(const std::wstring& name, bool is_distinct, const std::wstring& cover_url, const std::wstring& data, const std::wstring& custom_type,
        std::function<void(SBDGroupChannel*, SBDError*)> completion_handler);
 
    void UpdateChannel(const std::wstring& name, bool is_distinct, const std::wstring& cover_image_file_path, const std::wstring& file_mime_type,
        const std::wstring& data, const std::wstring& custom_type, std::function<void(SBDGroupChannel*, SBDError*)> completion_handler);
 
    void DeleteChannel(std::function<void(SBDError*)> completion_handler);
 
    void RefreshChannel(std::function<void(SBDError*)> completion_handler);
 
    static SBDGroupChannelListQuery* CreateMyGroupChannelListQuery();
 
    static void GetChannelFromServer(const std::wstring& channel_url, std::function<void(SBDGroupChannel*, SBDError*)> completion_handler);
 
    static void GetChannel(const std::wstring& channel_url, std::function<void(SBDGroupChannel*, SBDError*)> completion_handler);
 
    void InviteUsers(const std::vector<SBDUser>& users, std::function<void(SBDError*)> completion_handler);
 
    void HideChannel(bool hide_prev_messages, std::function<void(SBDError*)> completion_handler);
 
    void HideChannel(bool hide_prev_messages, bool allow_auto_unhide, std::function<void(SBDError*)> completion_handler);
 
    void UnhideChannel(std::function<void(SBDError*)> completion_handler);
 
    void JoinChannel(std::function<void(SBDError*)> completion_handler);
 
    void LeaveChannel(std::function<void(SBDError*)> completion_handler);
 
    static void MarkAllAsRead(std::function<void(SBDError*)> completion_handler);
 
    void MarkAsRead();
 
    int GetReadReceipt(SBDBaseMessage* message);
 
    int64_t GetLastSeenAt(const SBDUser& user);
 
    std::vector<SBDMember> GetReadMembers(SBDBaseMessage* message);
 
    std::vector<SBDMember> GetUnreadMembers(SBDBaseMessage* message);
 
    std::map<std::wstring, SBDReadStatus> GetReadStatus();
 
    bool HasMember(const std::wstring& user_id);
 
    SBDMember GetMember(const std::wstring& user_id, bool* member_exist);
 
    void AcceptInvitation(std::function<void(SBDError*)> completion_handler);
 
    void DeclineInvitation(std::function<void(SBDError*)> completion_handler);
 
    void ResetMyHistory(std::function<void(SBDError*)> completion_handler);
 
    static void GetChannelCount(SBDMemberStateFilter member_state_filter,
        std::function<void(uint64_t group_chanel_count, SBDError* error)> completion_handler);
 
    const SBDBaseMessage* GetLastMessage();
 
private:
    int64_t last_start_typing_ts;
    int64_t last_end_typing_ts;
    int64_t last_manual_mark_as_read_ts;
    std::map<std::wstring, SBDMember> member_map;
    static std::mutex member_mutex;
    std::map<std::wstring, int64_t> cached_read_receipt_status;
    std::map<std::wstring, int64_t> cached_typing_status;
    static std::vector<std::unique_ptr<SBDGroupChannelListQuery>> group_channel_list_queries;
    bool has_been_updated;
 
    SBDGroupChannel(const std::string& dict);
    static SBDGroupChannel* Upsert(SBDGroupChannel* channel);
    void Overwrite(SBDGroupChannel* channel);
    void UpdateTypingStatus(const SBDUser& user, bool start);
    void AddMember(SBDMember user);
    void RemoveMember(SBDMember user);
    void TypingStatusTimeout();
    void UpdateReadReceipt(const std::wstring& user_id, int64_t timestamp);
    void SetChannelHiddenState(SBDGroupChannelHiddenState hidden_state);
    void UpdateMyReadReceipt(int64_t ts);
    static std::map<std::wstring, std::unique_ptr<SBDGroupChannel>> cached_channels;
    static std::mutex cached_channel_mutex;
    static int64_t last_mark_all_as_read_ts;
    static SBDGroupChannel* BuildAndUpsert(std::string dict);
    static void UpdateTypingStatus();
    static void ClearCache();
    static void RemoveChannelFromCache(const std::wstring& channel_url);
    static SBDGroupChannel* GetChannelFromCache(const std::wstring& channel_url);
    static bool HasChannelInCache(const std::wstring& channel_url);
    static void LocalGetChannel(bool from_local, const std::wstring& channel_url, std::function<void(SBDGroupChannel*, SBDError*)> completion_handler);
 
    void StartTyping();
    void EndTyping();
    bool IsTyping();
    std::vector<SBDMember> GetTypingMembers();
 
    friend FSBDGroupChannel;
};
 
#endif /* SENDBIRD_SBDGROUPCHANNEL_H_ */