콘텐츠로 이동

이벤트 관리

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

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

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

연결 이벤트

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

연결 이벤트 유형

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

ConnectionHandler connectionHandler = new ConnectionHandler
{
    OnConnected = () =>
    {
        // on connected
    },
    OnDisconnected = () =>
    {
        // on disconnected
    },
    OnReconnectStarted() => 
    {
        // on reconnect Started
    },
    OnReconnected = (ResultAPI result, 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 onReconnectStarted() override {
        // on reconnect Started
    }

    virtual void onReconnected(const FHiveResultAPI& Result, 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 onReconnectStarted() override {
        // on reconnect Started
    }

    void onReconnected(ResultAPI const & result, 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 onReconnectStarted() {
        // on reconnect started
    }

    override fun onReconnected(result: ResultAPI, 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 onReconnectStarted() {
        // on reconnect started
    }

    @Override
    public void onReconnected(@NonNull ResultAPI result, @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 onReconnectStarted() {
        // on reconnect started
    }

    func onReconnected(result: ResultAPI, 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)onReconnectStarted {
    // on reconnect Started
}

- (void)onReconnectedWithResult:(HIVEResultAPI *)result channelIds:(NSArray<NSString *> *)channelIds failChannelIds:(NSArray<NSString *> *)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
translated 번역여부 boolean
translatedMessage 번역 메시지 string
extraData 채널 메시지 부가정보 string
timestamp 이벤트 발생 시간 string
timestampMillis 이벤트 발생 시간 (Unix Timestamp) string 
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 메시지 전송, 공지사항 전송 이벤트를 전달합니다.

유저 이벤트 유형

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

DirectMessage

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

NoticeMessage

필드명 설명 타입
from 메시지 발신자 string
message 메시지 string
timestamp 이벤트 발생 시간 string
timestampMillis 이벤트 발생 시간 (Unix Timestamp) string 
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 채널 커스텀 메시지 전송 또는 사용자 커스텀 메시지 전송으로 전달하는 커스텀 데이터를 수신하는 기능을 제공합니다.

Note

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

커스텀 데이터 이벤트 유형

이벤트명 발생 시기 설명
OnCustomData 커스텀 데이터 수신 시 커스텀 데이터 수신 시 발생합니다. string 타입의 커스텀 데이터를 전달합니다.
(최대 8000 byte)		 
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