การจัดการเหตุการณ์¶

ฟีเจอร์แชทของแบรนด์ Hive จะส่งเหตุการณ์สี่ประเภทต่อไปนี้ไปยังไคลเอนต์แอป

เหตุการณ์การเชื่อมต่อ
เหตุการณ์ช่อง
เหตุการณ์ผู้ใช้
เหตุการณ์ข้อมูลที่กำหนดเอง

คุณสามารถรับเหตุการณ์โดยการลงทะเบียนตัวฟังเหตุการณ์ด้วยคีย์ที่กำหนดเอง

เหตุการณ์การเชื่อมต่อ¶

เหตุการณ์การเชื่อมต่อเกี่ยวข้องกับการเชื่อมต่อเซิร์ฟเวอร์ซ็อกเก็ตแชทของ Hive

ประเภทเหตุการณ์การเชื่อมต่อ¶

ชื่อเหตุการณ์	เวลาที่เกิดขึ้น	คำอธิบาย
OnConnected	~~เมื่อการเชื่อมต่อสำเร็จ~~	[Deprecated] เกิดขึ้นเมื่อการเชื่อมต่อสำเร็จ.
OnConnectStarted	เมื่อเริ่มการเชื่อมต่อ	เกิดขึ้นเมื่อเริ่มการเชื่อมต่อ.
OnConnectCompleted	เมื่อการเชื่อมต่อเสร็จสมบูรณ์	เกิดขึ้นหลังจากพยายามเชื่อมต่อ และส่งคืนผลลัพธ์ว่าประสบความสำเร็จหรือไม่.
OnDisconnected	เมื่อการเชื่อมต่อล้มเหลว	เกิดขึ้นเมื่อการเชื่อมต่อล้มเหลว.
OnReconnectStarted	~~เมื่อเริ่มการเชื่อมต่อใหม่~~	[Deprecated] เกิดขึ้นเมื่อเริ่มการเชื่อมต่อใหม่.
OnReconnected	~~เมื่อการเชื่อมต่อใหม่สำเร็จ~~	[Deprecated] เกิดขึ้นหลังจากพยายามเชื่อมต่อใหม่ หากคำขอการเชื่อมต่อใหม่สำเร็จภายใน 10 นาทีหลังจากเซิร์ฟเวอร์ซ็อกเก็ตแชทถูกตัดการเชื่อมต่อ ระบบจะพยายามเข้าร่วมช่องที่เคยเข้าร่วมก่อนหน้านี้โดยอัตโนมัติ จากนั้นจะส่งกลับรายการช่องที่เข้าร่วมสำเร็จและรายการช่องที่ล้มเหลวเป็นผลลัพธ์.

ยูนิตี้Unreal EngineC++โคทลินจาวาSwiftObjective-C

using hive;

ConnectionHandler connectionHandler = new ConnectionHandler
{
    OnConnectStarted() => 
    {
        // on connect started
    },
    OnConnectCompleted() = (ResultAPI result) =>
    {
        // on connect completed
    },
    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 onConnectStarted() override {
        // on connect started
    }

    virtual void onConnectCompleted(const FHiveResultAPI& Result) override {
        // on connect completed
    }

    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 onConnectStarted() override {
        // on connect started
    }

    void onConnectCompleted(ResultAPI const & result) override {
        // on connect completed
    }

    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 onConnectStarted() {
        // on connect started
    }

    override fun onConnectCompleted(result: ResultAPI) {
        // on connect completed
    }

    override fun onDisconnected() {
        // on disconnected
    }

})

// ลบการฟังการเชื่อมต่อ
Chat.removeConnectionListener("UNIQUE_KEY");

import com.hive.Chat;

// เพิ่มตัวฟังการเชื่อมต่อ
Chat.addConnectionListener("UNIQUE_KEY", new Chat.ConnectionListener() {
    @Override
    public void onConnectStarted() {
        // on connect started
    }

    @Override
    public void onConnectCompleted(@NonNull ResultAPI result) {
        // on connect completed
    }

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

});

// ลบการฟังการเชื่อมต่อ
Chat.removeConnectionListener("UNIQUE_KEY");

import HIVEService

class ChatConnectionListener: HiveChatConnectionDelegate {
    func onConnectStarted() {
        // on connect started
    }

    func onConnectCompleted(result: ResultAPI) {
        // on connect completed
    }

    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)onConnectStarted {
    // on connect Started
}

- (void)onConnectCompletedWithResult:(HIVEResultAPI *)result {
    // on connect completed
}

