Sendbird.h

// Copyright (c) 2021 Sendbird, Inc. All rights reserved.
 
#ifndef SENDBIRD_SENDBIRD_H_
#define SENDBIRD_SENDBIRD_H_
 
#include "SBDAdminMessage.h"
#include "SBDBaseChannel.h"
#include "SBDBaseInterface.h"
#include "SBDBaseMessage.h"
#include "SBDError.h"
#include "SBDFileMessage.h"
#include "SBDFileMessageParams.h"
#include "SBDGroupChannel.h"
#include "SBDGroupChannelListQuery.h"
#include "SBDGroupChannelParams.h"
#include "SBDGroupChannelTotalUnreadMessageCountParams.h"
#include "SBDMember.h"
#include "SBDMessageMetaArray.h"
#include "SBDOpenChannel.h"
#include "SBDOpenChannelListQuery.h"
#include "SBDOpenChannelParams.h"
#include "SBDOperatorListQuery.h"
#include "SBDPreviousMessageListQuery.h"
#include "SBDReadStatus.h"
#include "SBDTypes.h"
#include "SBDUser.h"
#include "SBDUserListQuery.h"
#include "SBDUserMessage.h"
#include "SBDUserMessageParams.h"
 
#include <string>
#include <sstream>
#include <ctime>
#include <map>
#include <cstdio>
#include <memory>
#include <mutex>
#include <condition_variable>
#include <codecvt>
#include <exception>
 
#define SBD_NULL_STRING "SBD_NULL_STRING_f2648f84e7e941208c8d9df02230a7c8"
#define SBD_NULL_WSTRING L"SBD_NULL_STRING_f2648f84e7e941208c8d9df02230a7c8"
#define IsNullString(str) (((str).compare(SBD_NULL_STRING)) == 0)
#define IsNullWString(str) (((str).compare(SBD_NULL_WSTRING)) == 0)
 
class SBDWebSocketClient;
class SBDLoginTimerHandler;
class SBDUpdateUserInfoWithBinaryFileRequestHandler;
class SBDWebSocketSendCommandHandler;
class SBDReconnectTimerHandler;
class SBDTypingStatusTimerHandler;
class SBDAckTimerHandler;
class SBDUnReadMessageCount;
class FSBDMain;
class SBDThreadManager;
 
class SBDOption final {
public:
    static bool use_member_as_message_sender;
};
 
class SBDConnectionHandler {
public:
    virtual void Started() {};
    virtual void Succeeded() {};
    virtual void Failed() {};
};
 
class SBDUserEventHandler {
public:
 
    virtual void TotalUnreadMessageCountChanged(int total_count, std::map<std::wstring, int> total_count_by_custom_type) {}
};
 
class SBDMain final {
public:
    static std::wstring GetApplicationId();
 
    static std::wstring GetSdkVersion();
 
    static bool IsInitialized();
 
    static void Init(std::wstring application_id);
 
    static SBDConnectionState GetConnectionState();
 
    static void AddConnectionHandler(std::wstring identifier, SBDConnectionHandler* handler);
 
    static void RemoveConnectionHandler(std::wstring identifier);
 
    static void RemoveAllConnectionHandlers();
 
    static void AddUserEventHandler(std::wstring identifier, SBDUserEventHandler* handler);
 
    static void RemoveUserEventHandler(std::wstring identifier);
 
    static void RemoveAllUserEventHandlers();
 
    static void AddChannelHandler(std::wstring identifier, SBDChannelHandler* handler);
 
    static void RemoveChannelHandler(std::wstring identifier);
 
    static void RemoveAllChannelHandlers();
 
    static void Connect(std::wstring user_id, std::wstring access_token, std::function<void(SBDUser*, SBDError*)> completion_handler);
 
    static void Disconnect(std::function<void()> completion_handler);
 
    static SBDUser* GetCurrentUser();
 
    static void UpdateCurrentUserInfo(std::wstring nickname, std::wstring profile_url, std::function<void(SBDError*)> completion_handler);
 
