Implement Chat for SteamClient

[rossengeorgiev]

Tasks:

• SteamUser rework
• research user to user chat protocol
• implement user to user chat handling
• research group chat protocol
• implement group protocol messages
• implement group chat
• docs & examples

[thomassross]

I've looked into this a little bit and I've discovered:

You can listen to the message CMsgClientFriendMsgIncoming to receive messages from friends. This message contains the following fields:

• steamid_from contains the steamid of the sender
• chat_entry_type contains the type of the message -- 2 means the sender has started typing in the chat window, 1 means a message has been sent
• from_limited_account - I haven't tested this one, but I assume it shows if the sender has a limited Steam account or not
• message - if chat_entry_type is 1, it contains the sent message. Otherwise it is empty (with a NUL character (\0) at the end) -- This message always ends with a NUL character (\0)
• rtime32_server_timestamp - The time the server sent the message (in Unix time)

[thomassross]

Sending a message:

• Send the protobuf message CMsgClientFriendMsg
• steamid is the steamid64 you want to send the message to
• chat_entry_type is the same as before -- 2 means the sender has started typing in the chat window, 1 means a message has been sent
• message is the message that you want to send
• rtime32_server_timestamp - The time the client sent the message (in Unix time)

Putting this all together you could write a simple "copycat":

@client.on(EMsg.ClientFriendMsgIncoming)
def onMessage(msg):
    messageText = msg.body.message.rstrip().strip("\0")

    if messageText:
        sendMsg = MsgProto(EMsg.ClientFriendMsg)
        sendMsg.body.steamid = msg.body.steamid_from
        sendMsg.body.chat_entry_type = 1
        sendMsg.body.message = messageText
        sendMsg.body.rtime32_server_timestamp = int(time.time())

        client.send(sendMsg)

[rossengeorgiev]

Hi @thomassross, thanks for the info I appreciate it. My fault for not adding any details on the issue, but the issue was more about implementing code in the module that abstracts the unnecessary details while providing a simple and initiative API. I already have something in the works.

[alexche8]

Can you please add thomassross example of chat to documentation or examle pages? It helps to do basic things.

[rossengeorgiev]

You are right @alexche8, docs are a bit lacking on that. It will happen at some point. Currently you can send and receive messages from individual users.

Here is a simple message echo example, user parameter is a SteamUser instance.

@client.on('chat_message')
def handle_message(user, message_text):
    user.send_message('You said: %s' % message_text)

[alexche8]

@rossengeorgiev , thanks!

[nukeop]

User chats work perfectly, are group chats getting implemented any time soon?
I noticed that some protobuf messages connected to this functionality are missing - sadly I don't have any idea how to implement this myself, but I might try figuring it out in the coming weeks.
For example to join a group chat, EMsg.ClientJoinChat protobuf needs to be sent, but attempting to create it with MsgProto (from steam.core.msg) results in an empty message. If I have the time I will try to learn how exactly messages are created and how they're defined, and maybe find a way to create support for joining and receiving/sending messages.

[b3mb4m]

User chat working tested on linux.I wish i had time to help but working too hard these days.

Thanks for everyone ~~

[nukeop]

I'm slowly figuring out group chat. For example, I managed to get joining group chats to work. You have to use non-protobuf messages (Msg class) serialized to bytes. For example, given an invite with chatroomid, to join that chatroom we need something like this:

msg = Msg(EMsg.ClientJoinChat, extended=True)
msg.body = MsgClientJoinChat(chatroomid)
client.send(msg)

Where MsgClientJoinChat is a class encapsulating the required fields, and providing a method for serialization to bytes. A crude version of this class could look like this:

import StringIO

class MsgClientJoinChat(object):
    def __init__(self, sidc):
        self.SteamIdChat = sidc
        self.IsVoiceSpeaker = False

    def serialize(self):
        out = StringIO.StringIO()
        hsteamidchat = format(self.SteamIdChat, '02x')
        if len(hsteamidchat)%4!=0:
            hsteamidchat = (len(hsteamidchat)%4)*'0' + hsteamidchat

        newstr = ""
        for i in range(len(hsteamidchat), 2, -2):
            newstr += hsteamidchat[i-2:i]

        hsteamidchat = bytearray.fromhex(newstr)
        out.write(hsteamidchat)
        out.write("\x00")
        return out.getvalue()

The hard part is converting the steam id into bytes and reversing their order (unless I missed some built-in python function that does that).

After sending the message in the way described in the first block of code, the bot joins the chatroom. I was unable to find non-protobuf messages with bodies specific to their types (like this MsgClientJoinChat class I pasted here). Have I missed them or is this functionality not implemented in the library?

[nukeop]

I figured out something more advanced: receiving group chat messages.

In steam/core/msg.py, in the Msg class constructor, I added this condition to the chain creating the appropriate message body:

elif msg == EMsg.ClientChatMsg:
        self.body = ClientChatMsg(data)

ClientChatMsg is a class I created in the same file after looking at the format in which steam sends group chat messages. This is basically:

steamIdChatter - 64-bit ID of the author of the message
steamIdChatRoom - 64 bit ID of the chatroom the message was sent in
ChatMsgType - 32-bit int message type
ChatMsg - the message itself. Size is as big as needed.

This can be unpacked with struct.unpack_from with the format string "<QQI16s", similarly to other messages, although this particular string will only unpack the first 16 characters correctly, not sure how to make it unpack everything until the end of the message.

Once we have this unpacked, we set a ClientChatMsg object as the message body and voila. The last piece of the puzzle is figuring out the format string for struct.unpack_from, and I can post a pull request.

An ugly way to do that would be just getting the length of the message in bytes and subtracting 8+8+4=20 bytes, since that's how much the first three attributes take. Then we can use s in the format string.

[rossengeorgiev]

Nice, those seem to be correct. They are indeed not protos for them

The hard part is converting the steam id into bytes and reversing their order (unless I missed some built-in python function that does that).

If it is endianness just use <> in the unpack format.

An ugly way to do that would be just getting the length of the message in bytes

It's not ugly at all.

"<QQI{}s".format(len(body) - struct.calcsize("QQI"))