rf(message): simply send message.

client/group_msg.go

@@ -36,17 +36,20 @@ func (c *QQClient) SendGroupMessage(groupCode int64, m *message.SendingMessage,
 	if len(f) > 0 {
 		useFram = f[0]
 	}
-	imgCount := m.Count(func(e message.IMessageElement) bool { return e.Type() == message.Image })
+	imgCount := 0
-	if useFram {
+	for _, e := range m.Elements {
-		if m.Any(func(e message.IMessageElement) bool { return e.Type() == message.Reply }) {
+		switch e.Type() {
+		case message.Image:
+			imgCount++
+		case message.Reply:
 			useFram = false
 		}
 	}
-	msgLen := message.EstimateLength(m.Elements, 5000)
+	msgLen := message.EstimateLength(m.Elements)
 	if msgLen > 5000 || imgCount > 50 {
 		return nil
 	}
-	if (msgLen > 100 || imgCount > 2) && !useFram {
+	if !useFram && (msgLen > 100 || imgCount > 2) {
 		ret := c.sendGroupMessage(groupCode, false,
 			&message.SendingMessage{Elements: []message.IMessageElement{
 				c.uploadGroupLongMessage(groupCode,
@@ -61,14 +64,8 @@ func (c *QQClient) SendGroupMessage(groupCode int64, m *message.SendingMessage,
 				),
 			}},
 		)
-		return &message.GroupMessage{
+		ret.Elements = m.Elements
-			Id:         ret.Id,
+		return ret
-			InternalId: ret.InternalId,
-			GroupCode:  ret.GroupCode,
-			Sender:     ret.Sender,
-			Time:       ret.Time,
-			Elements:   m.Elements,
-		}
 	}
 	return c.sendGroupMessage(groupCode, false, m)
 }
@@ -101,25 +98,29 @@ func (c *QQClient) GetAtAllRemain(groupCode int64) (*AtAllRemainInfo, error) {
 func (c *QQClient) sendGroupMessage(groupCode int64, forward bool, m *message.SendingMessage) *message.GroupMessage {
 	eid := utils.RandomString(6)
 	mr := int32(rand.Uint32())
-	ch := make(chan int32)
+	ch := make(chan int32, 1)
 	c.onGroupMessageReceipt(eid, func(c *QQClient, e *groupMessageReceiptEvent) {
-		if e.Rand == mr && !utils.IsChanClosed(ch) {
+		if e.Rand == mr {
 			ch <- e.Seq
 		}
 	})
 	defer c.onGroupMessageReceipt(eid)
-	imgCount := m.Count(func(e message.IMessageElement) bool { return e.Type() == message.Image })
+	imgCount := 0
-	msgLen := message.EstimateLength(m.Elements, 703)
+	frag := false
-	if (msgLen > 100 || imgCount > 1) && !forward && !m.Any(func(e message.IMessageElement) bool {
+L:
-		_, ok := e.(*message.GroupVoiceElement)
+	for _, e := range m.Elements {
-		_, ok2 := e.(*message.ServiceElement)
+		switch e.Type() {
-		_, ok3 := e.(*message.ReplyElement)
+		case message.Image:
-		if _, ok4 := e.(*message.ForwardElement); ok4 {
+			imgCount++
+		case message.Forward:
 			forward = true
-			return true
+			fallthrough
+		case message.Reply, message.Voice, message.Service:
+			frag = true
+			break L
 		}
-		return ok || ok2 || ok3
+	}
-	}) {
+	if !forward && !frag && (imgCount > 1 || message.EstimateLength(m.Elements) > 100) {
 		div := int32(rand.Uint32())
 		fragmented := m.ToFragmented()
 		for i, elems := range fragmented {

client/private_msg.go

@@ -18,7 +18,7 @@ func (c *QQClient) SendPrivateMessage(target int64, m *message.SendingMessage) *
 	var seq int32
 	t := time.Now().Unix()
 	imgCount := m.Count(func(e message.IMessageElement) bool { return e.Type() == message.Image })
-	msgLen := message.EstimateLength(m.Elements, 703)
+	msgLen := message.EstimateLength(m.Elements)
 	if msgLen > 5000 || imgCount > 50 {
 		return nil
 	}

message/message.go

@@ -1,7 +1,6 @@
 package message
 
 import (
-	"math"
 	"reflect"
 	"regexp"
 	"strconv"
@@ -237,24 +236,20 @@ func (msg *SendingMessage) ToFragmented() [][]IMessageElement {
 	return fragmented
 }
 
-func EstimateLength(elems []IMessageElement, limit int) int {
+func EstimateLength(elems []IMessageElement) int {
 	sum := 0
 	for _, elem := range elems {
-		if sum > limit {
-			break
-		}
-		left := int(math.Max(float64(limit-sum), 0))
 		switch e := elem.(type) {
 		case *TextElement:
-			sum += utils.ChineseLength(e.Content, left)
+			sum += len(e.Content)
 		case *AtElement:
-			sum += utils.ChineseLength(e.Display, left)
+			sum += len(e.Display)
 		case *ReplyElement:
-			sum += 444 + EstimateLength(e.Elements, left)
+			sum += 444 + EstimateLength(e.Elements)
 		case *ImageElement, *GroupImageElement, *FriendImageElement:
 			sum += 100
 		default:
-			sum += utils.ChineseLength(ToReadableString([]IMessageElement{elem}), left)
+			sum += len(ToReadableString([]IMessageElement{elem}))
 		}
 	}
 	return sum

utils/string.go

@@ -1,39 +1,42 @@
 package utils
 
 import (
-	"bytes"
+	"math/rand"
-	"crypto/rand"
-	"math/big"
 	"reflect"
 	"strconv"
 	"strings"
+	"time"
 	"unsafe"
 )
 
+func init() {
+	rand.Seed(time.Now().Unix())
+}
+
 func RandomString(len int) string {
 	return RandomStringRange(len, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890")
 }
 
-func RandomStringRange(len int, str string) string {
+func RandomStringRange(length int, str string) string {
-	var res string
+	sb := strings.Builder{}
-	b := bytes.NewBufferString(str)
+	for i := 0; i < length; i++ {
-	length := b.Len()
+		sb.WriteByte(str[rand.Intn(len(str))])
-	bigInt := big.NewInt(int64(length))
-	for i := 0; i < len; i++ {
-		randomInt, _ := rand.Int(rand.Reader, bigInt)
-		res += string(str[randomInt.Int64()])
 	}
-	return res
+	return sb.String()
 }
 
 func ChunkString(s string, chunkSize int) []string {
-	var chunks []string
 	runes := []rune(s)
-
 	if len(runes) == 0 || len(runes) <= chunkSize {
 		return []string{s}
 	}
 
+	chunkLen := len(runes) / chunkSize
+	if len(runes)%chunkSize != 0 {
+		chunkLen++
+	}
+
+	var chunks = make([]string, 0, chunkLen)
 	for i := 0; i < len(runes); i += chunkSize {
 		nn := i + chunkSize
 		if nn > len(runes) {
@@ -44,26 +47,6 @@ func ChunkString(s string, chunkSize int) []string {
 	return chunks
 }
 
-func ChineseLength(str string, limit int) int {
-	sum := 0
-	for _, r := range str {
-		switch {
-		case r >= '\u0000' && r <= '\u007F':
-			sum += 1
-		case r >= '\u0080' && r <= '\u07FF':
-			sum += 2
-		case r >= '\u0800' && r <= '\uFFFF':
-			sum += 3
-		default:
-			sum += 4
-		}
-		if sum > limit {
-			break
-		}
-	}
-	return sum
-}
-
 func ConvertSubVersionToInt(str string) int32 {
 	i, _ := strconv.ParseInt(strings.Join(strings.Split(str, "."), ""), 10, 64)
 	return int32(i) * 10