跳转至

事件管理

Hive 聊天功能向应用客户端提供三种类型的事件。

  • 连接事件
  • 渠道事件
  • 1:1 消息事件

您可以通过使用自定义键注册事件监听器来接收事件。

连接事件

连接事件是与 Hive 聊天套接字服务器连接相关的事件。

连接事件类型

事件名称 发生时间 描述
连接成功 当连接成功时 当连接成功时发生。
连接失败 当连接失败时 当连接失败时发生。 
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)); // 添加连接监听器
FHiveChat::RemoveConnectionListener("UNIQUE_KEY"); // 移除连接监听器

#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()); // 添加连接监听器
Chat::removeConnectionListener("UNIQUE_KEY"); // 移除连接监听器

import com.hive.Chat;

    // 添加连接监听器
Chat.addConnectionListener("UNIQUE_KEY", object : ConnectionListener{
    override fun onConnected() {
        // 已连接
    }

    override fun onDisconnected() {
        // 断开连接时
    }
})

    // 移除连接监听器
Chat.removeConnectionListener("UNIQUE_KEY"); 

import com.hive.Chat;

    // 添加连接监听器
Chat.addConnectionListener("UNIQUE_KEY", new Chat.ConnectionListener() {
    @Override
    public void onConnected() {
        // 连接成功时
    }

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

    // 移除连接监听器
Chat.removeConnectionListener("UNIQUE_KEY"); 

import HIVEService

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

    func onDisconnected() {
        // 断开连接时
    }
}

ChatInterface.addConnectionListener(uniqueKey: "UNIQUE_KEY", listener: 
    ChatConnectionListener()) // 添加连接监听器
ChatInterface.removeConnectionListener(uniqueKey: "UNIQUE_KEY") // 移除连接监听器

#import "HIVEService.h"

@interface ChatConnectionListener : NSObject <HiveChatConnectionDelegate>
@end

@implementation ChatConnectionListener

- (void)onConnected {
    // 已连接
}

- (void)onDisconnected {
    // 断开连接时
}

@end

[ChatInterface addConnectionListenerWithUniqueKey:@"UNIQUE_KEY" listener:[[ChatConnectionListener alloc] init]]; // 添加连接监听器
[ChatInterface removeConnectionListenerWithUniqueKey:@"UNIQUE_KEY"]; // 移除连接监听器

渠道事件

频道事件传达用户与频道之间发生的所有事件。

渠道事件类型

事件名称 发生时间 描述
OnEnteredMember 成员频道参与 当成员加入频道时发生。加入频道时会传递包含参与成员信息的对象（EnteredMember）。
OnExitedMember 成员频道退出 当成员退出频道时发生。离开频道时会传递包含退出成员信息的对象（ExitedMember）。
OnDeletedChannel 频道删除 当频道被删除时发生。会传递包含被删除频道信息的对象（DeletedChannel）。
OnNoticeMessage 通知消息接收 当接收到通知消息时发生。会传递包含通知消息信息的对象（ChannelNoticeMessage）。
OnChannelMessage 频道消息接收 当接收到频道消息时发生。会传递包含频道消息信息的对象（ChannelMessage）。

进入的成员

字段名称 描述 类型
channelId 事件发生的频道ID 字符串
playerId 加入成员的玩家ID 整数
extraData 附加成员信息 字符串
timestamp 事件发生时间 字符串

退出成员

字段名称 描述 类型
channelId 事件发生的频道ID 字符串
playerId 退出成员的PlayerID 整数
extraData 关于成员的附加信息 字符串
timestamp 事件发生的时间 字符串

已删除频道

字段名称 描述 类型
channelId 已删除的频道ID 字符串
timestamp 事件发生时间 字符串

通道通知消息

字段名称 描述 类型
channelId 事件发生的频道ID string
from 通知消息的发送者 string
message 通知消息 string
timestamp 事件发生的时间 string

渠道消息

字段名称 描述 类型
channelId 事件发生的频道ID 字符串
from 消息发送者 字符串
fromExtra 关于消息发送者的附加信息 字符串
to 接收频道 字符串
message 消息 字符串
timestamp 事件发生时间 字符串 
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)); // 添加频道监听器 FHiveChat::RemoveChannelListener("UNIQUE_KEY"); // 移除频道监听器 ```

#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()); // 添加频道监听器
Chat::removeChannelListener("UNIQUE_KEY"); // 移除频道监听器

import com.hive.Chat;
    // 添加频道监听器
Chat.addChannelListener("UNIQUE_KEY", object: Chat.ChannelListener{
    override fun onEnteredMember(member: Chat.EnteredMember) {
        // 成员已进入
    }

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

    // 移除频道监听器
Chat.removeChannelListener("UNIQUE_KEY"); 

import com.hive.Chat;

    // 添加频道监听器
Chat.addChannelListener("UNIQUE_KEY", new Chat.ChannelListener(){
    @Override
    public void onEnteredMember(@NonNull Chat.EnteredMember member) {
        // 成员已加入
    }

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

    // 移除频道监听器
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()) // 添加频道监听器
ChatInterface.removeChannelListener(uniqueKey: "UNIQUE_KEY") // 移除频道监听器

#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]]; // 添加频道监听器
[ChatInterface removeChannelListenerWithUniqueKey:@"UNIQUE_KEY"]; // 移除频道监听器

1:1 消息事件

1:1 消息事件传递个人消息发送事件。

1:1 消息事件类型

事件名称 发生时间 描述
OnDirectMessage 接收到1:1消息时 当接收到1:1消息时发生。它传递一个包含1:1消息信息的对象（DirectMessage）。

直接消息

字段名称 描述 类型
from 消息发送者 长整型
fromExtra 消息发送者的附加信息 字符串
to 消息接收者 长整型
message 消息 字符串
timestamp 事件发生时间 字符串 
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)); // 添加直接消息监听器

FHiveChat::RemoveDirectMessageListener("UNIQUE_KEY"); // 移除直接消息监听器

#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()); // 添加直接消息监听器
Chat::removeDirectMessageListener("UNIQUE_KEY"); // 移除直接消息监听器

import com.hive.Chat;

    // 添加直接消息监听器
Chat.addDirectMessageListener("UNIQUE_KEY", object: Chat.DirectMessageListener{
    override fun onDirectMessage(message: Chat.DirectMessage) {
        // 收到直接消息
    }
})

    // 移除直接消息监听器
Chat.removeDirectMessageListener("UNIQUE_KEY");

import com.hive.Chat;

     // 添加直接消息监听器
Chat.addDirectMessageListener("UNIQUE_KEY", new Chat.DirectMessageListener() {
    @Override
    public void onDirectMessage(@NonNull Chat.DirectMessage message) {
        // 收到直接消息
    }
});

    // 移除直接消息监听器
Chat.removeDirectMessageListener("UNIQUE_KEY");

import HIVEService

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

ChatInterface.addDirectMessageListener(uniqueKey: "UNIQUE_KEY", listener: ChatDirectMessageListener()) // 添加直接消息监听器
ChatInterface.removeDirectMessageListener(uniqueKey: "UNIQUE_KEY") // 移除直接消息监听器

#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]]; // 添加直接消息监听器
[ChatInterface removeDirectMessageListenerWithUniqueKey:@"UNIQUE_KEY"]; // 移除直接消息监听器