실시간 채팅

실시간 채팅을 통해 라이브 커뮤니티가 쉽게 활성화됩니다.

사용자는 1대1로 또는 그룹의 일부로 또는 채팅방에서 채팅할 수 있습니다. 메시지에는 이미지, 링크 및 기타 컨텐츠를 포함시킬 수 있습니다. 수신자가 온라인 상태면 이러한 메시지는 즉시 클라이언트에게 전달되고 메시지 기록에 저장되므로 오프라인 사용자가 온라인 상태가 되면 쉽게 확인할 수 있습니다.

실시간 채팅 엔진을 통해 전달되는 모든 메시지는 메시지를 받을 사용자를 내부적으로 식별하기 위해 사용되는 채널에 속합니다. 사용자는 연결될 때 채널을 명시적으로 가입하고 탈퇴합니다. 이렇게 하면 관심있는 메시지를 선택적으로 듣거나 또는 사용 중인 특정 채널을 쉽게 “음소거"할 수 있습니다. 사용자는 한 번에 여러 채널에 가입하여 여러 그룹이나 채팅방에서 동시에 채팅할 수도 있습니다.

채팅 채널 #

채널에는 3 가지 유형이 있습니다:

채팅방은 공개적인 채팅에 좋습니다. 어떤 사용자도 허가없이 가입하고 참여할 수 있습니다. 이런 채팅방은 동시 커뮤니케이션에서 수백만 명의 사용자로 확장될 수 있습니다. 라이브 참여 앱 또는 라이브 이벤트 또는 토너먼트가 있는 게임에 적합합니다.
그룹 채팅은 그룹의 사용자에게만 공개됩니다. 각 사용자는 그룹의 구성원이어야 하며 다른 사용자는 참여할 수 없습니다. 팀 기반 게임 플레이 또는 협업에서 그룹 채팅을 사용할 수 있습니다.
직접 채팅은 두 사용자에게만 공개됩니다. 각 사용자는 채팅에 초대되면 알림이 전달됩니다. 나쁜 사용자의 스팸을 방지하기 위해 메시지를 교환하려면 두 사용자 모두 가입해야 합니다.

지속성 #

기본적으로 모든 채널은 영구적이므로 채널을 통해 주고 받은 메시지는 데이터베이스에 저장되며 나중에 메시지 기록에서 사용할 수 있습니다. 이 기록을 통해 오프라인 사용자는 확인하지 못한 메시지를 다음에 연결한 후 확인할 수 있습니다.

메시지를 온라인 사용자에게만 보내고 메시지 기록에 보관하지 않기 위해 클라이언트는 지속성이 비활성화된 채널에 가입할 수 있습니다.

숨겨진 채널 구성원 #

기본적으로 채널에 가입하는 모든 사용자는 다른 사용자에게 표시됩니다. 기존 채널 참가자는 사용자가 연결 및 연결 해제될 때 이벤트를 받으며 새로운 채널 가입자는 이미 채널에 있는 사용자 목록을 받습니다.

사용자는 연결할 때 자신의 채널 존재를 숨기도록 선택할 수 있으므로 사용자의 가입/탈퇴 알림이 생성되지 않고 사용자가 채널 구성원 목록에 표시되지 않습니다. 이런 경우에도 사용자는 평소처럼 실시간 메시지를 주고 받을 수 있습니다.

채팅 가입 #

다른 사용자에게 메시지를 보내려면 사용자는 통신할 채팅 채널에 가입해야 합니다. 이렇게 하면 실시간으로 메시지를 받을 수도 있습니다.

각 사용자는 자신의 세션으로 다양한 방, 그룹 및 직접 채팅에 가입할 수 있습니다. 각 장치는 별도의 세션으로 식별되므로 한 사용자가 다른 장치에서 같은 채팅에 연결할 수도 있습니다.

채팅방 #

채팅방은 사용자가 채팅할 수 있게 동적으로 생성됩니다. 채팅방에는 이름이 있으며 사용자가 가입할 때 서버에 설정됩니다. 가입할 수 있는 채팅방 이름 목록은 클라이언트 코드에 저장하거나 저장소 기록으로 원격 구성을 통해 저장할 수 있습니다.

