跳转至

事件管理

Hive 聊天功能向应用客户端发送以下四种类型的事件。

  • 连接事件
  • 渠道事件
  • 用户事件
  • 自定义数据事件

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

连接事件

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

连接事件类型

事件名称 发生时间 描述
连接成功 当连接成功时 当连接成功时发生。
连接失败 当连接失败时 当连接失败时发生。
重连开始 当重连开始时 当重连开始时发生。
重连成功 当重连成功时 在重连尝试后发生。如果在聊天套接字服务器断开连接后的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)); // 添加连接监听器
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 {
        // 断开连接时
    }

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

import com.hive.Chat;

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

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

    override fun onReconnectStarted() {
        // on reconnect started
    }

    override fun onReconnected(result: ResultAPI, channelIds: ArrayList<String>, failChannelIds: ArrayList<String>) {
        // 重新连接时
    }
})

// 移除连接监听器
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
    }

    @Override
    public void onReconnectStarted() {
        // on reconnect started
    }

    @Override
    public void onReconnected(@NonNull ResultAPI result, @NonNull ArrayList<String> channelIds, @NonNull ArrayList<String> failChannelIds) {
        // on reconnected
    }
});

// 移除连接监听器
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]) {
        // 重新连接时
    }
}

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

#import "HIVEService.h"

@interface ChatConnectionListener : NSObject <HiveChatConnectionDelegate>
@end

@implementation ChatConnectionListener

- (void)onConnected {
    // on connected
}

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

- (void)onReconnectStarted {
    // 重新连接开始
}

- (void)onReconnectedWithResult:(HIVEResultAPI *)result channelIds:(NSArray<NSString *> *)channelIds failChannelIds:(NSArray<NSString *> *)failChannelIds {
    // on reconnected
}

@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 整数
timestamp 事件发生时间 字符串
timestampMillis 事件发生时间（Unix时间戳） 字符串

退出成员

字段名称 描述 类型
channelId 事件发生的频道ID string
playerId 离开的成员的PlayerID int
timestamp 事件发生的时间 string
timestampMillis 事件发生的时间（Unix时间戳） string

已删除频道

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

渠道通知消息

字段名称 描述 类型
channelId 事件发生的频道ID 字符串
from 通知消息的发送者 字符串
message 通知消息 字符串
timestamp 事件发生的时间 字符串
timestampMillis 事件发生时间（Unix时间戳） 字符串

渠道消息

字段名称 描述 类型
messageId 唯一消息标识符 string
channelId 事件发生的频道ID string
from 消息发送者 string
to 接收频道 string
message 消息 string
translated 翻译状态 boolean
translatedMessage 翻译后的消息 string
extraData 频道消息的附加信息 string
timestamp 事件发生时间 string
replyMessageId 回复目标消息ID（仅在发送频道消息时在ChannelSendMessageParams中指定回复目标消息ID时接收） string
replyMessage 回复目标消息内容（仅在发送频道消息时在ChannelSendMessageParams中指定回复目标消息ID时接收） string
replyExtraData 回复目标消息的附加信息（仅在发送频道消息时在ChannelSendMessageParams中指定回复目标消息ID时接收） string
mentionedPlayerIds 提到的玩家ID list<long>
reactions 反应信息 map<ReactionType, list<long>>

反应

字段名称 描述 类型
channelId 发生反应事件的频道 ID string
messageId 发生反应事件的消息 ID string
playerId 触发反应事件的玩家 ID long
type 反应类型 (ReactionType) enum 
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
             },
    OnAddReaction = (reaction) =>
    {
        // add reaction
    },
    OnRemoveReaction = (reaction) =>
    {
        // remove reaction      
    }
};
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
    }


    virtual void onAddReaction(const FReaction& reaction) override {
        // add reaction
    }

    virtual void onRemoveReaction(const FReaction& reaction) override {
        // remove reaction
    }
};

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
    }

    void onAddReaction(Reaction const & reaction) override {
        // add reaction
    }

    void onRemoveReaction(Reaction const & reaction) override {
        // remove reaction
    }
};

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
    }

            override fun onAddReaction(reaction: Chat.Reaction) {
        // add reaction
    }

    override fun onRemoveReaction(reaction: Chat.Reaction) {
        // remove reaction
    }
})

