이벤트 관리¶

Hive 채팅 기능은 앱 클라이언트로 아래 4가지 유형 이벤트를 전달합니다.

연결 이벤트
채널 이벤트
유저 이벤트
커스텀 데이터 이벤트

사용자 정의 키와 함께 이벤트 리스너를 등록하면 이벤트를 수신할 수 있습니다.

연결 이벤트¶

연결 이벤트는 Hive 채팅 소켓 서버 연결과 관련한 이벤트입니다.

연결 이벤트 유형¶

이벤트명	발생 시기	설명
OnConnected	~~연결 성공 시~~	[Deprecated] 연결 성공 시 발생합니다.
OnConnectStarted	연결 시작 시	연결 시작 시 발생합니다.
OnConnectCompleted	연결 완료 시	연결 시도 후 발생합니다. 성공 여부를 결과로 반환합니다.
OnDisconnected	연결 실패 시	연결 실패 시 발생합니다.
OnReconnectStarted	~~재연결 시작 시~~	[Deprecated] 재연결 시작 시 발생합니다.
OnReconnected	~~재연결 성공 시~~	[Deprecated] 재연결 시도 후 발생합니다. 채팅 소켓 서버 연결 해제 후 10분 이내 재연결 요청에 성공 시, 이전에 참여한 채널에 자동으로 입장을 시도합니다. 그 후에 입장에 성공한 채널 목록과 실패한 채널 목록을 결과로 반환합니다.

UnityUnreal EngineC++KotlinJavaSwiftObjective-C

using hive;

ConnectionHandler connectionHandler = new ConnectionHandler
{
    OnConnectStarted() => 
    {
        // on connect started
    },
    OnConnectCompleted() = (ResultAPI result) =>
    {
        // on connect completed
    },
    OnDisconnected = () =>
    {
        // on disconnected
    }
};
Chat.addConnectionHandler("UNIQUE_KEY", connectionHandler); // add connection handler
Chat.removeConnectionHandler("UNIQUE_KEY"); // remove connection handler

#include "HiveChat.h"

class ConnectionListener : public FHiveConnectionListener {
public:
    UChatTestView* Owner;
    ConnectionListener(UChatTestView* InOwner) : Owner(InOwner) {}

    virtual void onConnectStarted() override {
        // on connect started
    }

    virtual void onConnectCompleted(const FHiveResultAPI& Result) override {
        // on connect completed
    }

    virtual void onDisconnected() override {
        // on disconnected
    }
};

FHiveChat::AddConnectionListener("UNIQUE_KEY", new ConnectionListener(this)); // add connection listener
FHiveChat::RemoveConnectionListener("UNIQUE_KEY"); // remove connection listener

#include <HIVE_SDK_Plugin/HIVE_CPP.h>
using namespace hive;

class ConnectionListenerImpl : public ConnectionListener {
    void onConnectStarted() override {
        // on connect started
    }

    void onConnectCompleted(ResultAPI const & result) override {
        // on connect completed
    }

    void onDisconnected() override {
        // on disconnected
    }
};

Chat::addConnectionListener("UNIQUE_KEY", new ConnectionListenerImpl()); // add connection listener
Chat::removeConnectionListener("UNIQUE_KEY"); // remove connection listener

import com.hive.Chat;

// add connection listener
Chat.addConnectionListener("UNIQUE_KEY", object : ConnectionListener{
    override fun onConnectStarted() {
        // on connect started
    }

    override fun onConnectCompleted(result: ResultAPI) {
        // on connect completed
    }

    override fun onDisconnected() {
        // on disconnected
    }
})

// remove connection listener
Chat.removeConnectionListener("UNIQUE_KEY");

import com.hive.Chat;

// add connection listener
Chat.addConnectionListener("UNIQUE_KEY", new Chat.ConnectionListener() {
    @Override
    public void onConnectStarted() {
        // on connect started
    }

    @Override
    public void onConnectCompleted(@NonNull ResultAPI result) {
        // on connect completed
    }

    @Override
    public void onDisconnected() {
        // on disconnected
    }
});

// remove connection listener
Chat.removeConnectionListener("UNIQUE_KEY");

