HIVE_Chat.h

Go to the documentation of this file.

 
#ifndef __HIVE_CHAT_H__
#define __HIVE_CHAT_H__
 
#include "HIVE_ResultAPI.h"
#include <cstdint>      // int64_t
#include <functional>   // std::function
#include <map>          // std::map
#include <string>       // std::string
#include <vector>       // std::vector
#include <mutex>
 
 
NS_HIVE_BEGIN
 
class ResultAPI;
enum class ChannelType;
enum class SortType;
class Channel;
class ChannelPage;
class Member;
class BlockMember;
class CreateChannelParams;
class GetChannelsParams;
class EnterChannelParams;
class ChannelSendMessageParams;
class DirectSendMessageParams;
class TranslateParams;
class ChannelListener;
class DirectMessageListener;
class UserListener;
class ConnectionListener;
class ChannelMessage;
class ChannelNoticeMessage;
class DirectMessage;
class EnteredMember;
class ExitedMember;
class DeletedChannel;
class ChannelMessageListQueryParams;
class ChannelMessageListQueryResponse;
class CustomDataListener;
class TranslationData;
 
class HIVESDK_DLLEXPORT Chat {
public:
    // Callback types
    typedef std::function<void(ResultAPI const & result)> onResult;
    typedef std::function<void(ResultAPI const & result)> onCreateChannel;
    typedef std::function<void(ResultAPI const & result)> onDeleteChannel;
    typedef std::function<void(ResultAPI const & result)> onEnterChannel;
    typedef std::function<void(ResultAPI const & result)> onExitChannel;
    typedef std::function<void(ResultAPI const & result)> onBlockMember;
    typedef std::function<void(ResultAPI const & result)> onUnblockMember;
    typedef std::function<void(ResultAPI const & result)> onChannelTranslationSetting;
    typedef std::function<void(ResultAPI const & result)> onConnect;
    typedef std::function<void(ResultAPI const & result)> onDisconnect;
    typedef std::function<void(ResultAPI const & result, std::vector<std::string> const & channelIds, std::vector<std::string> const & failChannelIds)> onReconnect;
    typedef std::function<void(ResultAPI const & result, std::vector<Channel> const & channels, ChannelPage const & channelPage)> onGetChannels;
    typedef std::function<void(ResultAPI const & result, Channel const & channel, std::vector<Member> const & members)> onGetChannelInfo;
    typedef std::function<void(ResultAPI const & result, std::vector<Member> const & members)> onGetChannelMembers;
    typedef std::function<void(ResultAPI const & result, std::vector<Channel> const & channels)> onGetChannelsByUser;
    typedef std::function<void(ResultAPI const & result, std::vector<BlockMember> const & blockMembers)> onGetBlockMembers;
    typedef std::function<void(ResultAPI const & result, ChannelSendMessageParams const & params)> onChannelSendMessage;
    typedef std::function<void(ResultAPI const & result, DirectSendMessageParams const & params)> onDirectSendMessage;
    typedef std::function<void(ResultAPI const & result, ChannelMessageListQueryResponse const & response)> onGetChannelMessageHistory;
    typedef std::function<void(ResultAPI const & result, TranslationData const & translationData)> onTranslate;
    
    // MARK: Channel APIs
    static void createChannel(CreateChannelParams const & params, onCreateChannel listener);
    
    static void getChannels(GetChannelsParams const * params, onGetChannels listener);
    
    static void getChannelInfo(const char * channelId, onGetChannelInfo listener);
    
    static void getChannelMembers(const char * channelId, onGetChannelMembers listener);
    
    static void deleteChannel(const char * channelId, onDeleteChannel listener);
    
    static void enterChannel(EnterChannelParams const & params, onEnterChannel listener);
    
    static void exitChannel(const char * channelId, onExitChannel listener);
    
    // MARK: User APIs
    static void getChannelsByUser(onGetChannelsByUser listener);
    
    static void getBlockMembers(onGetBlockMembers listener);
    
    static void blockMember(int64_t blockPlayerId, onBlockMember listener);
    
    static void unblockMember(int64_t blockPlayerId, onUnblockMember listener);
    
    static void translate(TranslateParams const & params, onTranslate listener);
    
    // MARK: Connection APIs
    static void connect(const char * extraData, onResult listener);
    
    static void connect(onConnect listener);
    
    static void reconnect(onReconnect listener);
    
    static void disconnect(onDisconnect listener);
    
    // MARK: Message APIs
    static void sendMessageWithChannelSendMessageParams(ChannelSendMessageParams const & params);
    
    // MARK: Message APIs
    static void sendMessageWithChannelSendMessageParams(ChannelSendMessageParams const & params, onChannelSendMessage listener);
    
    static void sendMessageWithDirectSendMessageParams(DirectSendMessageParams const & params);
    
