跳转至

事件管理

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

import com.hive.Chat;

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

    override fun onDisconnected() {
        // on disconnected
    }

    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) {
        // 重新连接时
    }
});

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

#import "HIVEService.h"

@interface ChatConnectionListener : NSObject <HiveChatConnectionDelegate>
@end

@implementation ChatConnectionListener

- (void)onConnected {
    // on connected
}

- (void)onDisconnected {
    // on disconnected
}

- (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 string
playerId 进入的成员的PlayerID int
timestamp 事件发生时间 string
timestampMillis 事件发生时间（Unix时间戳） string

退出成员

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

删除频道

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

通道通知消息

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

通道消息

字段名称 描述 类型
channelId 事件发生的频道ID string
from 消息发送者 string
to 接收频道 string
message 消息 string
translated 翻译状态 boolean
translatedMessage 翻译后的消息 string
extraData 频道消息的附加信息 string
timestamp 事件发生时间 string
timestampMillis 事件发生时间（Unix时间戳） 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

#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 消息发送和公告发送事件。

用户事件类型

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

直接消息

字段名称 描述 类型
from 消息发送者 长整型
to 消息接收者 长整型
message 消息 字符串
extraData 1:1 消息附加信息 字符串
timestamp 事件发生时间 字符串
timestampMillis 事件发生时间（Unix 时间戳） 字符串

通知消息

字段名称 描述 类型
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"]; // 移除自定义数据监听器