    static void UpdateCurrentUserInfoWithBinaryProfileImage(std::wstring nickname, std::wstring profile_image_file_path, std::wstring mime_type,
        std::function<void(SBDError*)> completion_handler);
 
    static SBDUserListQuery* CreateAllUserListQuery();
 
    static SBDUserListQuery* CreateUserListQuery(std::vector<std::wstring> user_ids);
 
    static SBDUserListQuery* CreateBlockedUserListQuery();
 
    static void BlockUser(const SBDUser& user, std::function<void(SBDUser* blocked_user, SBDError*)> completion_handler);
 
    static void UnblockUser(const SBDUser& user, std::function<void(SBDError*)> completion_handler);
 
    static bool Reconnect();
 
    static void SetChannelInvitationPreference(bool auto_accept, std::function<void(SBDError*)> completion_handler);
 
    static void GetChannelInvitationPreference(std::function<void(bool is_auto_accept, SBDError*)> completion_handler);
 
    static void GetTotalUnreadChannelCount(std::function<void(int total_unread_channel_count, SBDError*)> completion_handler);
 
    static void GetTotalUnreadMessageCount(SBDGroupChannelTotalUnreadMessageCountParams& params, std::function<void(int total_unread_message_count, SBDError*)> completion_handler);
 
    static int GetSubscribedTotalUnreadMessageCount();
 
    static int GetSubscribedCustomTypeTotalUnreadMessageCount();
 
    static int GetSubscribedCustomTypeUnreadMessageCount(std::wstring custom_type);
 
    static void RegisterPushTokenForCurrentUser(SBDPushTokenType type, std::wstring token, bool unique, std::function<void(SBDPushTokenRegistrationStatus, SBDError*)> completion_handler);
 
    static std::wstring GetPendingPushToken();
 
    static void UnregisterPushTokenForCurrentUser(SBDPushTokenType type, std::wstring token, std::function<void(SBDError*)> completion_handler);
 
    static void UnregisterPushTokenAllForCurrentUser(std::function<void(SBDError*)> completion_handler);
 
private:
    std::wstring application_id;
    SBDUser current_user;
    std::mutex current_user_mutex;
 
    std::map<std::wstring, SBDConnectionHandler*> reconnection_handlers;
    std::mutex reconnection_handlers_mutex;
    std::map<std::wstring, SBDUserEventHandler*> user_event_handlers;
    std::mutex user_event_handlers_mutex;
    std::map<std::wstring, SBDChannelHandler*> channel_handlers;
    std::mutex channel_handlers_mutex;
 
    std::unique_ptr<SBDWebSocketClient> websocket_client;
    std::mutex websocket_client_mutex;
 
    std::mutex reconnect_in_progress_mutex;
    bool reconnect_in_progress;
    SBDReconnectTimerHandler* reconnect_timer = nullptr;
    std::mutex reconnect_timer_mutex;
 
    SBDTypingStatusTimerHandler* typing_status_timer = nullptr;
    std::mutex typing_status_timer_mutex;
 
    bool session_opened;
    bool has_current_user;
 
    std::vector<std::unique_ptr<SBDUserListQuery>> user_list_queries;
    std::vector<std::unique_ptr<SBDUpdateUserInfoWithBinaryFileRequestHandler>> update_user_info_with_binary_file_request_handlers;
 
    SBDLoginTimerHandler* login_timer = nullptr;
    std::mutex login_timer_mutex;
 
    unsigned long reconnect_delay;
    uint8_t reconnect_count;
    std::map<std::string, SBDAckTimerHandler*> ack_timer_map;
    std::mutex ack_timer_map_mutex;
 
    std::vector<std::function<void(SBDUser*, SBDError*)>> connect_callbacks;
    std::mutex connect_callbacks_mutex;
    std::wstring connecting_user_id;
 
    std::vector<std::function<void()>> disconnect_callbacks;
    std::mutex disconnect_callbacks_mutex;
    bool is_disconnecting;
 