import HIVEService

class ChatConnectionListener: HiveChatConnectionDelegate {
    func onConnectStarted() {
        // on connect started
    }

    func onConnectCompleted(result: ResultAPI) {
        // on connect completed
    }

    func onDisconnected() {
        // on disconnected
    }
}

ChatInterface.addConnectionListener(uniqueKey: "UNIQUE_KEY", listener: ChatConnectionListener()) // add connection listener
ChatInterface.removeConnectionListener(uniqueKey: "UNIQUE_KEY") // remove connection listener

#import "HIVEService.h"

@interface ChatConnectionListener : NSObject <HiveChatConnectionDelegate>
@end

@implementation ChatConnectionListener

- (void)onConnectStarted {
    // on connect Started
}

- (void)onConnectCompletedWithResult:(HIVEResultAPI *)result {
    // on connect completed
}

- (void)onDisconnected {
    // on disconnected
}

@end

[ChatInterface addConnectionListenerWithUniqueKey:@"UNIQUE_KEY" listener:[[ChatConnectionListener alloc] init]]; // add connection listener
[ChatInterface removeConnectionListenerWithUniqueKey:@"UNIQUE_KEY"]; // remove connection listener

채널 이벤트¶

채널 이벤트는 사용자와 채널 사이에서 발생하는 모든 이벤트를 전달합니다.

채널 이벤트 유형¶

이벤트명	발생 시기	설명
OnEnteredMember	멤버의 채널 참여	멤버가 채널에 참여 시 발생합니다. 채널 참여 시 참여한 멤버 정보를 포함한 객체(EnteredMember)를 전달합니다.
OnExitedMember	멤버의 채널 퇴장	멤버가 채널에서 퇴장 시 발생합니다. 채널 퇴장 시 퇴장한 멤버 정보를 포함한 객체(ExitedMember)를 전달합니다.
OnDeletedChannel	채널 삭제	채널 삭제 시 발생합니다. 삭제된 채널 정보를 포함한 객체(DeletedChannel)를 전달합니다.
OnNoticeMessage	공지 메시지 수신	공지 메시지 수신 시 발생합니다. 공지 메시지 정보를 포함한 객체(ChannelNoticeMessage)를 전달합니다.
OnChannelMessage	채널 메시지 수신	채널 메시지 수신 시 발생합니다. 채널 메시지 정보를 포함한 객체(ChannelMessage)를 전달합니다.

EnteredMember¶

필드명	설명	타입
channelId	이벤트가 발생한 채널 ID	string
playerId	입장한 멤버의 PlayerID	int
timestamp	이벤트 발생 시간	string
timestampMillis	이벤트 발생 시간 (Unix Timestamp)	string

ExitedMember¶

필드명	설명	타입
channelId	이벤트가 발생한 채널 ID	string
playerId	퇴장한 멤버의 PlayerID	int
timestamp	이벤트 발생 시간	string
timestampMillis	이벤트 발생 시간 (Unix Timestamp)	string

DeletedChannel¶

필드명	설명	타입
channelId	삭제된 채널 ID	string
timestamp	이벤트 발생 시간	string
timestampMillis	이벤트 발생 시간 (Unix Timestamp)	string

ChannelNoticeMessage¶

필드명	설명	타입
channelId	이벤트가 발생한 채널 ID	string
from	공지 메시지 발신자	string
message	공지 메시지	string
timestamp	이벤트 발생 시간	string
timestampMillis	이벤트 발생 시간 (Unix Timestamp)	string

ChannelMessage¶

