事件管理¶

Hive 聊天功能向应用客户端提供三种类型的事件。

连接事件
渠道事件
1:1 消息事件

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

连接事件¶

连接事件是与 Hive 聊天套接字服务器连接相关的事件。

连接事件类型¶

事件名称	发生时间	描述
连接成功	当连接成功时	当连接成功时发生。
连接失败	当连接失败时	当连接失败时发生。

UnityC++KotlinJava快速Objective-C

using hive;

ConnectionHandler connectionHandler = new ConnectionHandler
{
    OnConnected = () =>
    {
        // on connected
    },
    OnDisconnected = () =>
    {
        // on disconnected
    }
};
Chat.addConnectionHandler("UNIQUE_KEY", connectionHandler);

#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());

import com.hive.Chat;

Chat.addConnectionListener("UNIQUE_KEY", object : ConnectionListener{
    override fun onConnected() {
        // on connected
    }

    override fun onDisconnected() {
        // on disconnected
    }
})

import com.hive.Chat;

Chat.addConnectionListener("UNIQUE_KEY", new Chat.ConnectionListener() {
    @Override
    public void onConnected() {
        // on connected
    }

    @Override
    public void onDisconnected() {
        // on disconnected
    }
});

import HIVEService

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

    func onDisconnected() {
        // 断开连接时
    }
}

ChatInterface.addConnectionListener(uniqueKey: "UNIQUE_KEY", listener: ChatConnectionListener())

#import "HIVEService.h"

@interface ChatConnectionListener : NSObject <HiveChatConnectionDelegate>
@end

@implementation ChatConnectionListener

- (void)onConnected {
    // on connected
}

- (void)onDisconnected {
    // 断开连接时
}

@end

[ChatInterface addConnectionListenerWithUniqueKey:@"UNIQUE_KEY" listener:[[ChatConnectionListener alloc] init]];

渠道事件¶

频道事件传达用户与频道之间发生的所有事件。

渠道事件类型¶

事件名称	发生时间	描述
OnEnteredMember	成员频道参与	当成员加入频道时发生。加入频道时会传递包含参与成员信息的对象 (EnteredMember)。
OnExitedMember	成员频道退出	当成员退出频道时发生。离开频道时会传递包含退出成员信息的对象 (ExitedMember)。
OnDeletedChannel	频道删除	当频道被删除时发生。会传递包含已删除频道信息的对象 (DeletedChannel)。
OnNoticeMessage	通知消息接收	当接收到通知消息时发生。会传递包含通知消息信息的对象 (ChannelNoticeMessage)。
OnChannelMessage	频道消息接收	当接收到频道消息时发生。会传递包含频道消息信息的对象 (ChannelMessage)。

进入的成员¶

字段名称	描述	类型
channelId	事件发生的频道ID	string
playerId	加入成员的PlayerID	int
extraData	额外的成员信息	string
timestamp	事件发生时间	string

退出成员¶

字段名称	描述	类型
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	事件发生时间	字符串

UnityC++KotlinJava快速Objective-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);

#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());

import com.hive.Chat;

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

import com.hive.Chat;

Chat.addChannelListener("UNIQUE_KEY", new Chat.ChannelListener(){
    @Override
    public void onEnteredMember(@NonNull Chat.EnteredMember member) {
        // member entered
    }

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

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

#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]];

1:1 消息事件¶

1:1消息事件传递个人消息发送事件。

1:1 消息事件类型¶

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

直接消息¶

字段名称	描述	类型
from	消息发送者	长整型
fromExtra	消息发送者的附加信息	字符串
to	消息接收者	长整型
message	消息	字符串
timestamp	事件发生时间	字符串

UnityC++KotlinJava迅捷Objective-C

using hive;

DirectMessageHandler directMessageHandler = new DirectMessageHandler
{
    OnDirectMessage = (message) =>
    {
        // direct message received
    }
};
Chat.addDirectMessageHandler("UNIQUE_KEY", directMessageHandler);

#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());

import com.hive.Chat;

Chat.addDirectMessageListener("UNIQUE_KEY", object: Chat.DirectMessageListener{
    override fun onDirectMessage(message: Chat.DirectMessage) {
        // direct message received
    }
})

import com.hive.Chat;

Chat.addDirectMessageListener("UNIQUE_KEY", new Chat.DirectMessageListener() {
    @Override
    public void onDirectMessage(@NonNull Chat.DirectMessage message) {
        // direct message received
    }
});

import HIVEService

class ChatDirectMessageListener: HiveChatDirectMessageDelegate {
    func onDirectMessage(_ message: Chat.DirectMessage) {
        // direct message received
    }
}

ChatInterface.addDirectMessageListener(uniqueKey: "UNIQUE_KEY", listener: ChatDirectMessageListener())

#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]];