イベント管理¶

Hive チャット機能は、アプリクライアントに以下の4種類のイベントを送信します。

接続イベント
チャンネルイベント
ユーザーイベント
カスタムデータイベント

カスタムキーでイベントリスナーを登録することで、イベントを受信できます。

接続イベント¶

接続イベントは、Hive チャットソケットサーバー接続に関連しています。

接続イベントタイプ¶

イベント名	発生時間	説明
OnConnected	~~接続成功時~~	[Deprecated] 接続成功時に発生します。
OnConnectStarted	接続開始時	接続開始時に発生します。
OnConnectCompleted	接続完了時	接続試行後に発生します。成功可否を結果として返します。
OnDisconnected	接続に失敗したとき	接続に失敗したときに発生します。
OnReconnectStarted	~~再接続開始時~~	[Deprecated] 再接続開始時に発生します。
OnReconnected	~~再接続成功時~~	[Deprecated] 再接続試行後に発生します。チャットソケットサーバーの接続解除後10分以内に再接続リクエストに成功すると、以前参加していたチャンネルへの自動入場を試行します。その後、入場に成功したチャンネル一覧と失敗したチャンネル一覧を結果として返します。

ユニティアンリアルエンジンC++コトリンJavaスウィフトObjective-C

using hive;

ConnectionHandler connectionHandler = new ConnectionHandler
{
    OnConnectStarted() => 
    {
        // 接続開始時
    },
    OnConnectCompleted() = (ResultAPI result) =>
    {
        // 接続完了時
    },
    OnDisconnected = () =>
    {
        // 切断時
    },
};
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 {
        // 接続開始時
    }

    virtual void onConnectCompleted(const FHiveResultAPI& Result) override {
        // 接続完了時
    }

    virtual void onDisconnected() override {
        // 切断時
    }

};

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 {
        // 接続開始時
    }

    void onConnectCompleted(ResultAPI const & result) override {
        // 接続完了時
    }

    void onDisconnected() override {
        // 切断時
    }

};

Chat::addConnectionListener("UNIQUE_KEY", new ConnectionListenerImpl()); // 接続リスナーを追加
Chat::removeConnectionListener("UNIQUE_KEY"); // 接続リスナーを削除

import com.hive.Chat;

// 接続リスナーを追加
Chat.addConnectionListener("UNIQUE_KEY", object : ConnectionListener{
    override fun onConnectStarted() {
        // 接続開始時
    }

    override fun onConnectCompleted(result: ResultAPI) {
        // 接続完了時
    }

    override fun onDisconnected() {
        // 切断時
    }

})

// 接続リスナーを削除する
Chat.removeConnectionListener("UNIQUE_KEY");

import com.hive.Chat;

// 接続リスナーを追加
Chat.addConnectionListener("UNIQUE_KEY", new Chat.ConnectionListener() {
    @Override
    public void onConnectStarted() {
        // 接続開始時
    }

    @Override
    public void onConnectCompleted(@NonNull ResultAPI result) {
        // 接続完了時
    }

    @Override
    public void onDisconnected() {
        // 切断時
    }

});

// 接続リスナーを削除する
Chat.removeConnectionListener("UNIQUE_KEY");

import HIVEService

class ChatConnectionListener: HiveChatConnectionDelegate {
    func onConnectStarted() {
        // 接続開始時
    }

    func onConnectCompleted(result: ResultAPI) {
        // 接続完了時
    }

    func onDisconnected() {
        // 切断時
    }

}

ChatInterface.addConnectionListener(uniqueKey: "UNIQUE_KEY", listener: ChatConnectionListener()) // 接続リスナーを追加
ChatInterface.removeConnectionListener(uniqueKey: "UNIQUE_KEY") // 接続リスナーを削除

#import "HIVEService.h"

@interface ChatConnectionListener : NSObject <HiveChatConnectionDelegate>
@end

@implementation ChatConnectionListener

- (void)onConnectStarted {
    // 接続開始時
}