필드명	설명	타입
messageId	메시지 고유 식별자	string
channelId	이벤트가 발생한 채널 ID	string
from	메시지 발신자	string
to	수신 채널	string
message	메시지	string
translated	번역여부	boolean
translatedMessage	번역 메시지	string
extraData	채널 메시지 부가정보	string
timestamp	이벤트 발생 시간	string
timestampMillis	이벤트 발생 시간 (Unix Timestamp)	string
replyMessageId	답글 대상 메시지 아이디(채널 메시지 전송 시, ChannelSendMessageParams의 답글 대상 메시지 아이디(replyMessageId)를 지정하여 전송한 경우에만 수신)	string
replyMessage	답글 대상 메시지 본문(채널 메시지 전송 시, ChannelSendMessageParams의 답글 대상 메시지 아이디(replyMessageId)를 지정하여 전송한 경우에만 수신)	string
replyExtraData	답글 대상 메시지 부가정보(채널 메시지 전송 시, ChannelSendMessageParams의 답글 대상 메시지 아이디(replyMessageId)를 지정하여 전송한 경우에만 수신)	string
mentionedPlayerIds	멘션 대상 플레이어 아이디	list<long>
reactions	리액션 정보	map<ReactionType, list<long>>

Reaction¶

필드명	설명	타입
channelId	리액션 이벤트가 발생한 채널 ID	string
messageId	리액션 이벤트가 발생한 메시지 ID	string
playerId	리액션 이벤트를 발생시킨 플레이어 ID	long
type	리액션 타입(ReactionType)	enum

UnityUnreal EngineC++KotlinJavaSwiftObjective-C

using hive;

ChannelHandler channelHandler = new ChannelHandler
{
    OnEnteredMember = (member) =>
    {
        // member entered
    },
    OnExitedMember = (member) =>
    {
        // member exited
    },
    OnDeletedChannel = (channel) =>
    {
        // channel deleted
    },
    OnNoticeMessage = (message) =>
    {
        // channel notice message received
    },
    OnChannelMessage = (message) =>
    {
        // channel message received
    },
    OnAddReaction = (reaction) =>
    {
        // add reaction
    },
    OnRemoveReaction = (reaction) =>
    {
        // remove reaction
    }
};
Chat.addChannelHandler("UNIQUE_KEY", channelHandler); // add channel handler
Chat.removeChannelHandler("UNIQUE_KEY"); // remove channel handler

#include "HiveChat.h"

class ChannelListener : public FHiveChannelListener {
public:
    UChatTestView* Owner;
    ChannelListener(UChatTestView* InOwner) : Owner(InOwner) {}

    virtual void onNoticeMessage(const FHiveChannelNoticeMessage& message) override {
        // channel notice message received
    }

    virtual void onChannelMessage(const FHiveChannelMessage& message) override {
        // channel message received
    }

    virtual void onDeletedChannel(const FHiveDeletedChannel& channel) override {
        // channel deleted
    }

    virtual void onEnteredMember(const FHiveEnteredMember& member) override {
        // member entered
    }

    virtual void onExitedMember(const FHiveExitedMember& member) override {
        // member exited
    }

    virtual void onAddReaction(const FReaction& reaction) override {
        // add reaction
    }

    virtual void onRemoveReaction(const FReaction& reaction) override {
        // remove reaction
    }
};

FHiveChat::AddChannelListener("UNIQUE_KEY", new ChannelListener(this)); // add channel listener
FHiveChat::RemoveChannelListener("UNIQUE_KEY"); // remove channel listener

#include <HIVE_SDK_Plugin/HIVE_CPP.h>
using namespace hive;

class ChannelListenerImpl : public ChannelListener {
    void onEnteredMember(EnteredMember const & member) override {
        // member entered
    }

    void onExitedMember(ExitedMember const & member) override {
        // member exited
    }

    void onDeletedChannel(DeletedChannel const & channel) override {
        // channel deleted
    }

    void onNoticeMessage(ChannelNoticeMessage const & message) override {
        // channel notice message received
    }

    void onChannelMessage(ChannelMessage const & message) override {
        // channel message received
    }

    void onAddReaction(Reaction const & reaction) override {
        // add reaction
    }

    void onRemoveReaction(Reaction const & reaction) override {
        // remove reaction
    }
};

Chat::addChannelListener("UNIQUE_KEY", new ChannelListenerImpl()); // add channel listener
Chat::removeChannelListener("UNIQUE_KEY"); // remove channel listener

import com.hive.Chat;