    static void sendMessageWithDirectSendMessageParams(DirectSendMessageParams const & params, onDirectSendMessage listener);
    
    // MARK: Listener APIs
    static void addChannelListener(const char * uniqueKey, ChannelListener* listener);
    
    static void addDirectMessageListener(const char * uniqueKey, DirectMessageListener* listener);
    
    static void addUserListener(const char * uniqueKey, UserListener* listener);
    
    static void addConnectionListener(const char * uniqueKey, ConnectionListener* listener);
    
    static void addCustomDataListener(const char * uniqueKey, CustomDataListener* listener);
 
    static void removeChannelListener(const char * uniqueKey);
    
    static void removeDirectMessageListener(const char * uniqueKey);
    
    static void removeUserListener(const char * uniqueKey);
    
    static void removeConnectionListener(const char * uniqueKey);
    
    static void removeCustomDataListener(const char * uniqueKey);
 
    // MARK: Socket Connected APIs
    static bool isConnected();
    
    static void executeEngine(picojson::value jsonParam);
};
 
// MARK: Common
enum class ChannelType {
    UNKNOWN,
    PRIVATE,
    PUBLIC,
    GROUP
};
 
enum class SortType {
    Unknown,
    ChannelId,
    ChannelName,
    RegTime
};
 
class HIVESDK_DLLEXPORT Channel {
public:
    // 채널 ID / Channel ID
    std::string channelId;
    // 채널 타입 / Channel Type
    ChannelType type;
    // 채널 소유자 / Channel Owner
    std::string owner;
    // 채널명 / Channel Name
    std::string channelName;
    // 현재 채널 인원수 / Current Number of People in the Channel
    int memberCount;
    // 채널 최대 인원수 / Maximum Number of People in the Channel
    int maxMemberCount;
    // 채널 생성 시간 / Channel Creation Time
    std::string regTime;
    // 채널 생성 시간 UnixTime / Channel Creation UnixTime
    int64_t regTimeMillis;
    // 채널 메시지 조회 가능 여부 / Channel Message Query Availability
    bool chatHistoryAllowed; 
    
    Channel();
    bool parse(picojson::value const & json);
    picojson::object toJson() const;
    std::string toString() const;
    
    void query(ChannelMessageListQueryParams const & params, Chat::onGetChannelMessageHistory listener) const;
    void setTranslationEnabled(bool enabled, Chat::onChannelTranslationSetting listener) const;
};
 
class HIVESDK_DLLEXPORT ChannelPage {
public:
    // 페이지 크기 / Page Size
    int size;
    // 현재 페이지 / Current Page
    int currentPage;
    // 전체 채널 수 / Total Number of Channels
    int totalElements;
    // 전체 페이지 수 / Total Number of Pages
    int totalPages;
    
    ChannelPage();
    bool parse(picojson::value const & json);
    picojson::object toJson() const;
};
 
class HIVESDK_DLLEXPORT Member {
public:
    // 플레이어 ID / Player ID
    int64_t playerId;
    // 접속 시간 / Connection Time
    std::string connectedTime;
    // 접속 시간 UnixTime / Connection UnixTime
    int64_t connectedTimeMillis;
    
    Member();
    bool parse(picojson::value const & json);
    picojson::object toJson() const;
};
 
class HIVESDK_DLLEXPORT BlockMember {
public:
    // 차단된 사용자 ID / Blocked User ID
    int64_t playerId;
    // 차단 시간 / Blocked Time
    std::string blockedTime;
    // 차단 시간 UnixTime / Blocked UnixTime
    int64_t blockedTimeMillis;
    
    BlockMember();
    bool parse(picojson::value const & json);
    picojson::object toJson() const;
};
 
// MARK: Params
class HIVESDK_DLLEXPORT CreateChannelParams {
public:
    // 채널 ID / Channel ID
    std::string channelId;
    // 비밀번호 / Password
    std::string password;
    // 채널명 / Channel Name
    std::string channelName;
    // 최대 인원수 / Maximum Number of People
    int maxMemberCount;
    // 채널 타입 / Channel Type
    ChannelType type;
    // 채널 메시지 조회 가능 여부 / Channel Message Query Availability
    bool chatHistoryAllowed;
    
    CreateChannelParams();
    picojson::object toJson() const;
    std::string toString() const;
};
 
class HIVESDK_DLLEXPORT GetChannelsParams {
public:
    // 채널 타입 / Channel Type
    ChannelType type;
    // 채널 ID / Channel ID
    std::string channelId;
    // 채널명 / Channel Name
    std::string channelName;
    // 정렬 타입 / Sort Type
    SortType sort;
    // 페이지 순서 (ASC, DESC) / Page Order (ASC, DESC)
    std::string pageOrder;
    // 페이지 크기 / Page Size
    int pageSize;
    // 페이지 번호 / Page Number
    int pageNumber;
    
