跳轉至

事件管理

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
    }

    虚拟 void onReconnectStarted() 覆盖 {
        // 在重新连接开始时
    }

    virtual void onReconnected(const FHiveResultAPI& Result, const TArray<FString>& ChannelIds, const TArray<FString>& FailChannelIds) override {
        // on reconnected
    }
};

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
    }

    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) {
        // 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]) {
        // 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 string
playerId 離開成員的PlayerID int
timestamp 事件發生的時間 string
timestampMillis 事件發生的時間（Unix時間戳） string

已刪除的頻道

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

通道通知消息

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

頻道消息

欄位名稱 描述 類型
channelId 事件發生的頻道 ID 字串
from 訊息發送者 字串
to 接收頻道 字串
message 訊息 字串
translated 翻譯狀態 布林值
translatedMessage 翻譯後的訊息 字串
extraData 頻道訊息的附加資訊 字串
timestamp 事件發生時間 字串
timestampMillis 事件發生時間（Unix 時間戳） 字串 
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()) // 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]]; // 添加频道监听器
[ChatInterface removeChannelListenerWithUniqueKey:@"UNIQUE_KEY"]; // 移除频道监听器

使用者事件

用戶事件提供 1:1 消息發送和公告發送事件。

使用者事件類型

事件名稱 發生時間 描述
OnDirectMessage 當收到 1:1 訊息時 當收到 1:1 訊息時發生。它傳遞一個包含 1:1 訊息信息的物件 (DirectMessage).
onNoticeMessage 當收到通知訊息時 當收到通知訊息時發生。它傳遞一個包含通知訊息信息的物件 (NoticeMessage).

直接訊息

欄位名稱 描述 類型
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 byte）		 
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)); // add custom data listener

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()) // add custom data listener
ChatInterface.removeCustomDataListener(uniqueKey: "UNIQUE_KEY") // remove custom data listener

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