Client
1
2
3
4
5
6
7
8
const roomname = "MarvelMovieFans";
const persistence = true;
const hidden = false;

// 1 = Room, 2 = Direct Message, 3 = Group
const response = await socket.joinChat(roomname, 1, persistence, hidden);

console.log("Now connected to channel id: '%o'", response.channel.id);

Client
1
2
3
4
5
var roomname = "MarvelMovieFans";
var persistence = true;
var hidden = false;
var channel = await socket.JoinChatAsync(roomname, ChannelType.Room, persistence, hidden);
Console.WriteLine("Now connected to channel id: '{0}'", channel.Id);

Client
1
2
3
4
5
6
7
auto successCallback = [](NChannelPtr channel)
{
    std::cout << "Now connected to channel id: " << channel->id << std::endl;
};

string roomname = "MarvelMovieFans";
rtClient->joinChat(roomname, NChannelType::ROOM, true, false, successCallback);

Client
1
2
3
4
5
String roomname = "MarvelMovieFans";
boolean persistence = true;
boolean hidden = false;
Channel channel = socket.joinChat(roomname, ChannelType.ROOM, persistence, hidden).get();
System.out.format("Now connected to channel id: %s", channel.getId());

Client
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
var roomname = "MarvelMovieFans"
var persistence = true
var hidden = false
var type = NakamaSocket.ChannelType.Room
var channel : NakamaRTAPI.Channel = yield(socket.join_chat_async(roomname, type, persistence, hidden), "completed")

if channel.is_exception():
    print("An error occurred: %s" % channel)
    return

print("Now connected to channel id: '%s'" % [channel.id])

roomId 변수에는 메시지를 보내는 데 사용되는 ID가 포함됩니다.

그룹 #

그룹 채팅은 그룹의 구성원인 사용자만 가입할 수 있습니다. 메시지는 실시간으로 그룹 구성원에게 푸시되며 구성원들은 기록 메시지를 읽을 수 있습니다. 쫓겨나거나 그룹을 나간 사용자는 더 이상 메시지를 받거나 기록을 읽을 수 없습니다.

그룹 채팅에 가입하는 사용자는 그룹 ID가 필요하며 사용자는 이를 나열할 수 있습니다.

Client
1
2
3
4
5
6
7
const groupId = "<group id>";
const persistence = true;
const hidden = false;
// 1 = Room, 2 = Direct Message, 3 = Group
const response = await socket.joinChat(3, groupId, persistence, hidden);

console.log("You can now send messages to channel id: ", response.channel.id);

Client
1
2
3
4
5
var groupId = "<group id>";
var persistence = true;
var hidden = false;
var channel = await socket.JoinChatAsync(groupId, ChannelType.Group, persistence, hidden);
Console.WriteLine("You can now send messages to channel id: '{0}'", channel.Id);

Client
1
2
3
4
5
6
7
auto successCallback = [](NChannelPtr channel)
{
    std::cout << "You can now send messages to channel id: " << channel->id << std::endl;
};

string groupId = "<group id>";
rtClient->joinChat(groupId, NChannelType::GROUP, true, false, successCallback);

Client
1
2
3
4
5
String groupId = "<group id>";
boolean persistence = true;
boolean hidden = false;
Channel channel = socket.joinChat(groupId, ChannelType.GROUP, persistence, hidden).get();
System.out.format("You can now send messages to channel id %s", channel.getId());

Client
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
var group_id = "<group id>"
var persistence = true
var hidden = false
var type = NakamaSocket.ChannelType.Group
var channel : NakamaRTAPI.Channel = yield(socket.join_chat_async(group_id, type, persistence, hidden), "completed")

if channel.is_exception():
    print("An error occurred: %s" % channel)
    return

print("Now connected to channel id: '%s'" % [channel.id])

"<group id>" 변수는 메시지를 보내는데 사용되는 ID여야 합니다.

직접 #

사용자는 ID를 통해 다른 사용자에게 메시지를 직접 보낼 수 있습니다. 친구, 그룹, 순위표, 매치메이커, 채팅방 및 저장소 검색은 모두 채팅할 사용자를 찾는 방법입니다.