// 移除频道监听器
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
    }

            @Override
    public void onAddReaction(@NonNull Chat.Reaction reaction) {
        // add reaction
    }

    @Override
    public void onRemoveReaction(@NonNull Chat.Reaction reaction) {
        // remove reaction
    }
});

// 移除频道监听器
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
    }

            func onAddReaction(_ reaction: Chat.Reaction) {
        // add reaction
    }

    func onRemoveReaction(_ reaction: Chat.Reaction) {
        // remove reaction
    }
}

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 {
    // 收到频道消息
}

    - (void)onAddReaction:(Chat.Reaction *)reaction {
    // add reaction
}

- (void)onRemoveReaction:(Chat.Reaction *)reaction {
    // remove reaction
}

@end

[ChatInterface addChannelListenerWithUniqueKey:@"UNIQUE_KEY" listener:[[ChatChannelListener alloc] init]]; // 添加频道监听器
[ChatInterface removeChannelListenerWithUniqueKey:@"UNIQUE_KEY"]; // 移除频道监听器

用户事件

用户事件提供 1:1 消息发送和公告发送事件。

用户事件类型

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

直接消息

字段名称 描述 类型
messageId 唯一消息标识符 string
from 消息发送者 long
to 消息接收者 long
message 消息 string
extraData 1:1 消息附加信息 string
timestamp 事件发生时间 string
timestampMillis 事件发生时间（Unix 时间戳） string

通知消息

字段名称 描述 类型
from 消息发送者 string
message 消息 string
timestamp 事件发生时间 string
timestampMillis 事件发生时间（Unix 时间戳） 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)); // 添加用户监听器

FHiveChat::RemoveUserListener("UNIQUE_KEY"); // 移除用户监听器

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

import com.hive.Chat;

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

    override fun onNoticeMessage(message: Chat.NoticeMessage) {
        // 收到通知消息
    }
})

// 移除用户监听器
Chat.removeUserListener("UNIQUE_KEY");

import com.hive.Chat;

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

    @Override
    public void onNoticeMessage(@NonNull Chat.NoticeMessage message) {
        // notice message received
    }
});

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

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

自定义数据事件

Hive SDK 提供通过服务器 API 提供的 频道自定义消息发送 或 用户自定义消息发送 接收自定义数据的能力。

Note

Hive SDK 不提供发送自定义数据的功能。

自定义数据事件类型

事件名称 发生时间 描述
OnCustomData 当接收到自定义数据时 当接收到自定义数据时发生。它传输类型为string的自定义数据。
（最大8000字节）		 
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)); // 添加自定义数据监听器

FHiveChat::RemoveCustomDataListener("UNIQUE_KEY"); // 移除自定义数据监听器

#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()); // 添加自定义数据监听器
Chat::removeCustomDataListener("UNIQUE_KEY"); // 移除自定义数据监听器

import com.hive.Chat;

// 添加自定义数据监听器
Chat.addCustomDataListener("UNIQUE_KEY", object: Chat.CustomDataListener{
    override fun onCustomData(data: String) {
        // 收到自定义数据
    }
})

// 移除自定义数据监听器
Chat.removeCustomDataListener("UNIQUE_KEY");

import com.hive.Chat;

// 添加自定义数据监听器
Chat.addCustomDataListener("UNIQUE_KEY", new Chat.CustomDataListener() {
    @Override
    public void onCustomData(@NonNull String data) {
        // 收到自定义数据
    }
});

// 移除自定义数据监听器
Chat.removeCustomDataListener("UNIQUE_KEY");

import HIVEService

class ChatCustomDataListener: HiveChatCustomDataDelegate {
    func onCustomData(_ data: String) {
        // custom data received
    }
}

ChatInterface.addCustomDataListener(uniqueKey: "UNIQUE_KEY", listener: HiveChatCustomDataDelegate()) // 添加自定义数据监听器
ChatInterface.removeCustomDataListener(uniqueKey: "UNIQUE_KEY") // 移除自定义数据监听器

#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]]; // 添加自定义数据监听器
[ChatInterface removeCustomDataListenerWithUniqueKey:@"UNIQUE_KEY"]; // 移除自定义数据监听器