    GetChannelsParams();
    picojson::object toJson() const;
    std::string toString() const;
};
 
class HIVESDK_DLLEXPORT EnterChannelParams {
public:
    // 채널 ID / Channel ID
    std::string channelId;
    // 비밀번호 / Password
    std::string password;
    
    EnterChannelParams();
    picojson::object toJson() const;
    std::string toString() const;
};
 
class HIVESDK_DLLEXPORT ChannelSendMessageParams {
public:
    // 채널 ID / Channel ID
    std::string channelId;
    // 메시지 / Message
    std::string message;
    // extraData
    std::string extraData;
    
    ChannelSendMessageParams();
    picojson::object toJson() const;
    std::string toString() const;
    bool parse(picojson::value const & json);
};
 
class HIVESDK_DLLEXPORT DirectSendMessageParams {
public:
    // 수신자 플레이어 ID / Receiver Player ID
    int64_t toPlayerId;
    // 메시지 / Message
    std::string message;
    // extraData
    std::string extraData;
    
    DirectSendMessageParams();
    picojson::object toJson() const;
    std::string toString() const;
    bool parse(picojson::value const & json);
};
 
class HIVESDK_DLLEXPORT ChannelMessageListQueryParams {
public:
    // 페이지 당 항목 개수 / Number of Items per Page
    int size;
    // 메시지 index (없을 경우 가장 최신 메시지 조회) / Message Index (If not available, retrieve the most recent message)
    std::string index;
 
    ChannelMessageListQueryParams();
    picojson::object toJson() const;
    std::string toString() const;
};    
 
class HIVESDK_DLLEXPORT TranslateParams {
public:
    std::string message;
    std::string sourceLanguage;
    std::vector<std::string> targetLanguage;
 
    TranslateParams();
    picojson::object toJson() const;
    std::string toString() const;
};
 
// MARK: Listener Message Classes
class HIVESDK_DLLEXPORT EnteredMember {
public:
    // 채널 ID / Channel ID
    std::string channelId;
    // 플레이어 ID / Player ID
    int64_t playerId;
    // 입장 시간 / Join Time
    std::string timestamp;
    // 입장 시간 UnixTime / Join UnixTime
    int64_t timestampMillis;
    
    EnteredMember();
    bool parse(picojson::value const & json);
};
 
class HIVESDK_DLLEXPORT ExitedMember {
public:
    // 채널 ID / Channel ID
    std::string channelId;
    // 플레이어 ID / Player ID
    int64_t playerId;
    // 퇴장 시간 / Exit Time
    std::string timestamp;
    // 입장 시간 UnixTime / Join UnixTime
    int64_t timestampMillis;
    
    ExitedMember();
    bool parse(picojson::value const & json);
};
 
class HIVESDK_DLLEXPORT DeletedChannel {
public:
    // 채널 ID / Channel ID
    std::string channelId;
    // 삭제 시간 / Deletion Time
    std::string timestamp;
    // 입장 시간 UnixTime / Join UnixTime
    int64_t timestampMillis;
    
    DeletedChannel();
    bool parse(picojson::value const & json);
};
 
 
class HIVESDK_DLLEXPORT ChannelNoticeMessage {
public:
    // 채널 ID / Channel ID
    std::string channelId;
    // 발신자 / Sender
    std::string from;
    // 메시지 / Message
    std::string message;
    // 메시지 전송 시간 / Message Send Time
    std::string timestamp;
    // 입장 시간 UnixTime / Join UnixTime
    int64_t timestampMillis;
    
    ChannelNoticeMessage();
    bool parse(picojson::value const & json);
};
 
class HIVESDK_DLLEXPORT ChannelMessage {
public:
    // 발신자 / Sender
    int64_t from;
    // 발신자 추가 데이터 (닉네임 등) / Sender Additional Data (Nickname, etc
    std::string extraData;
    // 수신받은 채널 / Received Channel
    std::string to;
    // 메시지 / Message
    std::string message;
    // 메시지 전송 시간 / Message Send Time
    std::string timestamp;
    // 입장 시간 UnixTime / Join UnixTime
    int64_t timestampMillis;
    // 번역여부 / is Translated
    bool translated;
    // 번역 메시지 / Translated Message
    std::string translatedMessage;
    
    
    ChannelMessage();
    bool parse(picojson::value const & json);
};
 
class HIVESDK_DLLEXPORT DirectMessage {
public:
    // 발신자 / Sender
    int64_t from;
    // 발신자 추가 데이터 (닉네임 등) / Sender Additional Data (Nickname, etc.)
    std::string extraData;
    // 수신자 / Receiver
    int64_t to;
    // 메시지
    std::string message;
    // 메시지 전송 시간 / Message Send Time
    std::string timestamp;
    // 입장 시간 UnixTime / Join UnixTime
    int64_t timestampMillis;
    