두 사용자가 모두 채팅에 가입할 때까지 실시간으로 메시지가 전달되지 않습니다. 이렇게 하면 나쁜 사용자가 보내는 스팸 메시지가 방지되므로 중요합니다.

다른 사용자를 직접 채팅에 초대하려면:

Client
1
2
3
4
5
6
const userId = "<user id to invite>";
const persistence = true;
const hidden = false;
// 1 = Room, 2 = Direct Message, 3 = Group
const response = await socket.joinChat(userId, 2, persistence, hidden);
console.log("You can now send messages to channel id:", response.channel.id);

Client
1
2
3
4
5
var userId = "<user id to invite>";
var persistence = true;
var hidden = false;
var channel = await socket.JoinChatAsync(userId, ChannelType.DirectMessage, persistence, hidden);
Console.WriteLine("You can now send messages to channel id: '{0}'", channel.Id);

Client
1
2
3
4
5
6
7
auto successCallback = [](NChannelPtr channel)
{
    std::cout << "You can now send messages to channel id: " << channel->id << std::endl;
};

string userId = "<user id to invite>";
rtClient->joinChat(userId, NChannelType::DIRECT_MESSAGE, true, false, successCallback);

Client
1
2
3
4
5
String userId = "<user id to invite>";
boolean persistence = true;
boolean hidden = false;
Channel channel = socket.joinChat(userId, ChannelType.DIRECT_MESSAGE, persistence, hidden).get();
System.out.format("You can now send messages to channel id %s", channel.getId());

Client
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
var user_id = "<user id to invite>"
var persistence = true
var hidden = false
var type = NakamaSocket.ChannelType.DirectMessage
var channel : NakamaRTAPI.Channel = yield(socket.join_chat_async(user_id, type, persistence, hidden), "completed")

if channel.is_exception():
    print("An error occurred: %s" % channel)
    return

print("Now connected to channel id: '%s'" % [channel.id])

채팅 요청이 들어오면 사용자는 인앱 알림을 받게 됩니다. 초대를 수락하려면 사용자는 요청하는 사용자를 대상으로 동일한 joinChat 요청으로 응답합니다.

Client
1
2
3
4
5
6
const userId = "<user id of requestor>";
const persistence = true;
const hidden = false;
// 1 = Room, 2 = Direct Message, 3 = Group
const response = await socket.joinChat(userId, 2, persistence, hidden);
console.log("You can now send messages to channel id:", response.channel.id);

Client
1
2
3
4
5
var userId = "<user id of requestor>";
var persistence = true;
var hidden = false;
var channel = await socket.JoinChatAsync(userId, ChannelType.DirectMessage, persistence, hidden);
Console.WriteLine("You can now send messages to channel id: '{0}'", channel.Id);

Client
1
2
3
4
5
6
7
auto successCallback = [](NChannelPtr channel)
{
    std::cout << "You can now send messages to channel id: " << channel->id << std::endl;
};

string userId = "<user id of requestor>";
rtClient->joinChat(userId, NChannelType::DIRECT_MESSAGE, true, false, successCallback);

Client
1
2
3
4
5
String userId = "<user id of requestor>";
boolean persistence = true;
boolean hidden = false;
Channel channel = socket.joinChat(userId, ChannelType.DIRECT_MESSAGE, persistence, hidden).get();
System.out.format("You can now send messages to channel id %s", channel.getId());

Client
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
var user_id = "<user id of requestor>"
var persistence = true
var hidden = false
var type = NakamaSocket.ChannelType.DirectMessage
var channel : NakamaRTAPI.Channel = yield(socket.join_chat_async(user_id, type, persistence, hidden), "completed")

if channel.is_exception():
    print("An error occurred: %s" % channel)
    return

print("Now connected to channel id: '%s'" % [channel.id])

"<user id>" 변수는 메시지를 보내는데 사용되는 ID여야 합니다.

사용자는 원치 않는 직접 메시지를 중지하기 위해 다른 사용자를 차단할 수 있습니다.

온라인 사용자 나열 #

채팅에 가입하는 각 사용자는 채팅 채널에서 “현재 상태"가 됩니다(“숨겨진” 채널 사용자로 참여하지 않은 경우). 이러한 현재 상태를 통해 온라인 상태인 사용자를 확인할 수 있습니다.

