Message¶

The Hive chat feature supports channel message sending to send messages to channels the user participates in, and 1:1 message sending to send messages directly to specific individuals.

Channel message sending¶

To send a message to a channel that the user has joined, create a ChannelSendMessageParams object and pass it as an argument to the Chat class's sendMessage() method.

sendMessage() method returns the transmission result and the ChannelSendMessageParams used for sending as retryParam. If the transmission fails, you can attempt to resend using retryParams.

Channelsendmessageparams¶

Field Name	Description	Type	Required
channelId	Channel ID to send the message	string	Y
message	Message to send to the channel (up to 200 characters)	string	Y
extraData	Additional information for the channel message up to 256B Byte (UTF-8)	string	N

This is an example code that sends messages to channels the user has participated in.

UnityUnreal EngineC++KotlinJavaSwiftObjective-C

using hive;

ChannelSendMessageParams channelSendMessageParams = new ChannelSendMessageParams();
channelSendMessageParams.channelId = "CHANNEL_ID";
channelSendMessageParams.message = "Hello Hive";
channelSendMessageParams.extraData = "EXTRA_DATA";

Chat.sendMessage(channelSendMessageParams, (ResultAPI result, ChannelSendMessageParams retryParams) => {
    if (!result.isSuccess()) {
        // Message Send Failed, Try resending using `retryParams`

    }
});

#include "HiveChat.h"

FHiveChatChannelSendMessageParams ChannelSendMessageParams;
ChannelSendMessageParams.ChannelId = TEXT("CHANNEL_ID");
ChannelSendMessageParams.Message = TEXT("Hello Hive");
ChannelSendMessageParams.ExtraData = TEXT("EXTRA_DATA");

FHiveChat::SendMessageWithChannelSendMessageParams(ChannelSendMessageParams, FHiveChatOnResultDelegate::CreateLambda([this](const FHiveResultAPI& Result, const FHiveChatChannelSendMessageParams& RetryParams) {
    if (!Result.IsSuccess) {
        // Message Send Failed, Try resending using `RetryParams`
    }
}));

#include <HIVE_SDK_Plugin/HIVE_CPP.h>
  using namespace hive;

ChannelSendMessageParams params;
params.channelId = "CHANNEL_ID";
params.message = "Hello Hive";
params.extraData = "EXTRA_DATA";

Chat::sendMessageWithChannelSendMessageParams(params, [=](ResultAPI const & result, ChannelSendMessageParams const & retryParams) {
    if (!result.isSuccess()) {
        // Message Send Failed, Try resnding using `retryParams`
    }
});

import com.hive.Chat;
import com.hive.ResultAPI;

val params = Chat.ChannelSendMessageParams(
    channelId = "CHANNEL_ID",
    message = "Hello Hive",
    extraData = "EXTRA_DATA"
)
Chat.sendMessage(params, object: Chat.SendMessageListener {
    override fun onResult(
        result: ResultAPI,
        retryParams: Chat.ChannelSendMessageParams?
    ) {
        if (!result.isSuccess) {
            // Message Send Failed, Try resending using `retryParams`
        }
    }
})

import com.hive.Chat;

Chat.ChannelSendMessageParams params = new Chat.ChannelSendMessageParams(
    "CHANNEL_ID",
    "Hello Hive",
    "EXTRA_DATA"
);

Chat.sendMessage(params, (result, retryParams) -> {
    if(!result.isSuccess()) {
        // Message Send Failed, Try resending using `retryParams`
    }
});

import HIVEService

let params = HiveChatParams.ChannelSendMessageParams(
    channelId = "CHANNEL_ID",
    message = "Hello Hive",
    extraData = "EXTRA_DATA"
)
ChatInterface.sendMessage(params) { result, retryParams in
    if !result.isSuccess {
        // Message Send Failed, Try resending using `retryParams`
    }
}

#import "HIVEService.h"

HiveChatChannelSendMessageParams* sendMessageParams = [[HiveChatChannelSendMessageParams alloc] init];
sendMessageParams.channelId = "CHANNEL_ID";
sendMessageParams.message = "Hello Hive";
sendMessageParams.extraData = "EXTRA_DATA";