// add channel listener
Chat.addChannelListener("UNIQUE_KEY", object: Chat.ChannelListener{
    override fun onEnteredMember(member: Chat.EnteredMember) {
        // member entered
    }

    override fun onExitedMember(member: Chat.ExitedMember) {
        // member exited
    }

    override fun onDeletedChannel(channel: Chat.DeletedChannel) {
        // channel deleted
    }

    override fun onNoticeMessage(message: Chat.ChannelNoticeMessage) {
        // channel notice message received
    }

    override fun onChannelMessage(message: Chat.ChannelMessage) {
        // channel message received
    }

    override fun onAddReaction(reaction: Chat.Reaction) {
        // add reaction
    }

    override fun onRemoveReaction(reaction: Chat.Reaction) {
        // remove reaction
    }
})

// remove channel listener
Chat.removeChannelListener("UNIQUE_KEY");

import com.hive.Chat;

// add channel listener
Chat.addChannelListener("UNIQUE_KEY", new Chat.ChannelListener(){
    @Override
    public void onEnteredMember(@NonNull Chat.EnteredMember member) {
        // member entered
    }

    @Override
    public void onExitedMember(@NonNull Chat.ExitedMember member) {
        // member exited
    }

    @Override
    public void onDeletedChannel(@NonNull Chat.DeletedChannel channel) {
        // channel deleted
    }

    @Override
    public void onNoticeMessage(@NonNull Chat.ChannelNoticeMessage message) {
        // channel notice message received
    }

    @Override
    public void onChannelMessage(@NonNull Chat.ChannelMessage message) {
        // channel message received
    }

    @Override
    public void onAddReaction(@NonNull Chat.Reaction reaction) {
        // add reaction
    }

    @Override
    public void onRemoveReaction(@NonNull Chat.Reaction reaction) {
        // remove reaction
    }
});

// remove channel listener
Chat.removeChannelListener("UNIQUE_KEY");

import HIVEService

class ChatChannelListener: HiveChatChannelMessageDelegate {
    func onEnteredMember(_ member: Chat.EnteredMember) {
        // member entered
    }

    func onExitedMember(_ member: Chat.ExitedMember) {
        // member exited
    }

    func onDeletedChannel(_ channel: Chat.DeletedChannel) {
        // channel deleted
    }

    func onNoticeMessage(_ message: Chat.ChannelNoticeMessage) {
        // channel notice message received
    }

    func onChannelMessage(_ message: Chat.ChannelMessage) {
        // channel message received
    }

    func onAddReaction(_ reaction: Chat.Reaction) {
        // add reaction
    }

    func onRemoveReaction(_ reaction: Chat.Reaction) {
        // remove reaction
    }
}

ChatInterface.addChannelListener(uniqueKey: "UNIQUE_KEY", listener: ChatChannelListener()) // add channel listener
ChatInterface.removeChannelListener(uniqueKey: "UNIQUE_KEY") // remove channel listener

#import "HIVEService.h"

@interface ChatChannelListener : NSObject <HiveChatChannelMessageDelegate>
@end

@implementation ChatChannelListener
- (void)onEnteredMember:(Chat.EnteredMember *)member {
    // member entered
}

- (void)onExitedMember:(Chat.ExitedMember *)member {
    // member exited
}

- (void)onDeletedChannel:(Chat.DeletedChannel *)channel {
    // channel deleted
}

- (void)onNoticeMessage:(Chat.ChannelNoticeMessage *)message {
    // channel notice message received
}

- (void)onChannelMessage:(Chat.ChannelMessage *)message {
    // channel message received
}

- (void)onAddReaction:(Chat.Reaction *)reaction {
    // add reaction
}

- (void)onRemoveReaction:(Chat.Reaction *)reaction {
    // remove reaction
}
@end

[ChatInterface addChannelListenerWithUniqueKey:@"UNIQUE_KEY" listener:[[ChatChannelListener alloc] init]]; // add channel listener
[ChatInterface removeChannelListenerWithUniqueKey:@"UNIQUE_KEY"]; // remove channel listener

유저 이벤트¶

유저 이벤트는 다이렉트 메시지 전송, 공지사항 전송 이벤트를 전달합니다.

유저 이벤트 유형¶

