イベント管理¶

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

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

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

接続イベント¶

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

接続イベントタイプ¶

イベント名	発生時間	説明
OnConnected	接続が成功したとき	接続が成功したときに発生します。
OnDisconnected	接続が失敗したとき	接続が失敗したときに発生します。
OnReconnectStarted	再接続が開始されたとき	再接続が開始されたときに発生します。
OnReconnected	再接続が成功したとき	再接続の試行後に発生します。チャットソケットサーバーが切断されてから10分以内に再接続リクエストが成功した場合、以前参加していたチャンネルに自動的に参加し、成功したチャンネルのリストと失敗したチャンネルのリストを結果として返します。

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

using hive;

ConnectionHandler connectionHandler = new ConnectionHandler
{
    OnConnected = () =>
    {
        // on connected
    },
    OnDisconnected = () =>
    {
        // on disconnected
    },
    OnReconnectStarted() => 
    {
        // on reconnect Started
    },
    OnReconnected = (ResultAPI result, 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 {
        // 切断時
    }

    virtual void onReconnectStarted() override {
        // on reconnect Started
    }

    virtual void onReconnected(const FHiveResultAPI& Result, const TArray<FString>& ChannelIds, const TArray<FString>& FailChannelIds) override {
        // on reconnected
    }
};

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
    }

    void onReconnectStarted() override {
        // on reconnect Started
    }

    void onReconnected(ResultAPI const & result, std::vector<std::string>channelIds, std::vector<std::string>failChannelIds) override {
        // 再接続時
    }
};

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() {
        // 切断されたとき
    }

    再接続が開始されました。{
        // 再接続が開始されました
    }

    再接続時に関数をオーバーライドする(result: ResultAPI, 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 onReconnectStarted() {
        // on reconnect started
    }

    @Override
    public void onReconnected(@NonNull ResultAPI result, @NonNull ArrayList<String> channelIds, @NonNull ArrayList<String> failChannelIds) {
        // on reconnected
    }
});

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

import HIVEService

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

    func onDisconnected() {
        // on disconnected
    }

    func onReconnectStarted() {
        // on reconnect started
    }

    func onReconnected(result: ResultAPI, channelIds: [String], failChannelIds: [String]) {
        // 再接続時
    }
}

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)onReconnectStarted {
    // 再接続が開始されました
}

- (void)onReconnectedWithResult:(HIVEResultAPI *)result channelIds:(NSArray<NSString *> *)channelIds failChannelIds:(NSArray<NSString *> *)failChannelIds {
    // 再接続時
}

@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

チャンネルメッセージ¶

フィールド名	説明	タイプ
channelId	イベントが発生したチャンネルID	string
from	メッセージ送信者	string
to	受信チャンネル	string
message	メッセージ	string
translated	翻訳ステータス	boolean
translatedMessage	翻訳されたメッセージ	string
extraData	チャンネルメッセージの追加情報	string
timestamp	イベント発生時間	string
timestampMillis	イベント発生時間（Unixタイムスタンプ）	string

ユニティアンリアルエンジン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
    }
};
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 {
        // channel message received
    }

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

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

    virtual void onExitedMember(const FHiveExitedMember& member) override {
        // メンバーが退出しました
    }
};

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

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

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

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

- (void)onDeletedChannel:(Chat.DeletedChannel *)channel {
    // チャンネルが削除されました
}

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

- (void)onChannelMessage:(Chat.ChannelMessage *)message {
    // channel message received
}
@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）。

ダイレクトメッセージ¶

フィールド名	説明	タイプ
from	メッセージ送信者	long
to	メッセージ受信者	long
message	メッセージ	string
extraData	1:1 メッセージ追加情報	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 {
        // notice message received
    }
};

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) {
        // 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"]; // ユーザーリスナーを削除

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

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

Note

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

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

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

ユニティアンリアルエンジンC++コトリンJavaスウィフトオブジェクティブ-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) {
        // 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]]; // カスタムデータリスナーを追加
[ChatInterface removeCustomDataListenerWithUniqueKey:@"UNIQUE_KEY"]; // カスタムデータリスナーを削除