[HiveChat sendMessageWithChannelSendMessageParams:sendMessageParams handler:^(HIVEResultAPI * result, HiveChatChannelSendMessageParams * retryParams) {
    if (!result.isSuccess) {
        // Message Send Failed. Try resending using `retryParams`
    }
}];

Channel message event management¶

The sent message can be received by the onChannelMessage event handler of the addChannelListener event. For more details on event handling, please refer to the Event Management > Channel Events document.

1:1 message sending¶

To send a direct message to a specific recipient, the user creates a DirectSendMessageParams object and then passes it as an argument to the Chat class's sendMessage() method.

sendMessage() method returns the transmission result and the DirectSendMessageParams used during transmission under the name retryParam. If the transmission fails, you can attempt to resend using retryParams.

Directsendmessageparams¶

Field Name	Description	Type	Required
toPlayerId	Hive player ID of the target user	long	Y
message	Message to be sent to the target user (up to 200 characters)	string	Y
extraData	Additional information for 1:1 message up to 256B Byte (UTF-8 standard)	string	N

The following is an example code for a user to send a direct message to a specific recipient.

UnityUnreal EngineC++KotlinJavaSwiftObjective-C

using hive;

DirectSendMessageParams directSendMessageParams = new DirectSendMessageParams();
directSendMessageParams.toPlayerId = 12345678;
directSendMessageParams.message = "Hello Hive";
directSendMessageParams.extraData = "EXTRA_DATA";

Chat.sendMessage(directSendMessageParams, (ResultAPI result, DirectSendMessageParams retryParams) => {
    if (!result.isSuccess()) {
        // Message Send Failed, Try resending using `retryParams`

    }
});

#include "HiveChat.h"

FHiveChatDirectSendMessageParams DirectSendMessageParams = FHiveChatDirectSendMessageParams();
DirectSendMessageParams.ToPlayerId = 12345678l;
DirectSendMessageParams.Message = TEXT("Hello Hive");
DirectSendMessageParams.ExtraData = TEXT("EXTRA_DATA");

FHiveChat::SendMessageWithDirectSendMessageParams(DirectSendMessageParams, FHiveChatOnResultDelegate::CreateLambda([this](const FHiveResultAPI& Result, const FHiveChatDirectSendMessageParams& RetryParams) {
    if (!Result.IsSuccess) {
        // Message Send Failed, Try resending using `RetryParams`
    }
}));

#include <HIVE_SDK_Plugin/HIVE_CPP.h>
using namespace hive;

DirectSendMessageParams params;
params.toPlayerId = 12345678;
params.message = "Hello Hive";
params.extraData = "EXTRA_DATA";

Chat::sendMessageWithDirectSendMessageParams(params, [=](ResultAPI const & result, DirectSendMessageParams const & retryParams) {
    if (!result.isSuccess()) {
        // Message Send Failed, Try resnding using `retryParams`
    }
});

import com.hive.Chat;
import com.hive.ResultAPI;

val params = Chat.DirectSendMessageParams(
    toPlayerId = 12345678,
    message = "Hello Hive",
    extraData = "EXTRA_DATA"
)

Chat.sendMessage(params, object: Chat.SendMessageListener {
    override fun onResult(
        result: ResultAPI,
        retryParams: Chat.DirectSendMessageParams?
    ) {
        if (!result.isSuccess) {
            // Message Send Failed, Try resending using `retryParams`
        }
    }
})

import com.hive.Chat;

Chat.DirectSendMessageParams params = new Chat.DirectSendMessageParams(
        12345678,
        "Hello Hive",
        "EXTRA_DATA"
);

Chat.sendMessage(params, (result, retryParams) -> {
    if(!result.isSuccess()) {
        // Message Send Failed, Try resending using `retryParams`
    }
});

import HIVEService

let params = HiveChatParams.DirectSendMessageParams(toPlayerId: Int64(12345678), message: "Hello Hive", extraData: "EXTRA_DATA")

ChatInterface.sendMessage(sendMessageParams: params) { result, retryParams in
    if !result.isSuccess {
        // Message Send Failed, Try resending using `retryParams`
    }
}

#import "HIVEService.h"