현재 상태는 사용자 ID와 결합된 고유한 세션으로 구성됩니다. 이렇게 하면 채팅 채널에서 여러 장치를 사용하여 연결한 사용자를 쉽게 구별할 수 있습니다.

채팅 채널에 가입하는 사용자에게는 채팅 채널에서 연결된 다른 모든 사용자의 초기 현재 상태 목록이 제공됩니다. 콜백을 사용하여 가입 및 탈퇴하는 사용자의 현재 상태 변경 사항을 서버에서 받을 수 있습니다. 이렇게 하면 온라인 사용자 목록을 쉽게 유지 관리하고 변경 사항이 있을 때 업데이트할 수 있습니다.

서버는 다른 사용자가 채팅에 가입하거나 탈퇴할 때만 현재 상태 업데이트를 푸시하도록 최적화되어 있습니다.

Client
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
var onlineUsers = [];
socket.onchannelpresence = (presences) => {
  // Remove all users who left.
  onlineUsers = onlineUsers.filter((user) => {
    return !presences.leave.includes(user);
  });
  // Add all users who joined.
  onlineUsers.concat(presences.join);
};

const roomname = "PizzaFans";
const persistence = true;
const hidden = false;

// 1 = Room, 2 = Direct Message, 3 = Group
const response = await socket.joinChat(roomname, 1, persistence, hidden);

// Setup initial online user list.
onlineUsers.concat(response.channel.presences);
// Remove your own user from list.
onlineUsers = onlineUsers.filter((user) => {
  return user != channel.self;
});

Client
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
var roomUsers = new List<IUserPresence>(10);
socket.ReceivedChannelPresence += presenceEvent =>
{
    foreach (var presence in presenceEvent.Leaves)
    {
        roomUsers.Remove(presence);
    }

    roomUsers.AddRange(presenceEvent.Joins);
    Console.WriteLine("Room users: [{0}]", string.Join(",\n  ", roomUsers));
};

var roomName = "PizzaFans";
var persistence = true;
var hidden = false;
var channel = await socket.JoinChatAsync(roomName, ChannelType.Room, persistence, hidden);
roomUsers.AddRange(channel.Presences);

Client
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
// add this to your class: std::vector<NUserPresence> onlineUsers;

rtListener->setChannelPresenceCallback([this](const NChannelPresenceEvent& event)
{
    // Remove all users who left.
    for (auto& left : event.leaves)
    {
        for (auto it = onlineUsers.begin(); it != onlineUsers.end(); ++it)
        {
            if (it->userId == left.userId)
            {
                onlineUsers.erase(it);
                break;
            }
        }
    }

    // Add all users who joined.
    onlineUsers.insert(onlineUsers.end(), event.joins.begin(), event.joins.end());
});

auto successCallback = [this](NChannelPtr channel)
{
    onlineUsers.reserve(channel->presences.size());

    // Setup initial online user list without self.
    for (auto& joined : channel->presences)
    {
        if (joined.userId != channel->self.userId)
        {
           onlineUsers.push_back(joined);
        }
    }
};

string roomname = "PizzaFans";
rtClient->joinChat(roomname, NChannelType::ROOM, true, false, successCallback);

Client
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
final List<UserPresence> connectedUsers = new ArrayList<UserPresence>();
SocketListener listener = new AbstractSocketListener() {
    @Override
    public void onChannelPresence(final ChannelPresenceEvent presence) {
        connectedUsers.addAll(presence.getJoins());
        for (UserPresence presence : presence.getLeaves()) {
            for (int i = 0; i < connectedUsers.size(); i++) {
                if (connectedUsers.get(i).getUserId().equals(presence.getUserId())) {
                    connectedUsers.remove(i);
                }
            }
        }
    }
};

String roomname = "PizzaFans";
boolean persistence = true;
boolean hidden = false;
Channel channel = socket.joinChat(roomname, ChannelType.ROOM, persistence, hidden);
connectedUsers.addAll(channel.getPresences());

Client
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
var room_users = {}

