v4_api_reference/CPP/_h_i_v_e___chat_8h_source.html

#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__

HIVE_ResultAPI.h

BlockMember
차단된 사용자 정보
Definition: HIVE_Chat.h:734

Channel
채팅 채널 정보
Definition: HIVE_Chat.h:659

ChannelListener
채널 이벤트 리스너
Definition: HIVE_Chat.h:1075

ChannelMessage
채널 메시지 정보
Definition: HIVE_Chat.h:973

ChannelMessageListQueryParams
채널 대화 이력 조회 파라미터
Definition: HIVE_Chat.h:863

ChannelMessageListQueryResponse
채널 대화 이력 정보
Definition: HIVE_Chat.h:1046

ChannelNoticeMessage
채널 공지 메시지 정보
Definition: HIVE_Chat.h:951

ChannelPage
채널 조회 페이지 정보
Definition: HIVE_Chat.h:694

ChannelSendMessageParams
채널 메시지 전송 파라미터
Definition: HIVE_Chat.h:823

Chat
HiveChat은 실시간, 그룹, 1:1 채팅, 유저 간 차단 기능 등 게임에서 원활한 채팅을 할 수 있도록 필요한 핵심 기능을 제공하기 때문에 유저 간 협력을 증가시켜 게임 플레이...
Definition: HIVE_Chat.h:72

ConnectionListener
연결 리스너
Definition: HIVE_Chat.h:1123

CreateChannelParams
채널 생성 파라미터
Definition: HIVE_Chat.h:754

CustomDataListener
커스텀 데이터 리스너
Definition: HIVE_Chat.h:1142

DeletedChannel
삭제된 채널 정보
Definition: HIVE_Chat.h:932

DirectMessage
1:1 메시지 정보
Definition: HIVE_Chat.h:1002

DirectMessageListener
1:1 메시지 리스너
Definition: HIVE_Chat.h:1097

DirectSendMessageParams
1:1 메시지 전송 파라미터
Definition: HIVE_Chat.h:843

EnterChannelParams
채널 입장 파라미터
Definition: HIVE_Chat.h:806

EnteredMember
입장 멤버 정보
Definition: HIVE_Chat.h:892

ExitedMember
퇴장 멤버 정보
Definition: HIVE_Chat.h:912

GetChannelsParams
채널 목록 조회 파라미터
Definition: HIVE_Chat.h:779

Member
채널 멤버 정보
Definition: HIVE_Chat.h:715

NoticeMessage
유저 대상 공지 메시지 정보
Definition: HIVE_Chat.h:1026

ResultAPI
Definition: HIVE_ResultAPI.h:64

TranslationData
메시지 번역 결과
Definition: HIVE_Chat.h:1061

UserListener
유저 이벤트 리스너
Definition: HIVE_Chat.h:1108

Chat::removeCustomDataListener
static void removeCustomDataListener(const char *uniqueKey)
커스텀 데이터 리스너 제거

Chat::removeChannelListener
static void removeChannelListener(const char *uniqueKey)
채널 리스너 제거  등록된 채널 리스너를 제거합니다.

Chat::addConnectionListener
static void addConnectionListener(const char *uniqueKey, ConnectionListener *listener)
연결 리스너 등록  채팅서버 연결 상태를 수신하기 위한 리스너를 등록합니다.

Chat::sendMessageWithDirectSendMessageParams
static void sendMessageWithDirectSendMessageParams(DirectSendMessageParams const &params)
1:1 메시지 전송  수신자 ID와 메시지를 입력받아, 해당 사용자에게 메시지를 전송합니다.

ChannelType
ChannelType
채팅 채널 타입 정보
Definition: HIVE_Chat.h:635

Chat::addChannelListener
static void addChannelListener(const char *uniqueKey, ChannelListener *listener)
채널 리스너 등록  채널 이벤트를 수신하기 위한 리스너를 등록합니다.

Chat::addUserListener
static void addUserListener(const char *uniqueKey, UserListener *listener)
유저 리스너 등록  유저 이벤트를 수신하기 위한 리스너를 등록합니다.

Chat::disconnect
static void disconnect(onDisconnect listener)
채팅서버 연결 해제  채팅서버와의 연결을 해제합니다.

Chat::getChannelMembers
static void getChannelMembers(const char *channelId, onGetChannelMembers listener)
채널 멤버 조회  채널 ID를 입력받아, 해당 채널의 멤버 목록을 조회합니다.

