이벤트 관리¶

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

연결 이벤트
채널 이벤트
1:1 메시지 이벤트

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

연결 이벤트¶

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

연결 이벤트 유형¶

이벤트명	발생 시기	설명
OnConnected	연결 성공 시	연결 성공 시 발생합니다.
OnDisconnected	연결 실패 시	연결 실패 시 발생합니다.
OnReconnected	재연결 성공 시	재연결 성공 시 발생합니다. 채팅 소켓 서버 연결 해제 후 10분 이내 재연결 요청 시, 이전에 참여한 채널에 자동으로 입장을 시도하고, 입장에 성공한 채널 목록과 실패한 채널 목록을 결과로 반환합니다.

UnityUnreal EngineC++KotlinJavaSwiftObjective-C

using hive;

ConnectionHandler connectionHandler = new ConnectionHandler
{
    OnConnected = () =>
    {
        // on connected
    },
    OnDisconnected = () =>
    {
        // on disconnected
    },
    OnReconnected = (List<String> channelIds, List<String> failChannelIds) =>
    {
        // on reconnected
    }
};
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 onConnected() override {
        // on connected
    }

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

    virtual void onReconnected(const TArray<FString>& ChannelIds, const TArray<FString>& FailChannelIds) override {
        // on reconnected
    }
};

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 onConnected() override {
        // on connected
    }

    void onDisconnected() override {
        // on disconnected
    }

    void onReconnected(std::vector<std::string>channelIds, std::vector<std::string>failChannelIds) override {
        // on reconnected
    }
};

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 onConnected() {
        // on connected
    }

    override fun onDisconnected() {
        // on disconnected
    }

    override fun onReconnected(channelIds: ArrayList<String>, failChannelIds: ArrayList<String>) {
        // on reconnected
    }
})

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

import com.hive.Chat;

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

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

    @Override
    public void onReconnected(@NonNull ArrayList<String> channelIds, @NonNull ArrayList<String> failChannelIds) {
        // on reconnected
    }
});

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

import HIVEService

class ChatConnectionListener: HiveChatConnectionDelegate {
    func onConnected() {
        // on connected
    }

    func onDisconnected() {
        // on disconnected
    }

    func onReconnected(channelIds: [String], failChannelIds: [String]) {
        // on reconnected
    }
}

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)onConnected {
    // on connected
}

- (void)onDisconnected {
    // on disconnected
}

- (void)onReconnectedWithChannelIds:(NSArray<NSString *> * _Nonnull)channelIds failChannelIds:(NSArray<NSString *> * _Nonnull)failChannelIds {
    // on reconnected
}

@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¶

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

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
    }
};
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
    }
};

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
    }
};

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
    }
})

// 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
    }
});

// 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
    }
}

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
}
@end

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

1:1 메시지 이벤트¶

1:1 메시지 이벤트는 개인 메시지 전송 이벤트를 전달합니다.

1:1 메시지 이벤트 유형¶

이벤트명	발생 시기	설명
OnDirectMessage	1:1 메시지 수신 시	1:1 메시지 수신 시 발생합니다. 1:1 메시지 정보를 포함한 객체(DirectMessage)를 전달합니다.

DirectMessage¶

필드명	설명	타입
from	메시지 발신자	long
to	메시지 수신자	long
message	메시지	string
extraData	1:1 메시지 부가정보	string
timestamp	이벤트 발생 시간	string
timestampMillis	이벤트 발생 시간 (Unix Timestamp)	string

UnityUnreal EngineC++KotlinJavaSwiftObjective-C

using hive;

DirectMessageHandler directMessageHandler = new DirectMessageHandler
{
    OnDirectMessage = (message) =>
    {
        // direct message received
    }
};
Chat.addDirectMessageHandler("UNIQUE_KEY", directMessageHandler); // add direct message handler
Chat.removeDirectMessageHandler("UNIQUE_KEY"); // remove direct message handler

class DirectMessageListener : public FHiveDirectMessageListener {
public:
    UChatTestView* Owner;
    DirectMessageListener(UChatTestView* InOwner) : Owner(InOwner) {}

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

FHiveChat::AddDirectMessageListener("UNIQUE_KEY", new DirectMessageListener(this)); // add direct message listener

FHiveChat::RemoveDirectMessageListener("UNIQUE_KEY"); // remove direct message listener

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

class DirectMessageListenerImpl : public DirectMessageListener {
    void onDirectMessage(DirectMessage const & message) override {
        // direct message received
    }
};

Chat::addDirectMessageListener("UNIQUE_KEY", new DirectMessageListenerImpl()); // add direct message listener
Chat::removeDirectMessageListener("UNIQUE_KEY"); // remove direct message listener

import com.hive.Chat;

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

// remove direct message listener
Chat.removeDirectMessageListener("UNIQUE_KEY");

import com.hive.Chat;

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

// remove direct message listener
Chat.removeDirectMessageListener("UNIQUE_KEY");

import HIVEService

class ChatDirectMessageListener: HiveChatDirectMessageDelegate {
    func onDirectMessage(_ message: Chat.DirectMessage) {
        // direct message received
    }
}

ChatInterface.addDirectMessageListener(uniqueKey: "UNIQUE_KEY", listener: ChatDirectMessageListener()) // add direct message listener
ChatInterface.removeDirectMessageListener(uniqueKey: "UNIQUE_KEY") // remove direct message listener

#import "HIVEService.h"

@interface ChatDirectMessageListener : NSObject <HiveChatDirectMessageDelegate>
@end

@implementation ChatDirectMessageListener
- (void)onDirectMessage:(Chat.DirectMessage *)message {
    // direct message received
}
@end

[ChatInterface addDirectMessageListenerWithUniqueKey:@"UNIQUE_KEY" listener:[[ChatDirectMessageListener alloc] init]]; // add direct message listener
[ChatInterface removeDirectMessageListenerWithUniqueKey:@"UNIQUE_KEY"]; // remove direct message listener