func _ready():
  # First, setup the socket as explained in the authentication section.
  socket.connect("received_channel_presence", self, "_on_channel_presence")

  # Connect to the room.
  var roomname = "MarvelMovieFans"
  var persistence = true
  var hidden = false
  var type = NakamaSocket.ChannelType.Room
  var channel : NakamaRTAPI.Channel = yield(socket.join_chat_async(roomname, type, persistence, hidden), "completed")

  if channel.is_exception():
      print("An error occurred: %s" % channel)
      return

  # Add users already present in chat room.
  for p in channel.presences:
      room_users[p.user_id] = p

  print("Users in room: %s" % [room_users.keys()])

func _on_channel_presence(p_presence : NakamaRTAPI.ChannelPresenceEvent):
  for p in p_presence.joins:
      room_users[p.user_id] = p

  for p in p_presence.leaves:
      room_users.erase(p.user_id)

  print("Users in room: %s" % [room_users.keys()])

메시지 받기 #

사용자가 채팅 채널에 가입하여 실시간으로 메시지를 수신하기 시작합니다. 새 메시지는 각각 이벤트 핸들러에서 수신하고 UI에 추가할 수 있습니다. 메시지는 서버에서 처리한 순서대로 전달됩니다.

Client
1
2
3
4
5
6
socket.ReceivedChannelMessage += message =>
{
    Console.WriteLine("Received: {0}", message);
    Console.WriteLine("Message has channel id: {0}", message.ChannelId);
    Console.WriteLine("Message content: {0}", message.Content);
};

Client
1
2
3
4
5
6
7
SocketListener listener = new AbstractSocketListener() {
    @Override
    public void onChannelMessage(final ChannelMessage message) {
        System.out.format("Received a message on channel %s", message.getChannelId());
        System.out.format("Message content: %s", message.getContent());
    }
};

Client
1
2
3
4
5
6
7
8
func _ready():
    # First, setup the socket as explained in the authentication section.
    socket.connect("received_channel_message", self, "_on_channel_message")

func _on_channel_message(p_message : NakamaAPI.ApiChannelMessage):
    print(p_message)
    print("Received a message on channel: %s" % [p_message.channel_id])
    print("Message content: %s" % [p_message.content])

그룹 #

그룹 채팅의 경우 사용자는 서버로부터 다른 메시지를 받습니다. 이 메시지에는 그룹에 가입하거나 탈퇴하는 사용자에 대한 이벤트, 누군가가 관리자로 승격되는 경우 등이 포함됩니다. 사용자가 채팅 스트림에서 이러한 메시지를 보거나 UI에서 무시하도록 지정할 수 있습니다.

Type 메시지로 채팅 메시지와 이벤트 메시지를 식별할 수 있습니다.


Code	Purpose	Source	Description
0	Chat Message	User	사용자가 보낸 모든 메시지.
1	Chat Update	User	이전에 보낸 메시지를 업데이트하는 사용자.
2	Chat Remove	User	이전에 보낸 메시지를 제거하는 사용자.
3	Joined Group	Server	사용자가 그룹에 참여했을 때의 이벤트 메시지.
4	Added to Group	Server	사용자가 그룹에 추가되었을 때의 이벤트 메시지.
5	Left Group	Server	사용자가 그룹을 떠났을 때의 이벤트 메시지.
6	Kicked from Group	Server	관리자가 그룹에서 사용자를 강퇴시켰을 때의 이벤트 메시지.
7	Promoted in Group	Server	사용자가 그룹 관리자로 승격될 때의 이벤트 메시지.
8	Banned in Group	Server	사용자가 그룹에서 차단되었을 때의 이벤트 메시지.
9	Demoted in Group	Server	사용자가 그룹에서 강등되었을 때의 이벤트 메시지.

메시지 보내기 #

사용자가 채팅 채널에 가입하면 해당 ID를 사용하여 JSON 인코딩 문자열로 메시지를 보낼 수 있습니다.

전송된 모든 메시지는 서버에서 수신할 때 승인을 반환합니다. 반환된 승인에는 메시지 ID, 타임스탬프 및 메시지를 보낸 사용자에 대한 세부 정보가 포함됩니다.

Client
1
2
3
4
5
6
7
8
auto successCallback = [](const NChannelMessageAck& ack)
{
    std::cout << "message id: " << ack.messageId << std::endl;
};