이벤트명	발생 시기	설명
OnDirectMessage	다이렉트 메시지 수신 시	다이렉트 메시지 수신 시 발생합니다. 다이렉트 메시지 정보를 포함한 객체(DirectMessage)를 전달합니다.
onNoticeMessage	공지사항 메시지 수신 시	공지사항 메시지 수신 시 발생합니다. 공지사항 메시지 정보를 포함한 객체(NoticeMessage)를 전달합니다.

DirectMessage¶

필드명	설명	타입
messageId	메시지 고유 식별자	string
from	메시지 발신자	long
to	메시지 수신자	long
message	메시지	string
extraData	다이렉트 메시지 부가정보	string
timestamp	이벤트 발생 시간	string
timestampMillis	이벤트 발생 시간 (Unix Timestamp)	string

NoticeMessage¶

필드명	설명	타입
from	메시지 발신자	string
message	메시지	string
timestamp	이벤트 발생 시간	string
timestampMillis	이벤트 발생 시간 (Unix Timestamp)	string

UnityUnreal EngineC++KotlinJavaSwiftObjective-C

using hive;

UserHandler userHandler = new UserHandler
{
    OnDirectMessage = (message) =>
    {
        // direct message received
    },
    OnNoticeMessage = (message) =>
    {
        // notice message Received
    }
};
Chat.addUserHandler("UNIQUE_KEY", userHandler); // add user handler
Chat.removeUserHandler("UNIQUE_KEY"); // remove user handler

class UserListener : public FHiveUserListener {
public:
    UChatTestView* Owner;
    UserListener(UChatTestView* InOwner) : Owner(InOwner) {}

    virtual void onDirectMessage(const FHiveDirectMessage& message) override {
        // direct message received
    }

    virtual void onNoticeMessage(const FHiveNoticeMessage& message) override {
        // notice message received
    }
};

FHiveChat::AddUserListener("UNIQUE_KEY", new UserListener(this)); // add user listener

FHiveChat::RemoveUserListener("UNIQUE_KEY"); // remove user listener

#include <HIVE_SDK_Plugin/HIVE_CPP.h>
using namespace hive;

class UserListenerImpl : public UserListener {
    void onDirectMessage(DirectMessage const & message) override {
        // direct message received
    }

    void onNoticeMessage(NoticeMessage const & message) override {
        // notice message received
    }
};

Chat::addUserListener("UNIQUE_KEY", new UserListenerImpl()); // add user listener
Chat::removeUserListener("UNIQUE_KEY"); // remove user listener

import com.hive.Chat;

// add user listener
Chat.addUserListener("UNIQUE_KEY", object: Chat.UserListener{
    override fun onDirectMessage(message: Chat.DirectMessage) {
        // direct message received
    }

    override fun onNoticeMessage(message: Chat.NoticeMessage) {
        // notiice message received
    }
})

// remove user listener
Chat.removeUserListener("UNIQUE_KEY");

import com.hive.Chat;

// add direct message listener
Chat.addUserListener("UNIQUE_KEY", new Chat.UserListener() {
    @Override
    public void onDirectMessage(@NonNull Chat.DirectMessage message) {
        // direct message received
    }

    @Override
    public void onNoticeMessage(@NonNull Chat.NoticeMessage message) {
        // notice message received
    }
});

// remove user listener
Chat.removeUserListener("UNIQUE_KEY");

import HIVEService

class ChatUserListener: HiveChatUserDelegate {
    func onDirectMessage(_ message: HiveChatParams.DirectMessage) {
        // direct message received
    }

    func onNoticeMessage(_ message: HiveChatParams.NoticeMessage) {
        // notice message received
    }
}

ChatInterface.addUserListener(uniqueKey: "UNIQUE_KEY", listener: HiveChatUserDelegate()) // add user listener
ChatInterface.removeUserListener(uniqueKey: "UNIQUE_KEY") // remove user listener

#import "HIVEService.h"

@interface ChatUserListener : NSObject <HiveChatUserDelegate>
@end

@implementation ChatUserListener
- (void)onDirectMessage:(HiveChatDirectMessage *)message {
    // direct message received
}

- (void)onNoticeMessage:(HiveChatNoticeMessage)message {
    // notice message received
}
@end