- (void)onConnectCompletedWithResult:(HIVEResultAPI *)result {
    // 接続完了時
}

- (void)onDisconnected {
    // 切断時
}


@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	string
playerId	入場したメンバーのPlayerID	int
timestamp	イベント発生時間	string
timestampMillis	イベント発生時間（Unixタイムスタンプ）	string

退会メンバー¶

フィールド名	説明	タイプ
channelId	イベントが発生したチャンネルのID	string
playerId	離脱したメンバーのPlayerID	int
timestamp	イベントが発生した時間	string
timestampMillis	イベントが発生した時間（Unixタイムスタンプ）	string

削除されたチャンネル¶

フィールド名	説明	タイプ
channelId	削除されたチャンネルID	string
timestamp	イベント発生時間	string
timestampMillis	イベント発生時間（Unixタイムスタンプ）	string

チャンネル通知メッセージ¶

フィールド名	説明	タイプ
channelId	イベントが発生したチャネルのID	string
from	通知メッセージの送信者	string
message	通知メッセージ	string
timestamp	イベントが発生した時間	string
timestampMillis	イベント発生時間（Unixタイムスタンプ）	string

チャンネルメッセージ¶

フィールド名	説明	タイプ
messageId	ユニークなメッセージ識別子	string
channelId	イベントが発生したチャンネルID	string
from	メッセージ送信者	string
to	受信チャンネル	string
message	メッセージ	string
translated	翻訳ステータス	boolean
translatedMessage	翻訳されたメッセージ	string
extraData	チャンネルメッセージの追加情報	string
timestamp	イベント発生時間	string
replyMessageId	返信対象メッセージID（チャンネルメッセージ送信時にChannelSendMessageParamsで返信対象メッセージIDが指定された場合のみ受信）	string
replyMessage	返信対象メッセージ内容（チャンネルメッセージ送信時にChannelSendMessageParamsで返信対象メッセージIDが指定された場合のみ受信）	string
replyExtraData	返信対象メッセージの追加情報（チャンネルメッセージ送信時にChannelSendMessageParamsで返信対象メッセージIDが指定された場合のみ受信）	string
mentionedPlayerIds	メンションされたプレイヤーID	list<long>
reactions	リアクション情報	map<ReactionType, list<long>

反応¶

フィールド名	説明	タイプ
channelId	リアクションイベントが発生したチャンネルID	string
messageId	リアクションイベントが発生したメッセージID	string
playerId	リアクションイベントをトリガーしたプレイヤーID	long
type	リアクションタイプ（ReactionType）	enum

ユニティアンリアルエンジンC++コトリンJavaスウィフト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
             },
    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 {
        // チャンネル通知メッセージを受信しました
    }

    virtual void onChannelMessage(const FHiveChannelMessage& message) override {
        // チャンネルメッセージを受信しました
    }

    virtual void onDeletedChannel(const FHiveDeletedChannel& channel) override {
        // channel deleted
    }

    virtual void onEnteredMember(const FHiveEnteredMember& member) override {
        // メンバーが参加しました
    }

    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)); // チャンネルリスナーを追加
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 {
        // メンバーが退出しました
    }

    void onDeletedChannel(DeletedChannel const & channel) override {
        // channel deleted
    }

    void onNoticeMessage(ChannelNoticeMessage const & message) override {
        // チャンネル通知メッセージを受信しました
    }

    void onChannelMessage(ChannelMessage const & message) override {
        // channel message received
    }

    void onAddReaction(Reaction const & reaction) override {
        // 反応を追加
    }

    void onRemoveReaction(Reaction const & reaction) override {
        // remove reaction
    }
};

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) {
        // チャンネル通知メッセージを受信しました
    }

    override fun onChannelMessage(message: Chat.ChannelMessage) {
        // チャンネルメッセージを受信しました
    }

            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) {
        // チャンネル通知メッセージを受信しました
    }

    @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) {
        // メンバーが参加しました
    }

    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) {
        // チャンネルメッセージを受信しました
    }

            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 {
    // チャンネル通知メッセージを受信しました
}