string channelId = "<channel id>";
string data = "{ "some": "data" }";
rtClient->writeChatMessage(channelId, data, successCallback);

Client
1
2
3
4
5
6
7
8
9
var channel_id = "<channel id>"
var data = { "some": "data" }
var message_ack : NakamaRTAPI.ChannelMessageAck = yield(socket.write_chat_message_async(channel_id, data), "completed")

if message_ack.is_exception():
    print("An error occurred: %s" % message_ack)
    return

print("Sent message %s" % [message_ack])

메시지 컨텐츠 필터링 #

모욕적이거나 공격적인 행위를 방지하기 위해 채팅 채널에서 사용자의 메시지를 필터링하는 것이 일반적입니다. 이는 서버 런타임 코드에 후크를 사용하여 부적절한 컨텐츠가 포함된 메시지를 삭제하거나 거부함으로써 Nakama에서 달성할 수 있습니다.

이 코드는 메시지가 전송될 때 서버에서 트리거됩니다.

Server
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
// Inside your Go module's `InitModule` function.
if err := initializer.RegisterBeforeRt("ChannelMessageSend", func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, envelope *rtapi.Envelope) (*rtapi.Envelope, error) {
  message := envelope.GetChannelMessageSend()
  if strings.Contains(message.Content, "bad word") {
    // Alternatively, to sanitize instead of reject:
    // message.Content = strings.ReplaceAll(message.Content, "bad word", "****")

    // Reject the message send:
    return nil, runtime.NewError("profanity detected", 3)
  }
  return envelope, nil
}); err != nil {
  return err
}

Server
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
let rtBeforeChannelMessageSend: nkruntime.RtBeforeHookFunction<nkruntime.Envelope> = function (ctx: nkruntime.Context, logger: nkruntime.Logger, nk: nkruntime.Nakama, envelope: nkruntime.Envelope) : nkruntime.Envelope {
    let e = envelope as nkruntime.EnvelopeChannelMessageSend;
    if (e == null)
    {
        return e;
    }

    if (e.channelMessageSend.content.indexOf('Bad Word') !== -1) {
        // Alternatively, to sanitize instead of reject:
        //e.channelMessageSend.content = e.channelMessageSend.content.replace('Bad Word', '****');

        // Reject the message send.
        throw new Error("Profanity detected");
    }

    return e;
}

initializer.registerRtBefore("ChannelMessageSend", rtBeforeChannelMessageSend);

위 예의 경우, 고유한 필터링 기준(“악성 단어” 인덱스)을 만들고 유지 관리하면서 원하는 경우 타사 필터링 API와의 통합도 선택할 수 있습니다.

채팅 나가기 #

사용자는 더 이상 실시간으로 메시지를 보내지 않기 위해 채팅 채널을 나갈 수 있습니다. 이는 UI의 다른 부분에 있는 동안 채팅을 “음소거"하는데 유용할 수 있습니다.

Client
1
2
3
4
5
6
7
8
var channel_id = "<channel id>"
var result : NakamaAsyncResult = yield(socket.leave_chat_async(channel_id), "completed")

if result.is_exception():
    print("An error occurred: %s" % result)
    return

print("Left chat")

메시지 기록 #

모든 채팅 대화에서 메시지 기록은 저장됩니다(지속성이 false로 설정되지 않은 경우). 이 기록에는 서버가 그룹 채팅 채널에 보낸 이벤트 메시지도 포함됩니다. 각 사용자는 다음에 온라인으로 연결할 때 채널의 이전 메시지를 검색할 수 있습니다. 사용자는 채팅 기록을 보기 위해 채팅 채널에 가입할 필요가 없습니다. 이는 사용자가 채팅에 온라인으로 표시되지 않은 상태에서 메시지를 “미리 보기"하는데 유용합니다.

메시지는 최신 순 또는 역순(오래된 것에서 가장 최근 것)으로 나열될 수도 있습니다. 메시지는 더 많은 메시지가 있는 경우 커서를 포함하여 각각 최대 100개의 배치로 반환됩니다.

Client
1
2
3
4
5
6
7
8
const channelId = "<channel id>";
const result = await client.listChannelMessages(session, channelId, 10);

