跳轉至

事件管理

Hive 聊天功能向應用客戶端發送以下四種類型的事件。

  • 連接事件
  • 通道事件
  • 使用者事件
  • 自訂資料事件

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

連接事件

該連接事件與 Hive 聊天插座伺服器連接相關。

連接事件類型

事件名稱 發生時間 描述
OnConnected 當連接成功時 當連接成功時發生。
OnDisconnected 當連接失敗時 當連接失敗時發生。
OnReconnectStarted 當重新連接開始時 當重新連接開始時發生。
OnReconnected 當重新連接成功時 在重新連接嘗試之後發生。如果在聊天套接字伺服器斷開連接後的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() {
        // 斷開連接時
    }

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

- (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 進入的成員的 PlayerID 整數
timestamp 事件發生時間 字串
timestampMillis 事件發生時間（Unix 時間戳） 字串

退出會員

字段名稱 描述 類型
channelId 事件發生的頻道ID 字串
playerId 離開成員的PlayerID 整數
timestamp 事件發生的時間 字串
timestampMillis 事件發生的時間（Unix時間戳） 字串

已刪除的頻道

欄位名稱 描述 類型
channelId 已刪除的頻道 ID 字串
timestamp 事件發生時間 字串
timestampMillis 事件發生時間（Unix 時間戳） 字串

通道通知消息

欄位名稱 描述 類型
channelId 事件發生的頻道ID string
from 通知消息的發送者 string
message 通知消息 string
timestamp 事件發生的時間 string
timestampMillis 事件發生時間（Unix時間戳） string

頻道消息

字段名稱 描述 類型
messageId 唯一的消息識別碼 string
channelId 事件發生的頻道ID string
from 消息發送者 string
to 接收頻道 string
message 消息 string
translated 翻譯狀態 boolean
translatedMessage 翻譯後的消息 string
extraData 頻道消息的附加信息 string
timestamp 事件發生時間 string
replyMessageId 回覆目標消息ID（僅在發送頻道消息時指定回覆目標消息ID時接收） string
replyMessage 回覆目標消息內容（僅在發送頻道消息時指定回覆目標消息ID時接收） string
replyExtraData 回覆目標消息的附加信息（僅在發送頻道消息時指定回覆目標消息ID時接收） string
mentionedPlayerIds 提及的玩家ID list<long>
reactions 反應信息 map<ReactionType, list<long>

反應

字段名稱 描述 類型
channelId 反應事件發生的頻道 ID 字符串
messageId 反應事件發生的消息 ID 字符串
playerId 觸發反應事件的玩家 ID 長整數
type 反應類型 (ReactionType) 枚舉 
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)); // 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
    }

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

null 

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 {
    // channel message received
}

    - (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)); // add user listener

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"]; // 移除自定义数据监听器