跳轉至

事件管理

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

  • 連接事件
  • 頻道事件
  • 1:1 訊息事件

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

連接事件

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

連接事件類型

事件名稱 發生時間 描述
OnConnected 當連接成功時 當連接成功時發生。
OnDisconnected 當連接失敗時 當連接失敗時發生。 
using hive;

ConnectionHandler connectionHandler = new ConnectionHandler
{
    OnConnected = () =>
    {
        // on connected
    },
    OnDisconnected = () =>
    {
        // on disconnected
    }
};
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
    }
};

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

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() {
        // 斷開連接時
    }
})

    // 移除連接監聽器
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
    }
});

    // 移除連接監聽器
Chat.removeConnectionListener("UNIQUE_KEY"); 

import HIVEService

class ChatConnectionListener: HiveChatConnectionDelegate {
    func onConnected() {
        // on connected
    }

    func onDisconnected() {
        // on disconnected
    }
}

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
}

@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 整數
extraData 額外的成員資訊 字串
timestamp 事件發生時間 字串

退出的成員

欄位名稱 描述 類型
channelId 事件發生的頻道ID string
playerId 退出成員的PlayerID int
extraData 有關成員的附加信息 string
timestamp 事件發生的時間 string

已刪除的頻道

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

通道通知消息

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

頻道訊息

欄位名稱 描述 類型
channelId 事件發生的頻道 ID 字串
from 訊息發送者 字串
fromExtra 有關訊息發送者的附加資訊 字串
to 接收頻道 字串
message 訊息 字串
timestamp 事件發生時間 字串 
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
fromExtra 訊息發送者的附加資訊 string
to 訊息接收者 long
message 訊息 string
timestamp 事件發生時間 string 
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()); // 添加直接消息监听器
Chat::removeDirectMessageListener("UNIQUE_KEY"); // 移除直接消息监听器

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