Skip to content

Chat

Sending chat messages is probably the most common operation you will perform using the SDK.

Is also the simplest type of message, and allows you to send and receive plain text messages between two nodes.

Sending a Chat Message

To send a chat message:

  1. Create the message content:
1
2
3
content, err := message.NewChat().
    Message("Hello world!").
    Finish()

1
2
3
val chat = ChatBuilder()
    .message("Hello world!")
    .finish()

1
2
3
4
val chat = ChatMessage.Builder()
    .setToIdentifier(address)
    .setMessage("Hello world!")        
    .build()

1
2
3
4
let message = ChatMessage.Builder()
.toIdentifier(address)
.withMessage("Hello World")
.build()
  1. Send the message to a specific address:
1
err := selfAccount.MessageSend(address, content)

1
2
val sendStatus = account.messageSend(address, chat)
println("send chat status:${sendStatus.code()} - messageId:${chat.id().toHexString()}")

1
2
3
account.send(chat) { messageId, _ ->
    println("sent chat messageId:${messageId}")
}

1
2
3
4
5
Task(priority: .background, operation: {
    try await self.account.send(message: message, onAcknowledgement: {msgId, error in
        print("sent: \(msgId) with error: \(error)")
    })
})

Note: Check out the Discovery section for documentation on how to obtain the node address.

Receiving a Chat Message

Receiving chat messages is just as easy, as we saw on the messaging section you can use the OnMessage hook of your configuration process to receive and process chat messages.

Once you receive the message, you can decode and process the chat message as follows:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
case message.TypeChat:
    chat, err := message.DecodeChat(msg)
    // ...

    log.Info(
        "Received chat message",
        "from", msg.FromAddress().String(),
        "messageId", hex.EncodeToString(msg.ID()),
        "referencingId", hex.EncodeToString(chat.Referencing()),
        "message", chat.Message(),
        "attachmentCount", len(chat.Attachments()),
    )

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
ContentType.CHAT -> {
    val chat = Chat.decode(content)
    println(
        "received chat message " +
        "\nfrom:${message.fromAddress().encodeHex()}" +
        "\nmessageId:${message.id().toHexString()}" +
        "\nmessage:${chat.message()}" +
        "\nattachments:${chat.attachments().size}"
    )
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
account.setOnMessageListener { msg ->
    when (msg) {
        is ChatMessage -> {
            println(
                "received chat message " +
                "\nfrom:${msg.fromIdentifier()}" +
                "\nmessageId:${msg.id()}" +
                "\nmessage:${msg.message()}" +
                "\nattachments:${msg.attachments().size}"
            )
        }
        is Receipt -> {
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
account.setOnMessageListener { message in
    switch message {
    case is ChatMessage:
        let chatMessage = message as! ChatMessage
        print("Message chat: \(chatMessage)")

    case is Receipt:
        let receipt = message as! Receipt
        print("Message receipt: \(receipt)")

    default:
        print("Other Message: \(message)")
        break
    }
}

This code snippet shows how to extract and log various details from the received chat message, such as the sender's address, message content, and any attachments.

TDLR; You can find the final example at https://github.com/joinself/self-go-sdk/blob/main/examples/chat/request/main.go