Skip to content

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. 
using hive;

ConnectionHandler connectionHandler = new ConnectionHandler
{
    OnConnected = () =>
    {
        // on connected
    },
    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 onConnected() override {
        // on connected
    }

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

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

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

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

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

import HIVEService

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

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

- (void)onDisconnected {
    // on disconnected
}

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

```cpp

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