イベント管理¶

Hive チャット機能は、アプリクライアントに3種類のイベントを提供します。

接続イベント
チャンネルイベント
1:1 メッセージイベント

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

接続イベント¶

接続イベントは、Hive チャットソケットサーバー接続に関連するイベントです。

接続イベントタイプ¶

イベント名	発生時間	説明
接続時	接続が成功したとき	接続が成功したときに発生します。
切断時	接続に失敗したとき	接続に失敗したときに発生します。
再接続時	再接続が成功したとき	再接続が成功したときに発生します。チャットソケットサーバーの切断後10分以内に再接続リクエストが行われると、以前参加していたチャンネルに自動的に入ろうとし、成功したチャンネルのリストと、入れなかったチャンネルのリストを返します。

ユニティアンリアルエンジンC++コトリンJavaスウィフトオブジェクティブ-C

using hive;

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

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

    virtual void onReconnected(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 onReconnected(std::vector<std::string>channelIds, std::vector<std::string>failChannelIds) override {
        // on reconnected
    }
};

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

    override fun onReconnected(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 onReconnected(@NonNull ArrayList<String> channelIds, @NonNull ArrayList<String> failChannelIds) {
        // 再接続時
    }
});

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

import HIVEService

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

    func onDisconnected() {
        // 切断時
    }

    func onReconnected(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 {
    // 切断時
}

- (void)onReconnectedWithChannelIds:(NSArray<NSString *> * _Nonnull)channelIds failChannelIds:(NSArray<NSString *> * _Nonnull)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
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

```cpp

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 {
    // メンバーが退出しました
}

};

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

    @Override
    public void onChannelMessage(@NonNull Chat.ChannelMessage message) {
        // チャンネルメッセージを受信しました
    }
});

    // チャネルリスナーを削除する
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
    }
}

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 {
    // 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
to	メッセージ受信者	long
message	メッセージ	string
extraData	チャネルメッセージの追加情報	string
timestamp	イベント発生時間	string
timestampMillis	イベント発生時間（Unixタイムスタンプ）	string

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

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

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 {
    // ダイレクトメッセージを受信しました
}
@end

[ChatInterface addDirectMessageListenerWithUniqueKey:@"UNIQUE_KEY" listener:[[ChatDirectMessageListener alloc] init]]; // ダイレクトメッセージリスナーを追加
[ChatInterface removeDirectMessageListenerWithUniqueKey:@"UNIQUE_KEY"]; // ダイレクトメッセージリスナーを削除