Event management¶

The Hive chat feature delivers three types of events to the app client.

Connection events
Channel events
1:1 message events

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

Connection event¶

The connection event is an event 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.

UnityC++KotlinJavaSwiftObjective-C

using hive;

ConnectionHandler connectionHandler = new ConnectionHandler
{
    OnConnected = () =>
    {
        // on connected
    },
    OnDisconnected = () =>
    {
        // on disconnected
    }
};
Chat.addConnectionHandler("UNIQUE_KEY", connectionHandler);

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

class ConnectionListenerImpl : public ConnectionListener {
    void onConnected() override {
        // on connected
    }

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

Chat::addConnectionListener("UNIQUE_KEY", new ConnectionListenerImpl());

import com.hive.Chat;

Chat.addConnectionListener("UNIQUE_KEY", object : ConnectionListener{
    override fun onConnected() {
        // on connected
    }

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

import com.hive.Chat;

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

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

import HIVEService

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

    func onDisconnected() {
        // on disconnected
    }
}

ChatInterface.addConnectionListener(uniqueKey: "UNIQUE_KEY", listener: ChatConnectionListener())

#import "HIVEService.h"

@interface ChatConnectionListener : NSObject <HiveChatConnectionDelegate>
@end

@implementation ChatConnectionListener

- (void)onConnected {
    // on connected
}

- (void)onDisconnected {
    // on disconnected
}

@end

[ChatInterface addConnectionListenerWithUniqueKey:@"UNIQUE_KEY" listener:[[ChatConnectionListener alloc] init]];

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 participating member (EnteredMember) is passed when joining the channel.
OnExitedMember	Member Channel Exit	Occurs when a member exits the channel. An object containing the information of the exited member (ExitedMember) is passed when leaving the channel.
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 joined	int
extraData	Additional member information	string
timestamp	Event occurrence time	string

Exitedmember¶

Field Name	Description	Type
channelId	Channel ID where the event occurred	string
playerId	PlayerID of the member who exited	int
extraData	Additional information about the member	string
timestamp	Time when the event occurred	string

Deletedchannel¶

Field Name	Description	Type
channelId	Deleted channel ID	string
timestamp	Event occurrence time	string

Channelnoticemessage¶

Field Name	Description	Type
channelId	Channel ID where the event occurred	string
from	Sender of the notification message	string
message	Notification message	string
timestamp	Time the event occurred	string

Channelmessage¶

Field Name	Description	Type
channelId	Channel ID where the event occurred	string
from	Message sender	string
fromExtra	Additional information about the message sender	string
to	Receiving channel	string
message	Message	string
timestamp	Event occurrence time	string

UnityC++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);

#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());

import com.hive.Chat;

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

import com.hive.Chat;

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

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

#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]];

1:1 message event¶

The 1:1 message event delivers personal message sending events.

1:1 message event type¶

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

Directmessage¶

Field Name	Description	Type
from	Message Sender	long
fromExtra	Additional Information of Message Sender	string
to	Message Receiver	long
message	Message	string
timestamp	Event Occurrence Time	string

UnityC++KotlinJavaSwiftObjective-C

using hive;

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

#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());

import com.hive.Chat;

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

import com.hive.Chat;

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

import HIVEService

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

ChatInterface.addDirectMessageListener(uniqueKey: "UNIQUE_KEY", listener: ChatDirectMessageListener())

#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]];