事件管理¶

Hive 聊天功能向應用客戶端傳送三種類型的事件。

連接事件
頻道事件
1:1 消息事件

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

連接事件¶

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

連接事件類型¶

事件名稱	發生時間	描述
已連接	當連接成功時	當連接成功時發生。
已斷開連接	當連接失敗時	當連接失敗時發生。
已重新連接	當重新連接成功時	當重新連接成功時發生。當在聊天套接字伺服器斷開連接後的10分鐘內發出重新連接請求時，它會自動嘗試進入之前加入的頻道，並返回成功進入的頻道列表和因故未能進入的頻道列表。

Unity虛幻引擎C++KotlinJavaSwiftObjective-C

using hive;

ConnectionHandler connectionHandler = new ConnectionHandler
{
    OnConnected = () =>
    {
        // on connected
    },
    OnDisconnected = () =>
    {
        // on disconnected
    },
    OnReconnected = (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 onReconnected(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 onReconnected(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 onReconnected(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 onReconnected(@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 onReconnected(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)onReconnectedWithChannelIds:(NSArray<NSString *> * _Nonnull)channelIds failChannelIds:(NSArray<NSString *> * _Nonnull)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	字串
playerId	退出成員的 PlayerID	整數
timestamp	事件發生的時間	字串
timestampMillis	事件發生時間 (Unix 時間戳)	字串

已刪除的頻道¶

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

頻道通知訊息¶

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

通道消息¶

欄位名稱	描述	類型
channelId	事件發生的頻道 ID	字串
from	訊息發送者	字串
to	接收頻道	字串
message	訊息	字串
extraData	頻道訊息的附加資訊	字串
timestamp	事件發生時間	字串
timestampMillis	事件發生時間（Unix 時間戳）	字串

Unity虛幻引擎C++KotlinJavaSwiftObjective-C

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

Chat::addChannelListener("UNIQUE_KEY", new ChannelListenerImpl()); // 添加频道监听器
Chat::removeChannelListener("UNIQUE_KEY"); // 移除频道监听器

import com.hive.Chat;
    // add channel listener
Chat.addChannelListener("UNIQUE_KEY", object: Chat.ChannelListener{
    override fun onEnteredMember(member: Chat.EnteredMember) {
        // member entered
    }

    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	訊息發送者	long
to	訊息接收者	long
message	訊息	string
extraData	頻道訊息附加資訊	string
timestamp	事件發生時間	string
timestampMillis	事件發生時間（Unix 時間戳）	string

Unity虛幻引擎C++KotlinJavaSwiftObjective-C

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()); // add direct message listener
Chat::removeDirectMessageListener("UNIQUE_KEY"); // remove direct message listener

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"]; // 移除直接消息监听器