Event management¶

The Hive chat feature sends the following four types of events to the app client.

Connection Event
Channel Event
User Event
Custom Data Event

You can receive events by registering an event listener with a custom key.

Connection event¶

The connection event is related to the Hive chat socket server connection.

Connection event types¶

Event Name	Occurrence Time	Description
OnConnected	When connection is successful	Occurs when the connection is successful.
OnDisconnected	When connection fails	Occurs when the connection fails.
OnReconnectStarted	When reconnection starts	Occurs when reconnection starts.
OnReconnected	When reconnection is successful	Occurs after a reconnection attempt. If the reconnection request is successful within 10 minutes after the chat socket server is disconnected, it will automatically attempt to join the previously participated channels and return the list of successfully joined channels and the list of failed channels as a result.

UnityUnreal EngineC++KotlinJavaSwiftObjective-C

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

Channel event¶

Channel events convey all events that occur between the user and the channel.

Channel event types¶

Event Name	Occurrence Time	Description
OnEnteredMember	Member Channel Participation	Occurs when a member joins the channel. An object containing the information of the member who joined (EnteredMember) is passed.
OnExitedMember	Member Channel Exit	Occurs when a member exits the channel. An object containing the information of the member who exited (ExitedMember) is passed.
OnDeletedChannel	Channel Deletion	Occurs when a channel is deleted. An object containing the information of the deleted channel (DeletedChannel) is passed.
OnNoticeMessage	Notice Message Reception	Occurs when a notice message is received. An object containing the information of the notice message (ChannelNoticeMessage) is passed.
OnChannelMessage	Channel Message Reception	Occurs when a channel message is received. An object containing the information of the channel message (ChannelMessage) is passed.

Enteredmember¶

Field Name	Description	Type
channelId	Channel ID where the event occurred	string
playerId	PlayerID of the member who entered	int
timestamp	Event occurrence time	string
timestampMillis	Event occurrence time (Unix Timestamp)	string

Exitedmember¶

Field Name	Description	Type
channelId	The ID of the channel where the event occurred	string
playerId	The PlayerID of the member who left	int
timestamp	The time the event occurred	string
timestampMillis	The time the event occurred (Unix Timestamp)	string

Deletedchannel¶

Field Name	Description	Type
channelId	Deleted channel ID	string
timestamp	Event occurrence time	string
timestampMillis	Event occurrence time (Unix Timestamp)	string

Channelnoticemessage¶

Field Name	Description	Type
channelId	The ID of the channel where the event occurred	string
from	The sender of the notification message	string
message	The notification message	string
timestamp	The time the event occurred	string
timestampMillis	The event occurrence time (Unix Timestamp)	string

Channelmessage¶

Field Name	Description	Type
channelId	Channel ID where the event occurred	string
from	Message sender	string
to	Receiving channel	string
message	Message	string
translated	Translation status	boolean
translatedMessage	Translated message	string
extraData	Additional information for the channel message	string
timestamp	Event occurrence time	string
timestampMillis	Event occurrence time (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

User event¶

User events deliver 1:1 message sending and announcement sending events.

User event types¶

Event Name	Occurrence Time	Description
OnDirectMessage	When receiving a 1:1 message	Occurs when a 1:1 message is received. It delivers an object containing the 1:1 message information (DirectMessage).
onNoticeMessage	When receiving a notice message	Occurs when a notice message is received. It delivers an object containing the notice message information (NoticeMessage).

Directmessage¶

Field Name	Description	Type
from	Message Sender	long
to	Message Receiver	long
message	Message	string
extraData	1:1 Message Additional Information	string
timestamp	Event Occurrence Time	string
timestampMillis	Event Occurrence Time (Unix Timestamp)	string

Noticemessage¶

Field Name	Description	Type
from	Message Sender	string
message	Message	string
timestamp	Event Occurrence Time	string
timestampMillis	Event Occurrence Time (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

Custom data event¶

The Hive SDK provides the ability to receive custom data delivered through channel custom message sending or user custom message sending provided by the server API.

Note

The Hive SDK does not provide the functionality to send custom data.

Custom data event type¶

Event Name	Occurrence Time	Description
OnCustomData	When custom data is received	Occurs when custom data is received. It transmits custom data of type `string`. (Maximum `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