    DirectMessage();
    bool parse(picojson::value const & json);
};
 
class HIVESDK_DLLEXPORT NoticeMessage {
public:
    // 발신자 / Sender
    std::string from;
    // 메시지
    std::string message;
    // 메시지 전송 시간 / Message Send Time
    std::string timestamp;
    // 메시지 전송 시간 / Message Send Time (unix time)
    int64_t timestampMillis;
 
    NoticeMessage();
    bool parse(picojson::value const & json);
};
 
class HIVESDK_DLLEXPORT ChannelMessageListQueryResponse {
public:
    bool hasNext;
    std::string nextIndex;
    std::vector<ChannelMessage> messages;
 
    ChannelMessageListQueryResponse();
    bool parse(picojson::value const & json);
};
 
class HIVESDK_DLLEXPORT TranslationData {
public:
    map<std::string, std::string> translations;
 
    TranslationData();
    bool parse(picojson::value const & json);
};
    
// MARK: Listener Classes
class HIVESDK_DLLEXPORT ChannelListener {
public:
    // 채널 입장시 호출 / Called when a member enters the channel
    virtual void onEnteredMember(EnteredMember const & member) = 0;
    // 채널 퇴장시 호출 / Called when a member exits the channel
    virtual void onExitedMember(ExitedMember const & member) = 0;
    // 채널 삭제시 호출 / Called when a channel is deleted
    virtual void onDeletedChannel(DeletedChannel const & channel) = 0;
    // 채널 공지 메시지 수신시 호출 / Called when a channel notice message is received
    virtual void onNoticeMessage(ChannelNoticeMessage const & message) = 0;
    // 채널 메시지 수신시 호출 / Called when a channel message is received
    virtual void onChannelMessage(ChannelMessage const & message) = 0;
    
    virtual ~ChannelListener()  = default;
};
 
class HIVESDK_DLLEXPORT DirectMessageListener {
public:
    // 1:1 메시지 수신시 호출 / Called when a 1:1 message is received
    virtual void onDirectMessage(DirectMessage const & message) = 0;
};
 
class HIVESDK_DLLEXPORT UserListener {
public:
    // 1:1 메시지 수신시 호출 / Called when a 1:1 message is received
    virtual void onDirectMessage(DirectMessage const & message) = 0;
    // 개인 공지 메시지 수신 시 호출 / Called when a personal notice message is received
    virtual void onNoticeMessage(NoticeMessage const & message) = 0;
 
    virtual ~UserListener() = default;
};
 
class HIVESDK_DLLEXPORT ConnectionListener {
public:
    // 채팅서버 연결시 호출 / Called when connected to the Chat Server
    virtual void onConnected() = 0;
    // 채팅서버 재연결 시작 시 호출 / Called when reconnection to the Chat Server starts
    virtual void onReconnectStarted() = 0;
    // 채팅서버 재연결시 호출 / Called when reconnected to the Chat Server 
    virtual void onReconnected(ResultAPI const & result, std::vector<std::string> const & channelIds, std::vector<std::string> const & failChannelIds) = 0;
    // 채팅서버 연결 해제시 호출 / Called when disconnected from the Chat Server
    virtual void onDisconnected() = 0;
    
    virtual ~ConnectionListener() = default;
};
 
class HIVESDK_DLLEXPORT CustomDataListener {
public:
    // 커스텀 데이터 수신시 호출 / Called when a custom data is received
    virtual void onCustomData(std::string const & data) = 0;
 
    virtual ~CustomDataListener() = default;
};
 
class HIVESDK_DLLEXPORT Unique64 {
public:
 
    static Unique64& getInstance();
    std::string generateKey();
private:
    std::mutex mutex_;
    uint64_t last_timestamp_ms_;
    uint16_t sequence_;
    
    static const uint16_t MAX_SEQUENCE = 0xFFFF;
 
    Unique64();
    uint64_t getCurrentTimestampMs();
    uint64_t waitUntilNextMillisecond(uint64_t current_ts_ms_ref);
};
 
template<typename Key, typename Value>
class ThreadSafeMap {
private:
    std::map<Key, Value> map_;
    mutable std::mutex mutex_;
    
public:
    ThreadSafeMap() = default;
    ThreadSafeMap(const ThreadSafeMap&) = delete;
    ThreadSafeMap& operator=(const ThreadSafeMap&) = delete;
    void insert(const Key& key, const Value& value);
    Value get(const Key& key) const;
    bool contains(const Key& key) const;
    size_t erase(const Key& key);
};
 
NS_HIVE_END
 
#endif // __HIVE_CHAT_H__