result.messages.forEach((message) => {
  console.log("Message has id %o and content %o", message.message_id, message.data);
});

console.log("Get the next page of messages with the cursor:", result.next_cursor);

Client
1
2
3
4
5
6
7
var channelId = "<channel id>";
var result = await client.ListChannelMessagesAsync(session, channelId, 10, true);

foreach (var m in result.Messages)
{
    Console.WriteLine("Message id '{0}' content '{1}'", m.MessageId, m.Content);
}

Client
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
auto successCallback = [](NChannelMessageListPtr list)
{
    for (auto& message : list->messages)
    {
        std::cout << "message content: " << message.content << std::endl;
    }

    std::cout << "Get the next page of messages with the cursor: " << list->nextCursor << std::endl;
};

string channelId = "<channel id>";
client->listChannelMessages(session, channelId, 10, opt::nullopt, opt::nullopt, successCallback);

Client
1
2
3
4
5
6
String channelId = "<channel id>";
ChannelMessageList messages = client.listChannelMessages(session, channelId, 10).get();

for (ChannelMessage message : messages.getMessagesList()) {
    System.out.format("Message content: %s", message.getContent());
}

Client
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
var channel_id = "<channel id>"
var result : NakamaAPI.ApiChannelMessageList = yield(client.list_channel_messages_async(session, channel_id, 10), "completed")

if result.is_exception():
    print("An error occurred: %s" % result)
    return

for m in result.messages:
    var message : NakamaAPI.ApiChannelMessage = m as NakamaAPI.ApiChannelMessage
    print("Message has id %s and content %s" % [message.message_id, message.content])

print("Get the next page of messages with the cursor: %s" % [result.next_cursor])

커서를 사용하여 다음 결과 세트를 위해 메시지 배치 처리 후 페이징할 수 있습니다.

UI에는 최근 100개의 메시지만 나열하는 것이 좋습니다. 좋은 사용자 경험은 사용자가 UI 패널의 맨 아래로 스크롤할 때 다음 100개의 오래된 메시지를 표시하는 것입니다.

Client
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
var channelId = "<channel id>";
var forward = true;
var result = await client.listChannelMessages(session, channelId, 10, forward);

result.messages.forEach((message) => {
  console.log("Message has id %o and content %o", message.message_id, message.data);
});

if (result.next_cursor) {
  // Get the next 10 messages.
  var result = await client.listChannelMessages(session, channelId, 10, forward, result.next_cursor);

  result.messages.forEach((message) => {
    console.log("Message has id %o and content %o", message.message_id, message.data);
  });
}

Client
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
var channelId = "<channel id>";
var result = await client.ListChannelMessagesAsync(session, channelId, 10, true);

foreach (var m in result.Messages)
{
    Console.WriteLine("Message id '{0}' content '{1}'", m.MessageId, m.Content);
}

if (!string.IsNullOrEmpty(result.NextCursor)) {
    // Get the next 10 messages.
    var result = await client.ListChannelMessagesAsync(session, channelId, 10, true, result.NextCursor);
    foreach (var m in messages)
    {
        Console.WriteLine("Message id '{0}' content '{1}'", m.MessageId, m.Content);
    }
};

Client
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
void YourClass::listChannelMessages(const std::string& cursor)
{
    auto successCallback = [this](NChannelMessageListPtr list)
    {
        for (auto& message : list->messages)
        {
            std::cout << "message content: " << message.content << std::endl;
        }

        if (!list->nextCursor.empty())
        {
            listChannelMessages(list->nextCursor);
        }
    };

    string channelId = "<channel id>";
    client->listChannelMessages(session, channelId, 10, cursor, true, successCallback);
}

listChannelMessages("");

Client
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
String channelId = "<channel id>";
ChannelMessageList messages = client.listChannelMessages(session, channelId, 10).get();

if (messages.getNextCursor() != null) {
    messages = client.listChannelMessages(session, channelId, 10, messages.getNextCursor()).get();

    for (ChannelMessage message : messages.getMessagesList()) {
        System.out.format("Message content: %s", message.getContent());
    }
  }

Client
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
var channel_id = "<channel id>"
var forward = true
var result : NakamaAPI.ApiChannelMessageList = yield(client.list_channel_messages_async(session, channel_id, 10, forward), "completed")