HiveChatDirectSendMessageParams* sendMessageParams = [[HiveChatDirectSendMessageParams alloc] init];
sendMessageParams.toPlayerId = 12345678;
sendMessageParams.message = "Hello Hive";
sendMessageParams.extraData = "EXTRA_DATA";

[HiveChat sendDirectMessageWithSendMessageParams:sendMessageParams handler:^(HIVEResultAPI * result, HiveChatDirectSendMessageParams * retryParams) {
    if (!result.isSuccess) {
        // Message Send Failed. Try resending using `retryParams`
    }
}];

1:1 message event management¶

Messages sent through 1:1 message transmission can be received via the onDirectMessage event handler of the addUserListener event. For more details on event handling, please refer to the Event Management > User Events document.

Message translation request¶

Attempting to request a translation for the message. The language code is based on ISO 639 alpha-2 standards.

Translateparams¶

Field Name	Description	Type	Required
message	Message	string	Y
sourceLanguage	The language code of the message. If omitted, it is inferred as `auto`.	string	N
targetLanguages	Array of language codes for translation requests	string array	Y

UnityUnreal EngineC++KotlinJavaSwiftObjective-C

using hive;

List<String> targetLanguages = new List<String>();
targetLanguages.Add("ko");
targetLanguages.Add("ja");
targetLanguages.Add("ar");

TranslateParams translateParams = new TranslateParams("hello", "auto", targetLanguages);

Chat.translate(translateParams, (ResultAPI result, TranslationData data) => {
    if (result.isSuccess() && data != null) {
        // data is translate languages
    }
});

#include "HiveChat.h"

TArray<FString> TargetLanguages;
TargetLanguages.Add(TEXT("ko"));
TargetLanguages.Add(TEXT("ja"));
TargetLanguages.Add(TEXT("ar"));

FHiveChatTranslateParams TranslateParams = FHiveChatTranslateParams(TEXT("hello"), TEXT("auto"), TargetLanguages);

FHiveChat::Translate(TranslateParams, FHiveChatOnResultDelegate::CreateLambda([this](const FHiveResultAPI& Result, const FHiveChatTranslationData& data) {
    if (Result.ISSuccess && data != null) {
        // data is translate language messages
    }
}));

#include <HIVE_SDK_Plugin/HIVE_CPP.h>
using namespace hive;

std::vector<std::string> targetLanguages = { "ko", "ja", "ar" };

Chat::TranslateParams translateParams = new Chat::TranslateParams("hello", "auto", targetLanguages);

Chat::translate(translateParams, [=](ResultAPI const & result, Chat::TranslationData const & data) {
    if (!result.isSuccess() && data != null ) {
        // data is translate language messages
    }
});

import com.hive.Chat;
import com.hive.ResultAPI;

var translateParams = Chat.TranslateParams(
    message = "hello",
    sourceLanguage = "auto",
    targetLanguages = ["ko", "ja", "ar"]
)

Chat.translate(translateParams, object: Chat.TranslateParamsListener {
    override fun onResult(
        result: ResultAPI,
        data: Chat.TranslationData?
    ) {
        if (!result.isSuccess && data != null) {
            // data is translate language maessages
        } 
    }
})

import com.hive.Chat;

Chat.TranslateParams translateParams = new Chat.TranslateParams(
    "hello",
    "auto",
    ["ko", "ja", "ar"]
);

Chat.translate(translateParams, (result, data) -> {
    if(result.isSuccess() && data != null) {
        // data is translate language messages
    }
});

import HIVEService

let translateParams = HiveChatParams.TranslateParams("hello", "auto", ["ko", "ja", "ar"])
ChatInterface.translate(params: translateParams) { result, data in
    if result.isSuccess(), let data {
        // data is translate language messages
    }
}

#import "HIVEService.h"

NSArray<NSString *> *targetLanguages = @[@"ko", @"ja", @"ar"];
HiveChatTranslateParams translateParams = [[HiveChatTranslateParams alloc] message: @"hello"
                                                                           sourceLanguage: @"auto"
                                                                           targetLanguages: targetLanguages];


[HiveChat translateWithParams: translateParams
          handler:^(HIVEResultAPI * result, HiveChatTranslationData * data) {
            if (result.isSuccess && data) {
                // data is translate language messages
            }
          }];