supported JoinGroupEvent.

client/client.go

@@ -182,7 +182,7 @@ func (c *QQClient) GetFriendList() (*FriendListResponse, error) {
 	return r, nil
 }
 
-func (c *QQClient) SendGroupMessage(groupCode int64, m *message.SendingMessage) int32 {
+func (c *QQClient) SendGroupMessage(groupUin int64, m *message.SendingMessage) int32 {
 	eid := utils.RandomString(6)
 	mr := int32(rand.Uint32())
 	ch := make(chan int32)
@@ -192,7 +192,7 @@ func (c *QQClient) SendGroupMessage(groupCode int64, m *message.SendingMessage)
 			c.onGroupMessageReceipt(eid)
 		}
 	})
-	_, pkt := c.buildGroupSendingPacket(groupCode, mr, m)
+	_, pkt := c.buildGroupSendingPacket(utils.ToGroupCode(groupUin), mr, m)
 	_ = c.send(pkt)
 	var mid int32
 	select {
@@ -204,9 +204,9 @@ func (c *QQClient) SendGroupMessage(groupCode int64, m *message.SendingMessage)
 	return mid
 }
 
-func (c *QQClient) UploadGroupImage(groupCode int64, img []byte) (*message.GroupImageElement, error) {
+func (c *QQClient) UploadGroupImage(groupUin int64, img []byte) (*message.GroupImageElement, error) {
 	h := md5.Sum(img)
-	seq, pkt := c.buildGroupImageStorePacket(groupCode, h, int32(len(img)))
+	seq, pkt := c.buildGroupImageStorePacket(utils.ToGroupCode(groupUin), h, int32(len(img)))
 	r, err := c.sendAndWait(seq, pkt)
 	if err != nil {
 		return nil, err
@@ -430,6 +430,7 @@ func (c *QQClient) loop() {
 				continue
 			}
 		}
+		//fmt.Println(pkt.CommandName)
 		go func() {
 			decoder, ok := c.decoders[pkt.CommandName]
 			if !ok {

client/decoders.go

@@ -7,9 +7,14 @@ import (
 	"github.com/Mrs4s/MiraiGo/client/pb"
 	"github.com/Mrs4s/MiraiGo/client/pb/msg"
 	"github.com/golang/protobuf/proto"
+	"sync"
 	"time"
 )
 
+var (
+	groupJoinLock = new(sync.Mutex)
+)
+
 func decodeLoginResponse(c *QQClient, seq uint16, payload []byte) (interface{}, error) {
 	reader := binary.NewReader(payload)
 	reader.ReadUInt16() // sub command
@@ -143,19 +148,35 @@ func decodeMessageSvcPacket(c *QQClient, seq uint16, payload []byte) (interface{
 				MsgUid:  message.Head.MsgUid,
 			}
 			delItems = append(delItems, delItem)
-
 			if message.Head.ToUin != c.Uin {
 				continue
 			}
-			if message.Body.RichText == nil || message.Body.RichText.Elems == nil {
+			switch message.Head.MsgType {
-				continue
+			case 33:
+				groupJoinLock.Lock()
+				group := c.FindGroup(message.Head.FromUin)
+				if message.Head.AuthUin == c.Uin {
+					if group != nil {
+						groupJoinLock.Unlock()
+						continue
+					}
+					if c.ReloadGroupList() != nil {
+						groupJoinLock.Unlock()
+						continue
+					}
+					c.dispatchNewGroupEvent(c.FindGroup(message.Head.FromUin))
+				}
+				groupJoinLock.Unlock()
+			case 166:
+				if message.Body.RichText == nil || message.Body.RichText.Elems == nil {
+					continue
+				}
+				if c.lastMessageSeq >= message.Head.MsgSeq {
+					continue
+				}
+				c.lastMessageSeq = message.Head.MsgSeq
+				c.dispatchFriendMessage(c.parsePrivateMessage(message))
 			}
-			if c.lastMessageSeq >= message.Head.MsgSeq {
-				continue
-			}
-			c.lastMessageSeq = message.Head.MsgSeq
-
-			c.dispatchFriendMessage(c.parsePrivateMessage(message))
 		}
 	}
 	_, _ = c.sendAndWait(c.buildDeleteMessageRequestPacket(delItems))

client/events.go

@@ -13,6 +13,7 @@ type eventHandlers struct {
 	groupMessageHandlers        []func(*QQClient, *message.GroupMessage)
 	groupMuteEventHandlers      []func(*QQClient, *GroupMuteEvent)
 	groupRecalledHandlers       []func(*QQClient, *GroupMessageRecalledEvent)
+	joinGroupHandlers           []func(*QQClient, *GroupInfo)
 	groupMessageReceiptHandlers sync.Map
 }
 
@@ -26,6 +27,8 @@ func (c *QQClient) OnEvent(i interface{}) error {
 		c.OnGroupMuted(f)
 	case func(*QQClient, *GroupMessageRecalledEvent):
 		c.OnGroupMessageRecalled(f)
+	case func(*QQClient, *GroupInfo):
+		c.OnJoinGroup(f)
 	default:
 		return ErrEventUndefined
 	}
@@ -52,6 +55,10 @@ func (c *QQClient) OnGroupMuted(f func(*QQClient, *GroupMuteEvent)) {
 	c.eventHandlers.groupMuteEventHandlers = append(c.eventHandlers.groupMuteEventHandlers, f)
 }
 
+func (c *QQClient) OnJoinGroup(f func(*QQClient, *GroupInfo)) {
+	c.eventHandlers.joinGroupHandlers = append(c.eventHandlers.joinGroupHandlers, f)
+}
+
 func (c *QQClient) OnGroupMessageRecalled(f func(*QQClient, *GroupMessageRecalledEvent)) {
 	c.eventHandlers.groupRecalledHandlers = append(c.eventHandlers.groupRecalledHandlers, f)
 }
@@ -114,6 +121,17 @@ func (c *QQClient) dispatchGroupMessageRecalledEvent(e *GroupMessageRecalledEven
 	}
 }
 
+func (c *QQClient) dispatchJoinGroupEvent(group *GroupInfo) {
+	if group == nil {
+		return
+	}
+	for _, f := range c.eventHandlers.joinGroupHandlers {
+		cover(func() {
+			f(c, group)
+		})
+	}
+}
+
 func (c *QQClient) dispatchGroupMessageReceiptEvent(e *groupMessageReceiptEvent) {
 	c.eventHandlers.groupMessageReceiptHandlers.Range(func(_, f interface{}) bool {
 		go f.(func(*QQClient, *groupMessageReceiptEvent))(c, e)

client/global.go

@@ -116,23 +116,18 @@ func (info *DeviceInfo) GenDeviceInfoData() []byte {
 }
 
 func (c *QQClient) parsePrivateMessage(msg *msg.Message) *message.PrivateMessage {
-	switch msg.Head.MsgType {
+	friend := c.FindFriend(msg.Head.FromUin)
-	case 166:
+	if friend == nil {
-		friend := c.FindFriend(msg.Head.FromUin)
-		if friend == nil {
-			return nil
-		}
-		return &message.PrivateMessage{
-			Id: msg.Head.MsgSeq,
-			Sender: &message.Sender{
-				Uin:      friend.Uin,
-				Nickname: friend.Nickname,
-			},
-			Elements: parseMessageElems(msg.Body.RichText.Elems),
-		}
-	default:
 		return nil
 	}
+	return &message.PrivateMessage{
+		Id: msg.Head.MsgSeq,
+		Sender: &message.Sender{
+			Uin:      friend.Uin,
+			Nickname: friend.Nickname,
+		},
+		Elements: parseMessageElems(msg.Body.RichText.Elems),
+	}
 }
 
 func (c *QQClient) parseGroupMessage(m *msg.Message) *message.GroupMessage {

message/message.go

@@ -94,6 +94,13 @@ func (msg *SendingMessage) Append(e IMessageElement) *SendingMessage {
 	return msg
 }
 
+func (s *Sender) DisplayName() string {
+	if s.CardName == "" {
+		return s.Nickname
+	}
+	return s.CardName
+}
+
 func ToProtoElems(elems []IMessageElement) (r []*msg.Elem) {
 	for _, elem := range elems {
 		switch e := elem.(type) {

utils/group.go

@@ -0,0 +1,43 @@
+package utils
+
+func ToGroupUin(groupCode int64) int64 {
+	left := groupCode / 1000000
+	switch {
+	case left >= 0 && left <= 10:
+		left += 202
+	case left >= 11 && left <= 19:
+		left += 480 - 11
+	case left >= 20 && left <= 66:
+		left += 2100 - 20
+	case left >= 67 && left <= 156:
+		left += 2010 - 67
+	case left >= 157 && left <= 209:
+		left += 2147 - 157
+	case left >= 210 && left <= 309:
+		left += 4100 - 210
+	case left >= 310 && left <= 499:
+		left += 3800 - 310
+	}
+	return left*1000000 + groupCode%1000000
+}
+
+func ToGroupCode(groupUin int64) int64 {
+	left := groupUin / 1000000
+	switch {
+	case left >= 0+202 && left <= 10+202:
+		left -= 202
+	case left >= 11+480-11 && left <= 19+480-11:
+		left -= 480 - 11
+	case left >= 20+2100-20 && left <= 66+2100-20:
+		left -= 2100 - 20
+	case left >= 67+2010-67 && left <= 156+2010-67:
+		left -= 2010 - 67
+	case left >= 157+2147-157 && left <= 209+2147-157:
+		left -= 2147 - 157
+	case left >= 210+4100-210 && left <= 309+4100-210:
+		left -= 4100 - 210
+	case left >= 310+3800-310 && left <= 499+3800-310:
+		left -= 3800 - 310
+	}
+	return left*1000000 + groupUin%1000000
+}