if result.is_exception():
    print("An error occurred: %s" % result)
    return

for m in result.messages:
    var message : NakamaAPI.ApiChannelMessage = m as NakamaAPI.ApiChannelMessage
    print("Message has id %s and content %s" % [message.message_id, message.content])

if result.next_cursor:
    result = yield(client.list_channel_messages_async(session, channel_id, 10, forward, result.next_cursor), "completed")

    if result.is_exception():
        print("An error occurred: %s" % result)
        return

    for m in result.messages:
        var message : NakamaAPI.ApiChannelMessage = m as NakamaAPI.ApiChannelMessage
        print("Message has id %s and content %s" % [message.message_id, message.content])

캐시 가능한 커서 #

클라이언트가 목록을 마지막으로 검색한 이후에 추가된 메시지만 검색하는 것이 더 좋을 수 있습니다. 이는 각 채널 메시지와 함께 반환된 캐시 가능한 커서로 수행할 수 있습니다. 새 목록 작업을 통해 커서를 보내면 표시된 메시지보다 더 최신인 메시지만 검색합니다.

캐시 가능한 커서는 검색된 가장 최근 채널 메시지의 위치를 표시합니다. 캐시 가능한 커서를 장치 저장소에 저장하고 클라이언트가 최근 알림에 대한 다음 요청을 실시할 때 사용하는 것이 좋습니다.

Client
1
2
3
4
5
6
const cacheableCursor = "<cacheableCursor>";
const channelId = "<channelId>";
const result = await client.listChannelMessages(channelId, 10, cacheableCursor);
result.messages.forEach((message) => {
  console.log("Message has id %o and content %o", message.message_id, message.data);
});

Client
1
2
3
4
5
6
7
const string cacheableCursor = "<cacheableCursor>";
const string channelId = "<channelId>";
var result = await client.ListChannelMessagesAsync(session, channelId, 10, true, cacheableCursor);
foreach (var m in result.Messages)
{
    Console.WriteLine("Message id '{0}' content '{1}'", m.MessageId, m.Content);
}

Client
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
auto successCallback = [this](NChannelMessageListPtr list)
{
    for (auto& message : list->messages)
    {
        std::cout << "Message content " << message.content << std::endl;
    }
};

string channelId = "<channelId>";
string cacheableCursor = "<cacheableCursor>";
client->listChannelMessages(session, channelId, 10, cacheableCursor, true, successCallback);

Client
1
2
3
4
5
6
String channelId = "<channel id>";
String cacheableCursor = "<cacheableCursor>";
ChannelMessageList messages = client.listChannelMessages(session, channelId, 10, cacheableCursor).get();
for (ChannelMessage message : messages.getMessagesList()) {
        System.out.format("Message content: %s", message.getContent());
    }

Client
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
var cacheable_cursor = "<cacheable cursor>";
var channel_id = "<channel id>"
var forward = true
var result : NakamaAPI.ApiChannelMessageList = yield(client.list_channel_messages_async(session, channel_id, 10, forward, cacheable_cursor), "completed")
if result.is_exception():
    print("An error occurred: %s" % result)
    return
for m in result.messages:
    var message : NakamaAPI.ApiChannelMessage = m as NakamaAPI.ApiChannelMessage
    print("Message has id %s and content %s" % [message.message_id, message.content])

Heroic Cloud

Deploy Nakama and Satori

Company

A Heroic Ten Years: Special letter from our CEO, and invitation to our birthday party!

Heroic Labs Celebrates the Launch of FBC: Firebreak, a Co-op Shooter from Remedy Entertainment.

Realism Meets Tactics in an Open-world MMOFPS: Powering Gray Zone Warfare to Early Success.

Documentation

Community

Download and Install Nakama OSS

Learn how to use Nakama

실시간 채팅

채팅 채널 #

지속성 #

숨겨진 채널 구성원 #

채팅 가입 #

채팅방 #

그룹 #

직접 #

온라인 사용자 나열 #

메시지 받기 #

그룹 #

메시지 보내기 #

메시지 컨텐츠 필터링 #

채팅 나가기 #

메시지 기록 #

캐시 가능한 커서 #

Table of Contents