Chat::getChannelsByUser
static void getChannelsByUser(onGetChannelsByUser listener)
참여중인 채널 목록 조회  참여중인 채널 목록을 조회합니다.

Chat::unblockMember
static void unblockMember(int64_t blockPlayerId, onUnblockMember listener)
사용자 차단 해제  사용자 ID를 입력받아, 해당 사용자의 차단을 해제합니다.

Chat::connect
static void connect(const char *extraData, onResult listener)
채팅서버에 연결 (더 이상 사용되지 않음)  이 메서드는 더 이상 사용을 권장하지 않으며, 향후 버전에서 제거될 예정입니다.

Chat::translate
static void translate(TranslateParams const &params, onTranslate listener)
메시지 번역 요청  targetLanguage와 번역할 메시지를 입력받아, 해당 메시지를 번역합니다.

Chat::connect
static void connect(onConnect listener)
채팅서버에 연결  채팅서버에 연결을 시도합니다.

Chat::deleteChannel
static void deleteChannel(const char *channelId, onDeleteChannel listener)
채널 삭제  채널 ID를 입력받아, 해당 채널을 삭제합니다.

Chat::isConnected
static bool isConnected()
소켓 연결 상태 확인  현재 소켓이 연결되어 있는지 확인합니다.

Chat::getBlockMembers
static void getBlockMembers(onGetBlockMembers listener)
차단된 사용자 목록 조회  차단된 사용자 목록을 조회합니다.

Chat::addDirectMessageListener
static void addDirectMessageListener(const char *uniqueKey, DirectMessageListener *listener)
1:1 메시지 리스너 등록  1:1 메시지를 수신하기 위한 리스너를 등록합니다.

Chat::getChannels
static void getChannels(GetChannelsParams const *params, onGetChannels listener)
채널 목록 조회  접근 가능한 채널 목록을 조회합니다.

Chat::enterChannel
static void enterChannel(EnterChannelParams const &params, onEnterChannel listener)
채널 입장  채널 ID를 입력받아, 채널에 접속합니다.

Chat::removeUserListener
static void removeUserListener(const char *uniqueKey)
유저 리스너 제거  등록된 유저 이벤트 리스너를 제거합니다.

Chat::exitChannel
static void exitChannel(const char *channelId, onExitChannel listener)
채널 퇴장  채널 ID를 입력받아, 해당 채널에서 퇴장합니다.

Chat::removeConnectionListener
static void removeConnectionListener(const char *uniqueKey)
연결 리스너 제거  등록된 연결 리스너를 제거합니다.

Chat::blockMember
static void blockMember(int64_t blockPlayerId, onBlockMember listener)
사용자 차단  사용자 ID를 입력받아, 해당 사용자를 차단합니다.

Chat::sendMessageWithDirectSendMessageParams
static void sendMessageWithDirectSendMessageParams(DirectSendMessageParams const &params, onDirectSendMessage listener)
1:1 메시지 전송  수신자 ID와 메시지를 입력받아, 해당 사용자에게 메시지를 전송합니다.

Chat::reconnect
static void reconnect(onReconnect listener)
채팅 서버 재 연결  Hive 채팅 서버와 재연결 합니다.

Chat::sendMessageWithChannelSendMessageParams
static void sendMessageWithChannelSendMessageParams(ChannelSendMessageParams const &params, onChannelSendMessage listener)
채널 메시지 전송  채널 ID와 메시지를 입력받아, 해당 채널에 메시지를 전송합니다.

SortType
SortType
채널 정렬 타입 정보
Definition: HIVE_Chat.h:647

Chat::addCustomDataListener
static void addCustomDataListener(const char *uniqueKey, CustomDataListener *listener)
커스텀 데이터 리스너 등록

Chat::sendMessageWithChannelSendMessageParams
static void sendMessageWithChannelSendMessageParams(ChannelSendMessageParams const &params)
채널 메시지 전송  채널 ID와 메시지를 입력받아, 해당 채널에 메시지를 전송합니다.

Chat::createChannel
static void createChannel(CreateChannelParams const &params, onCreateChannel listener)
채널 생성

Chat::getChannelInfo
static void getChannelInfo(const char *channelId, onGetChannelInfo listener)
채널 정보 조회  채널 ID를 입력받아, 해당 채널의 정보를 조회합니다.

Chat::removeDirectMessageListener
static void removeDirectMessageListener(const char *uniqueKey)
1:1 메시지 리스너 제거  등록된 1:1 메시지 리스너를 제거합니다.