[ChatInterface addUserListenerWithUniqueKey:@"UNIQUE_KEY" listener:[[HiveChatUserDelegate alloc] init]]; // add user listener
[ChatInterface removeUserListenerWithUniqueKey:@"UNIQUE_KEY"]; // remove user listener

커스텀 데이터 이벤트¶

Hive 채팅 API 채널 커스텀 메시지 전송 또는 사용자 커스텀 메시지 전송으로 전달하는 커스텀 데이터를 수신하는 기능을 제공합니다. Hive 채팅 API 채널 커스텀 메시지 전송 또는 사용자 커스텀 메시지 전송으로 전달하는 커스텀 데이터를 수신하는 기능을 제공합니다.

Note

Hive SDK에서는 커스텀 데이터를 전송하는 기능을 제공하지 않습니다. Hive 채팅 API를 통해 커스텀 데이터를 전송할 수 있습니다.

커스텀 데이터 이벤트 유형¶

이벤트명	발생 시기	설명
OnCustomData	커스텀 데이터 수신 시	커스텀 데이터 수신 시 발생합니다. `string` 타입의 커스텀 데이터를 전달합니다. (최대 `8000 byte`)

UnityUnreal EngineC++KotlinJavaSwiftObjective-C

using hive;

CustomDataHandler customDataHandler = new CustomDataHandler
{
    OnCustomData = (data) =>
    {
        // custom data received
    }
};
Chat.addCustomDataHandler("UNIQUE_KEY", customDataHandler); // add custom data handler
Chat.removeCustomDataHandler("UNIQUE_KEY"); // remove custom data handler

class CustomDataListener : public FHiveCustomDataListener {
public:
    UChatTestView* Owner;
    CustomDataListener(UChatTestView* InOwner) : Owner(InOwner) {}

    virtual void onCustomData(const FString data) override {
        // custom data received
    }
};

FHiveChat::AddCustomDataListener("UNIQUE_KEY", new CustomDataListener(this)); // add custom data listener

FHiveChat::RemoveCustomDataListener("UNIQUE_KEY"); // remove custom data listener

#include <HIVE_SDK_Plugin/HIVE_CPP.h>
using namespace hive;

class CustomDataListenerImpl : public CustomDataListener {
    void onCustomData(std::string const & data) override {
        // custom data received
    }
};

Chat::addCustomDataListener("UNIQUE_KEY", new CustomDataListenerImpl()); // add custom data listener
Chat::removeCustomDataListener("UNIQUE_KEY"); // remove custom data listener

import com.hive.Chat;

// add custom data listener
Chat.addCustomDataListener("UNIQUE_KEY", object: Chat.CustomDataListener{
    override fun onCustomData(data: String) {
        // custom data received
    }
})

// remove custom data listener
Chat.removeCustomDataListener("UNIQUE_KEY");

import com.hive.Chat;

// add custom data listener
Chat.addCustomDataListener("UNIQUE_KEY", new Chat.CustomDataListener() {
    @Override
    public void onCustomData(@NonNull String data) {
        // custom data received
    }
});

// remove custom data listener
Chat.removeCustomDataListener("UNIQUE_KEY");

import HIVEService

class ChatCustomDataListener: HiveChatCustomDataDelegate {
    func onCustomData(_ data: String) {
        // custom data received
    }
}

ChatInterface.addCustomDataListener(uniqueKey: "UNIQUE_KEY", listener: HiveChatCustomDataDelegate()) // add custom data listener
ChatInterface.removeCustomDataListener(uniqueKey: "UNIQUE_KEY") // remove custom data listener

#import "HIVEService.h"

@interface ChatCustomDataListener : NSObject <HiveChatCustomDataDelegate>
@end

@implementation ChatCustomDataListener
- (void)onCustomData:(NSString *)data {
    // custom data received
}
@end

[ChatInterface addCustomDataListenerWithUniqueKey:@"UNIQUE_KEY" listener:[[HiveChatCustomDataDelegate alloc] init]]; // add custom data listener
[ChatInterface removeCustomDataListenerWithUniqueKey:@"UNIQUE_KEY"]; // remove custom data listener