- (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	รหัสช่องที่เกิดเหตุการณ์	string
playerId	รหัสผู้เล่นของสมาชิกที่เข้ามา	int
timestamp	เวลาที่เกิดเหตุการณ์	string
timestampMillis	เวลาที่เกิดเหตุการณ์ (Unix Timestamp)	string

สมาชิกที่ออก¶

ชื่อฟิลด์	คำอธิบาย	ประเภท
channelId	รหัสของช่องที่เกิดเหตุการณ์	string
playerId	PlayerID ของสมาชิกที่ออก	int
timestamp	เวลาที่เกิดเหตุการณ์	string
timestampMillis	เวลาที่เกิดเหตุการณ์ (Unix Timestamp)	string

ช่องที่ถูกลบ¶

ชื่อฟิลด์	คำอธิบาย	ประเภท
channelId	ID ช่องที่ถูกลบ	string
timestamp	เวลาที่เกิดเหตุการณ์	string
timestampMillis	เวลาที่เกิดเหตุการณ์ (Unix Timestamp)	string

ข้อความการแจ้งเตือนช่อง¶

ชื่อฟิลด์	คำอธิบาย	ประเภท
channelId	รหัสของช่องที่เกิดเหตุการณ์	string
from	ผู้ส่งข้อความการแจ้งเตือน	string
message	ข้อความการแจ้งเตือน	string
timestamp	เวลาที่เกิดเหตุการณ์	string
timestampMillis	เวลาที่เกิดเหตุการณ์ (Unix Timestamp)	string

ข้อความช่อง¶

ชื่อฟิลด์	คำอธิบาย	ประเภท
messageId	รหัสประจำข้อความที่ไม่ซ้ำกัน	string
channelId	รหัสช่องที่เกิดเหตุการณ์	string
from	ผู้ส่งข้อความ	string
to	ช่องที่รับข้อความ	string
message	ข้อความ	string
translated	สถานะการแปล	boolean
translatedMessage	ข้อความที่แปล	string
extraData	ข้อมูลเพิ่มเติมสำหรับข้อความในช่อง	string
timestamp	เวลาที่เกิดเหตุการณ์	string
replyMessageId	รหัสข้อความเป้าหมายสำหรับการตอบกลับ (จะได้รับเฉพาะเมื่อมีการระบุรหัสข้อความเป้าหมายในการตอบกลับใน ChannelSendMessageParams เมื่อส่งข้อความในช่อง)	string
replyMessage	เนื้อหาข้อความเป้าหมายสำหรับการตอบกลับ (จะได้รับเฉพาะเมื่อมีการระบุรหัสข้อความเป้าหมายในการตอบกลับใน ChannelSendMessageParams เมื่อส่งข้อความในช่อง)	string
replyExtraData	ข้อมูลเพิ่มเติมสำหรับข้อความเป้าหมายในการตอบกลับ (จะได้รับเฉพาะเมื่อมีการระบุรหัสข้อความเป้าหมายในการตอบกลับใน ChannelSendMessageParams เมื่อส่งข้อความในช่อง)	string
mentionedPlayerIds	รหัสผู้เล่นที่ถูกกล่าวถึง	list<long>
reactions	ข้อมูลการตอบสนอง	map<ReactionType, list<long>

ปฏิกิริยา¶

ชื่อฟิลด์	คำอธิบาย	ประเภท
channelId	รหัสช่องที่เกิดเหตุการณ์การตอบสนอง	string
messageId	รหัสข้อความที่เกิดเหตุการณ์การตอบสนอง	string
playerId	รหัสผู้เล่นที่กระตุ้นเหตุการณ์การตอบสนอง	long
type	ประเภทการตอบสนอง (ReactionType)	enum

UnityUnreal EngineC++โคทลินจาวาSwiftObjective-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
             },
    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 {
        // สมาชิกออก
    }


    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 {
        // สมาชิกออก
    }

    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()); // add channel listener
Chat::removeChannelListener("UNIQUE_KEY"); // remove channel listener

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

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) {
        // สมาชิกออก
    }

    @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) {
        // สมาชิกออก
    }

    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 {
    // สมาชิกออก
}

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

ข้อความแจ้งเตือน¶

ชื่อฟิลด์	คำอธิบาย	ประเภท
จาก	ผู้ส่งข้อความ	string
ข้อความ	ข้อความ	string
เวลา	เวลาที่เกิดเหตุการณ์	string
timestampMillis	เวลาที่เกิดเหตุการณ์ (Unix Timestamp)	string

Unityเอนจินที่ไม่เป็นจริงC++โคทลินJavaSwiftObjective-C

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()); // add user listener
Chat::removeUserListener("UNIQUE_KEY"); // remove user listener

import com.hive.Chat;

// เพิ่มผู้ฟังผู้ใช้
Chat.addUserListener("UNIQUE_KEY", object: Chat.UserListener{
    override fun onDirectMessage(message: Chat.DirectMessage) {
        // ข้อความตรงได้รับ
    }

    override fun onNoticeMessage(message: Chat.NoticeMessage) {
        // notiice message received
    }
})

// ลบผู้ฟังผู้ใช้
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"]; // ลบผู้ฟังผู้ใช้

เหตุการณ์ข้อมูลที่กำหนดเอง¶

SDK ของ Hive มีความสามารถในการรับข้อมูลที่กำหนดเองที่ส่งผ่าน การส่งข้อความที่กำหนดเองของช่องทาง หรือ การส่งข้อความที่กำหนดเองของผู้ใช้ ที่ให้บริการโดย API ของเซิร์ฟเวอร์.

Note

SDK ของ Hive ไม่มีฟังก์ชันการส่งข้อมูลที่กำหนดเอง

ประเภทเหตุการณ์ข้อมูลที่กำหนดเอง¶

ชื่อเหตุการณ์	เวลาที่เกิดขึ้น	คำอธิบาย
OnCustomData	เมื่อได้รับข้อมูลที่กำหนดเอง	เกิดขึ้นเมื่อได้รับข้อมูลที่กำหนดเอง มันส่งข้อมูลที่กำหนดเองประเภท `string`. (สูงสุด `8000 byte`)

ยูนิตี้Unreal EngineC++โคทลินจาวาSwiftObjective-C

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

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]]; // add custom data listener
[ChatInterface removeCustomDataListenerWithUniqueKey:@"UNIQUE_KEY"]; // remove custom data listener