- (void)onChannelMessage:(Chat.ChannelMessage *)message {
    // チャンネルメッセージを受信しました
}

    - (void)onAddReaction:(Chat.Reaction *)reaction {
    // 反応を追加する
}

- (void)onRemoveReaction:(Chat.Reaction *)reaction {
    // remove reaction
}

@end

[ChatInterface addChannelListenerWithUniqueKey:@"UNIQUE_KEY" listener:[[ChatChannelListener alloc] init]]; // チャンネルリスナーを追加
[ChatInterface removeChannelListenerWithUniqueKey:@"UNIQUE_KEY"]; // チャンネルリスナーを削除

ユーザーイベント¶

ユーザーイベントでは、ダイレクトメッセージ送信、告知事項送信イベントを伝達します。

ユーザーイベントタイプ¶

イベント名	発生時間	説明
OnDirectMessage	ダイレクトメッセージ受信時	ダイレクトメッセージ受信時に発生します。ダイレクトメッセージ情報を含むオブジェクト(DirectMessage)を渡します。
onNoticeMessage	通知メッセージを受信したとき	通知メッセージが受信されたときに発生します。通知メッセージ情報を含むオブジェクトを配信します（NoticeMessage）。

ダイレクトメッセージ¶

フィールド名	説明	タイプ
messageId	ユニークなメッセージ識別子	string
from	メッセージ送信者	long
to	メッセージ受信者	long
message	メッセージ	string
extraData	ダイレクトメッセージ付加情報	string
timestamp	イベント発生時間	string
timestampMillis	イベント発生時間（Unixタイムスタンプ）	string

お知らせメッセージ¶

フィールド名	説明	タイプ
from	メッセージ送信者	string
message	メッセージ	string
timestamp	イベント発生時間	string
timestampMillis	イベント発生時間（Unixタイムスタンプ）	string

ユニティアンリアルエンジンC++コトリンJavaスウィフトObjective-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 {
        // 直接メッセージを受信しました
    }

    virtual void onNoticeMessage(const FHiveNoticeMessage& message) override {
        // 通知メッセージを受信しました
    }
};

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 {
        // 通知メッセージを受信しました
    }
};

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) {
        // 通知メッセージを受信しました
    }
});

// ユーザーリスナーを削除する
Chat.removeUserListener("UNIQUE_KEY");

import HIVEService

class ChatUserListener: HiveChatUserDelegate {
    func onDirectMessage(_ message: HiveChatParams.DirectMessage) {
        // direct message received
    }

    func onNoticeMessage(_ message: HiveChatParams.NoticeMessage) {
        // 通知メッセージを受信しました
    }
}

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 {
    // 通知メッセージを受信しました
}
@end

[ChatInterface addUserListenerWithUniqueKey:@"UNIQUE_KEY" listener:[[HiveChatUserDelegate alloc] init]]; // ユーザーリスナーを追加
[ChatInterface removeUserListenerWithUniqueKey:@"UNIQUE_KEY"]; // ユーザーリスナーを削除

カスタムデータイベント¶

Hive SDKは、サーバーAPIによって提供されるチャネルカスタムメッセージ送信またはユーザーカスタムメッセージ送信を通じて配信されるカスタムデータを受信する機能を提供します。

Note

Hive SDKはカスタムデータを送信する機能を提供していません。

カスタムデータイベントタイプ¶

イベント名	発生時間	説明
OnCustomData	カスタムデータが受信されたとき	カスタムデータが受信されたときに発生します。タイプ`string`のカスタムデータを送信します。 (最大`8000バイト`)

ユニティアンリアルエンジンC++コトリンJavaスウィフトObjective-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 {
        // カスタムデータを受信しました
    }
};

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) {
        // カスタムデータを受信しました
    }
}

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]]; // カスタムデータリスナーを追加
[ChatInterface removeCustomDataListenerWithUniqueKey:@"UNIQUE_KEY"]; // カスタムデータリスナーを削除