    std::unique_ptr<SBDUnReadMessageCount> un_read_message_count;
    std::unique_ptr<SBDThreadManager> thread_manager; // FEATURE_THREAD_MANAGER
 
    std::wstring pending_push_token;
 
private:
    SBDMain();
    SBDMain(SBDMain const&) = delete;
    void operator=(SBDMain const&) = delete;
    void ReceiveMessage(std::string message, bool reconnect);
    void Send(SBDCommand* command, std::function<void(SBDCommand*, SBDError*)> completion_handler);
    static SBDMain& GetInstance();
    static void Disconnect(bool logout, bool from_disconnect, std::function<void()> completion_handler);
    static void ClearUserData();
    static void ClearLocalData();
 
    static SBDConnectionHandler* GetReconnectionHandler(std::wstring identifier);
    static SBDChannelHandler* GetChannelHandler(std::wstring identifier);
    static std::map<std::wstring, SBDConnectionHandler*> GetReconnectionHandlers();
    static std::map<std::wstring, SBDUserEventHandler*> GetUserEventHandlers();
    static std::map<std::wstring, SBDChannelHandler*> GetChannelHandlers();
 
    static void ClearCurrentUser();
    static void ProcessSubscribedUnreadMessageCount(SBDCommand* command);
    static void ClearUnreadCount();
    static void Reconnect(unsigned long timeout);
    static void ConnectToWebSocketServer(bool reconnect,
        std::wstring user_id, std::wstring access_token, std::string session_key,
        std::function<void(SBDUser*, SBDError*)> connect_callback);
    static void SetHosts(std::wstring api_host, std::wstring ws_host);
    static std::wstring GetApiServer();
    static std::wstring GetCustomApiServer();
    static std::wstring GetApiHostScheme();
    static std::wstring GetApiHost();
    static int GetApiPort();
    static std::wstring GetWsServer();
    static std::wstring GetCustomWsServer();
    static std::wstring GetWsHostScheme();
    static std::wstring GetWsHost();
    static int GetWsPort();
    static SBDWebSocketClient* GetWebSocket();
    static bool HasCurrentUser();
    static std::wstring GetCurrentUserId();
    static void SetCurrentUser(const SBDUser& user);
 
    static void StartAckTimer(SBDCommand* command, std::function<void(SBDCommand*, SBDError*)> command_completion_handler);
    static void RunAckTimerCallback(SBDCommand* command, SBDError* error);
    static void StopAckTimer(SBDCommand* command);
    static std::map<std::string, SBDAckTimerHandler*>& GetAckTimerMap();
    static std::mutex& GetAckTimerMapMutex();
    static void InvalidateAckTimers();
    static void ProcessAckTimersToErrors();
    static void StartLoginTimer(std::wstring user_id, std::function<void(SBDUser*, SBDError*)> completion_handler);
    static void StopLoginTimer();
 
    static void IncreaseReconnectCount();
    static void ResetReconnectCount();
    static uint8_t GetReconnectCount();
    static unsigned long GetReconnectDelay();
    static void IncreaseReconnectDelay();
    static void ResetReconnectDelay();
    static void SetReconnectionProgress(bool is_in_progress);
    static bool GetReconnectionProgress();
    static void SetReconnectTimer(unsigned long time_interval);
    static void StopReconnectTimer();
 
    static void Connect(std::wstring user_id, std::wstring access_token, std::wstring api_host, std::wstring ws_host,
        std::function<void(SBDUser*, SBDError*)> completion_handler);
    static void ProcessConnectCallbacks(SBDUser* user, SBDError* error);
    static void ProcessDisconnectCallbacks(bool logout);
    static std::wstring GetPlatformName();
    static std::wstring GetPlatformVersion();
    static std::wstring GetDeviceOsName();
    static std::wstring GetDeviceOsVersion();
    static SBDThreadManager* GetThreadManager();
 
    friend FSBDMain;
};
 
#endif /* SENDBIRD_SENDBIRD_H_ */