seang96/gmessages
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions

Remove unnecessary wrapping of API methods

Browse source
This commit is contained in:
Tulir Asokan 2023-07-16 00:26:22 +03:00
parent d04b1bde39
commit 3f912f87cf
8 changed files with 60 additions and 92 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
backfill.go
View file

@ -87,7 +87,7 @@ func (portal *Portal) deterministicEventID(messageID string, part int) id.EventI
func (portal *Portal) forwardBackfill(ctx context.Context, user *User, after time.Time, limit int64, markRead bool) { func (portal *Portal) forwardBackfill(ctx context.Context, user *User, after time.Time, limit int64, markRead bool) {
log := zerolog.Ctx(ctx) log := zerolog.Ctx(ctx)
resp, err := user.Client.Conversations.FetchMessages(portal.ID, limit, nil) resp, err := user.Client.FetchMessages(portal.ID, limit, nil)
if err != nil { if err != nil {
portal.zlog.Error().Err(err).Msg("Failed to fetch messages") portal.zlog.Error().Err(err).Msg("Failed to fetch messages")
return return

15
libgm/client.go
View file

@ -34,9 +34,6 @@ type Proxy func(*http.Request) (*url.URL, error)
type EventHandler func(evt interface{}) type EventHandler func(evt interface{})
type Client struct { type Client struct {
Logger zerolog.Logger Logger zerolog.Logger
Conversations *Conversations
Session *Session
Messages *Messages
rpc *RPC rpc *RPC
pairer *Pairer pairer *Pairer
evHandler EventHandler evHandler EventHandler
@ -70,8 +67,6 @@ func NewClient(authData *AuthData, logger zerolog.Logger) *Client {
sessionHandler.client = cli sessionHandler.client = cli
rpc := &RPC{client: cli, http: &http.Client{Transport: &http.Transport{Proxy: cli.proxy}}} rpc := &RPC{client: cli, http: &http.Client{Transport: &http.Transport{Proxy: cli.proxy}}}
cli.rpc = rpc cli.rpc = rpc
cli.Logger.Debug().Any("data", cli.authData.Cryptor).Msg("Cryptor")
cli.setApiMethods()
cli.FetchConfigVersion() cli.FetchConfigVersion()
return cli return cli
} }
@ -122,12 +117,12 @@ func (c *Client) Connect() error {
go c.rpc.ListenReceiveMessages(rpcPayload) go c.rpc.ListenReceiveMessages(rpcPayload)
c.sessionHandler.startAckInterval() c.sessionHandler.startAckInterval()
bugleRes, bugleErr := c.Session.IsBugleDefault() bugleRes, bugleErr := c.IsBugleDefault()
if bugleErr != nil { if bugleErr != nil {
panic(bugleErr) panic(bugleErr)
} }
c.Logger.Info().Any("isBugle", bugleRes.Success).Msg("IsBugleDefault") c.Logger.Info().Any("isBugle", bugleRes.Success).Msg("IsBugleDefault")
sessionErr := c.Session.SetActiveSession() sessionErr := c.SetActiveSession()
if sessionErr != nil { if sessionErr != nil {
panic(sessionErr) panic(sessionErr)
} }
@ -201,12 +196,6 @@ func (c *Client) triggerEvent(evt interface{}) {
} }
} }
func (c *Client) setApiMethods() {
c.Conversations = &Conversations{client: c}
c.Session = &Session{client: c}
c.Messages = &Messages{client: c}
}
func (c *Client) DownloadMedia(mediaID string, key []byte) ([]byte, error) { func (c *Client) DownloadMedia(mediaID string, key []byte) ([]byte, error) {
reqId := util.RandomUUIDv4() reqId := util.RandomUUIDv4()
downloadMetadata := &binary.UploadImagePayload{ downloadMetadata := &binary.UploadImagePayload{

68
libgm/conversations.go
View file

@ -6,30 +6,21 @@ import (
"go.mau.fi/mautrix-gmessages/libgm/binary" "go.mau.fi/mautrix-gmessages/libgm/binary"
) )
type Conversations struct { func (c *Client) ListConversations(count int64) (*binary.Conversations, error) {
client *Client
synced bool
}
// default is 25 count
func (c *Conversations) List(count int64) (*binary.Conversations, error) {
payload := &binary.ListCoversationsPayload{Count: count, Field4: 1} payload := &binary.ListCoversationsPayload{Count: count, Field4: 1}
var actionType binary.ActionType //var actionType binary.ActionType
//if !c.synced {
// actionType = binary.ActionType_LIST_CONVERSATIONS_SYNC
// c.synced = true
//} else {
actionType := binary.ActionType_LIST_CONVERSATIONS
if !c.synced { sentRequestId, sendErr := c.sessionHandler.completeSendMessage(actionType, true, payload)
actionType = binary.ActionType_LIST_CONVERSATIONS_SYNC
c.synced = true
} else {
actionType = binary.ActionType_LIST_CONVERSATIONS
}
sentRequestId, sendErr := c.client.sessionHandler.completeSendMessage(actionType, true, payload)
if sendErr != nil { if sendErr != nil {
return nil, sendErr return nil, sendErr
} }
response, err := c.client.sessionHandler.WaitForResponse(sentRequestId, actionType) response, err := c.sessionHandler.WaitForResponse(sentRequestId, actionType)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -42,16 +33,16 @@ func (c *Conversations) List(count int64) (*binary.Conversations, error) {
return res, nil return res, nil
} }
func (c *Conversations) GetType(conversationId string) (*binary.GetConversationTypeResponse, error) { func (c *Client) GetConversationType(conversationID string) (*binary.GetConversationTypeResponse, error) {
payload := &binary.ConversationTypePayload{ConversationID: conversationId} payload := &binary.ConversationTypePayload{ConversationID: conversationID}
actionType := binary.ActionType_GET_CONVERSATION_TYPE actionType := binary.ActionType_GET_CONVERSATION_TYPE
sentRequestId, sendErr := c.client.sessionHandler.completeSendMessage(actionType, true, payload) sentRequestId, sendErr := c.sessionHandler.completeSendMessage(actionType, true, payload)
if sendErr != nil { if sendErr != nil {
return nil, sendErr return nil, sendErr
} }
response, err := c.client.sessionHandler.WaitForResponse(sentRequestId, actionType) response, err := c.sessionHandler.WaitForResponse(sentRequestId, actionType)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -64,20 +55,20 @@ func (c *Conversations) GetType(conversationId string) (*binary.GetConversationT
return res, nil return res, nil
} }
func (c *Conversations) FetchMessages(conversationId string, count int64, cursor *binary.Cursor) (*binary.FetchMessagesResponse, error) { func (c *Client) FetchMessages(conversationID string, count int64, cursor *binary.Cursor) (*binary.FetchMessagesResponse, error) {
payload := &binary.FetchConversationMessagesPayload{ConversationID: conversationId, Count: count} payload := &binary.FetchConversationMessagesPayload{ConversationID: conversationID, Count: count}
if cursor != nil { if cursor != nil {
payload.Cursor = cursor payload.Cursor = cursor
} }
actionType := binary.ActionType_LIST_MESSAGES actionType := binary.ActionType_LIST_MESSAGES
sentRequestId, sendErr := c.client.sessionHandler.completeSendMessage(actionType, true, payload) sentRequestId, sendErr := c.sessionHandler.completeSendMessage(actionType, true, payload)
if sendErr != nil { if sendErr != nil {
return nil, sendErr return nil, sendErr
} }
response, err := c.client.sessionHandler.WaitForResponse(sentRequestId, actionType) response, err := c.sessionHandler.WaitForResponse(sentRequestId, actionType)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -90,15 +81,15 @@ func (c *Conversations) FetchMessages(conversationId string, count int64, cursor
return res, nil return res, nil
} }
func (c *Conversations) SendMessage(payload *binary.SendMessagePayload) (*binary.SendMessageResponse, error) { func (c *Client) SendMessage(payload *binary.SendMessagePayload) (*binary.SendMessageResponse, error) {
actionType := binary.ActionType_SEND_MESSAGE actionType := binary.ActionType_SEND_MESSAGE
sentRequestId, sendErr := c.client.sessionHandler.completeSendMessage(actionType, true, payload) sentRequestId, sendErr := c.sessionHandler.completeSendMessage(actionType, true, payload)
if sendErr != nil { if sendErr != nil {
return nil, sendErr return nil, sendErr
} }
response, err := c.client.sessionHandler.WaitForResponse(sentRequestId, actionType) response, err := c.sessionHandler.WaitForResponse(sentRequestId, actionType)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -108,20 +99,19 @@ func (c *Conversations) SendMessage(payload *binary.SendMessagePayload) (*binary
return nil, fmt.Errorf("unexpected response type %T, expected *binary.SendMessageResponse", response.Data.Decrypted) return nil, fmt.Errorf("unexpected response type %T, expected *binary.SendMessageResponse", response.Data.Decrypted)
} }
c.client.Logger.Debug().Any("res", res).Msg("sent message!")
return res, nil return res, nil
} }
func (c *Conversations) GetParticipantThumbnail(convID string) (*binary.ParticipantThumbnail, error) { func (c *Client) GetParticipantThumbnail(convID string) (*binary.ParticipantThumbnail, error) {
payload := &binary.GetParticipantThumbnailPayload{ConversationID: convID} payload := &binary.GetParticipantThumbnailPayload{ConversationID: convID}
actionType := binary.ActionType_GET_PARTICIPANTS_THUMBNAIL actionType := binary.ActionType_GET_PARTICIPANTS_THUMBNAIL
sentRequestId, sendErr := c.client.sessionHandler.completeSendMessage(actionType, true, payload) sentRequestId, sendErr := c.sessionHandler.completeSendMessage(actionType, true, payload)
if sendErr != nil { if sendErr != nil {
return nil, sendErr return nil, sendErr
} }
response, err := c.client.sessionHandler.WaitForResponse(sentRequestId, actionType) response, err := c.sessionHandler.WaitForResponse(sentRequestId, actionType)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -134,7 +124,7 @@ func (c *Conversations) GetParticipantThumbnail(convID string) (*binary.Particip
return res, nil return res, nil
} }
func (c *Conversations) Update(convBuilder *ConversationBuilder) (*binary.UpdateConversationResponse, error) { func (c *Client) UpdateConversation(convBuilder *ConversationBuilder) (*binary.UpdateConversationResponse, error) {
data := &binary.UpdateConversationPayload{} data := &binary.UpdateConversationPayload{}
payload, buildErr := convBuilder.Build(data) payload, buildErr := convBuilder.Build(data)
@ -144,12 +134,12 @@ func (c *Conversations) Update(convBuilder *ConversationBuilder) (*binary.Update
actionType := binary.ActionType_UPDATE_CONVERSATION actionType := binary.ActionType_UPDATE_CONVERSATION
sentRequestId, sendErr := c.client.sessionHandler.completeSendMessage(actionType, true, payload) sentRequestId, sendErr := c.sessionHandler.completeSendMessage(actionType, true, payload)
if sendErr != nil { if sendErr != nil {
return nil, sendErr return nil, sendErr
} }
response, err := c.client.sessionHandler.WaitForResponse(sentRequestId, actionType) response, err := c.sessionHandler.WaitForResponse(sentRequestId, actionType)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -162,16 +152,16 @@ func (c *Conversations) Update(convBuilder *ConversationBuilder) (*binary.Update
return res, nil return res, nil
} }
func (c *Conversations) SetTyping(convID string) error { func (c *Client) SetTyping(convID string) error {
payload := &binary.TypingUpdatePayload{Data: &binary.SetTypingIn{ConversationID: convID, Typing: true}} payload := &binary.TypingUpdatePayload{Data: &binary.SetTypingIn{ConversationID: convID, Typing: true}}
actionType := binary.ActionType_TYPING_UPDATES actionType := binary.ActionType_TYPING_UPDATES
sentRequestId, sendErr := c.client.sessionHandler.completeSendMessage(actionType, true, payload) sentRequestId, sendErr := c.sessionHandler.completeSendMessage(actionType, true, payload)
if sendErr != nil { if sendErr != nil {
return sendErr return sendErr
} }
_, err := c.client.sessionHandler.WaitForResponse(sentRequestId, actionType) _, err := c.sessionHandler.WaitForResponse(sentRequestId, actionType)
if err != nil { if err != nil {
return err return err
} }

26
libgm/messages.go
View file

@ -6,19 +6,15 @@ import (
"go.mau.fi/mautrix-gmessages/libgm/binary" "go.mau.fi/mautrix-gmessages/libgm/binary"
) )
type Messages struct { func (c *Client) SendReaction(payload *binary.SendReactionPayload) (*binary.SendReactionResponse, error) {
client *Client
}
func (m *Messages) React(payload *binary.SendReactionPayload) (*binary.SendReactionResponse, error) {
actionType := binary.ActionType_SEND_REACTION actionType := binary.ActionType_SEND_REACTION
sentRequestId, sendErr := m.client.sessionHandler.completeSendMessage(actionType, true, payload) sentRequestId, sendErr := c.sessionHandler.completeSendMessage(actionType, true, payload)
if sendErr != nil { if sendErr != nil {
return nil, sendErr return nil, sendErr
} }
response, err := m.client.sessionHandler.WaitForResponse(sentRequestId, actionType) response, err := c.sessionHandler.WaitForResponse(sentRequestId, actionType)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -28,20 +24,19 @@ func (m *Messages) React(payload *binary.SendReactionPayload) (*binary.SendReact
return nil, fmt.Errorf("unexpected response type %T, expected *binary.SendReactionResponse", response.Data.Decrypted) return nil, fmt.Errorf("unexpected response type %T, expected *binary.SendReactionResponse", response.Data.Decrypted)
} }
m.client.Logger.Debug().Any("res", res).Msg("sent reaction!")
return res, nil return res, nil
} }
func (m *Messages) Delete(messageId string) (*binary.DeleteMessageResponse, error) { func (c *Client) DeleteMessage(messageID string) (*binary.DeleteMessageResponse, error) {
payload := &binary.DeleteMessagePayload{MessageID: messageId} payload := &binary.DeleteMessagePayload{MessageID: messageID}
actionType := binary.ActionType_DELETE_MESSAGE actionType := binary.ActionType_DELETE_MESSAGE
sentRequestId, sendErr := m.client.sessionHandler.completeSendMessage(actionType, true, payload) sentRequestId, sendErr := c.sessionHandler.completeSendMessage(actionType, true, payload)
if sendErr != nil { if sendErr != nil {
return nil, sendErr return nil, sendErr
} }
response, err := m.client.sessionHandler.WaitForResponse(sentRequestId, actionType) response, err := c.sessionHandler.WaitForResponse(sentRequestId, actionType)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -51,20 +46,19 @@ func (m *Messages) Delete(messageId string) (*binary.DeleteMessageResponse, erro
return nil, fmt.Errorf("unexpected response type %T, expected *binary.DeleteMessagesResponse", response.Data.Decrypted) return nil, fmt.Errorf("unexpected response type %T, expected *binary.DeleteMessagesResponse", response.Data.Decrypted)
} }
m.client.Logger.Debug().Any("res", res).Msg("deleted message!")
return res, nil return res, nil
} }
func (m *Messages) MarkRead(conversationID, messageID string) error { func (c *Client) MarkRead(conversationID, messageID string) error {
payload := &binary.MessageReadPayload{ConversationID: conversationID, MessageID: messageID} payload := &binary.MessageReadPayload{ConversationID: conversationID, MessageID: messageID}
actionType := binary.ActionType_MESSAGE_READ actionType := binary.ActionType_MESSAGE_READ
sentRequestId, sendErr := m.client.sessionHandler.completeSendMessage(actionType, true, payload) sentRequestId, sendErr := c.sessionHandler.completeSendMessage(actionType, true, payload)
if sendErr != nil { if sendErr != nil {
return sendErr return sendErr
} }
_, err := m.client.sessionHandler.WaitForResponse(sentRequestId, actionType) _, err := c.sessionHandler.WaitForResponse(sentRequestId, actionType)
if err != nil { if err != nil {
return err return err
} }

2
libgm/rpc.go
View file

@ -82,7 +82,7 @@ func (r *RPC) ListenReceiveMessages(payload []byte) {
r.conn = resp.Body r.conn = resp.Body
if r.client.authData.DevicePair != nil { if r.client.authData.DevicePair != nil {
go func() { go func() {
err := r.client.Session.NotifyDittoActivity() err := r.client.NotifyDittoActivity()
if err != nil { if err != nil {
r.client.Logger.Err(err).Msg("Error notifying ditto activity") r.client.Logger.Err(err).Msg("Error notifying ditto activity")
} }

25
libgm/session.go
View file

@ -6,32 +6,27 @@ import (
"go.mau.fi/mautrix-gmessages/libgm/binary" "go.mau.fi/mautrix-gmessages/libgm/binary"
) )
type Session struct { func (c *Client) SetActiveSession() error {
client *Client c.sessionHandler.ResetSessionId()
}
// start receiving updates from mobile on this session
func (s *Session) SetActiveSession() error {
s.client.sessionHandler.ResetSessionId()
actionType := binary.ActionType_GET_UPDATES actionType := binary.ActionType_GET_UPDATES
_, sendErr := s.client.sessionHandler.completeSendMessage(actionType, false, nil) _, sendErr := c.sessionHandler.completeSendMessage(actionType, false, nil)
if sendErr != nil { if sendErr != nil {
return sendErr return sendErr
} }
return nil return nil
} }
func (s *Session) IsBugleDefault() (*binary.IsBugleDefaultResponse, error) { func (c *Client) IsBugleDefault() (*binary.IsBugleDefaultResponse, error) {
s.client.sessionHandler.ResetSessionId() c.sessionHandler.ResetSessionId()
actionType := binary.ActionType_IS_BUGLE_DEFAULT actionType := binary.ActionType_IS_BUGLE_DEFAULT
sentRequestId, sendErr := s.client.sessionHandler.completeSendMessage(actionType, true, nil) sentRequestId, sendErr := c.sessionHandler.completeSendMessage(actionType, true, nil)
if sendErr != nil { if sendErr != nil {
return nil, sendErr return nil, sendErr
} }
response, err := s.client.sessionHandler.WaitForResponse(sentRequestId, actionType) response, err := c.sessionHandler.WaitForResponse(sentRequestId, actionType)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -44,16 +39,16 @@ func (s *Session) IsBugleDefault() (*binary.IsBugleDefaultResponse, error) {
return res, nil return res, nil
} }
func (s *Session) NotifyDittoActivity() error { func (c *Client) NotifyDittoActivity() error {
payload := &binary.NotifyDittoActivityPayload{Success: true} payload := &binary.NotifyDittoActivityPayload{Success: true}
actionType := binary.ActionType_NOTIFY_DITTO_ACTIVITY actionType := binary.ActionType_NOTIFY_DITTO_ACTIVITY
sentRequestId, sendErr := s.client.sessionHandler.completeSendMessage(actionType, true, payload) sentRequestId, sendErr := c.sessionHandler.completeSendMessage(actionType, true, payload)
if sendErr != nil { if sendErr != nil {
return sendErr return sendErr
} }
_, err := s.client.sessionHandler.WaitForResponse(sentRequestId, actionType) _, err := c.sessionHandler.WaitForResponse(sentRequestId, actionType)
if err != nil { if err != nil {
return err return err
} }

4
libgm/useralert_handler.go
View file

@ -9,12 +9,12 @@ import (
func (c *Client) handleClientReady(newSessionId string) { func (c *Client) handleClientReady(newSessionId string) {
c.Logger.Info().Any("sessionId", newSessionId).Msg("Client is ready!") c.Logger.Info().Any("sessionId", newSessionId).Msg("Client is ready!")
conversations, convErr := c.Conversations.List(25) conversations, convErr := c.ListConversations(25)
if convErr != nil { if convErr != nil {
panic(convErr) panic(convErr)
} }
c.Logger.Debug().Any("conversations", conversations).Msg("got conversations") c.Logger.Debug().Any("conversations", conversations).Msg("got conversations")
notifyErr := c.Session.NotifyDittoActivity() notifyErr := c.NotifyDittoActivity()
if notifyErr != nil { if notifyErr != nil {
panic(notifyErr) panic(notifyErr)
} }

10
portal.go
View file

@ -1274,7 +1274,7 @@ func (portal *Portal) HandleMatrixMessage(sender *User, evt *event.Event, timing
if req, err := portal.convertMatrixMessage(ctx, sender, content, txnID); err != nil { if req, err := portal.convertMatrixMessage(ctx, sender, content, txnID); err != nil {
go ms.sendMessageMetrics(evt, err, "Error converting", true) go ms.sendMessageMetrics(evt, err, "Error converting", true)
} else if _, err = sender.Client.Conversations.SendMessage(req); err != nil { } else if _, err = sender.Client.SendMessage(req); err != nil {
go ms.sendMessageMetrics(evt, err, "Error sending", true) go ms.sendMessageMetrics(evt, err, "Error sending", true)
} else { } else {
go ms.sendMessageMetrics(evt, nil, "", true) go ms.sendMessageMetrics(evt, nil, "", true)
@ -1308,7 +1308,7 @@ func (portal *Portal) HandleMatrixReadReceipt(brUser bridge.User, eventID id.Eve
targetMessage = lastMessage targetMessage = lastMessage
} }
log = log.With().Str("message_id", targetMessage.ID).Logger() log = log.With().Str("message_id", targetMessage.ID).Logger()
err = user.Client.Messages.MarkRead(portal.ID, targetMessage.ID) err = user.Client.MarkRead(portal.ID, targetMessage.ID)
if err != nil { if err != nil {
log.Err(err).Msg("Failed to mark message as read") log.Err(err).Msg("Failed to mark message as read")
} else { } else {
@ -1353,7 +1353,7 @@ func (portal *Portal) handleMatrixReaction(sender *User, evt *event.Event) error
if existingReaction != nil { if existingReaction != nil {
action = binary.Reaction_SWITCH action = binary.Reaction_SWITCH
} }
resp, err := sender.Client.Messages.React(&binary.SendReactionPayload{ resp, err := sender.Client.SendReaction(&binary.SendReactionPayload{
MessageID: msg.ID, MessageID: msg.ID,
ReactionData: binary.MakeReactionData(emoji), ReactionData: binary.MakeReactionData(emoji),
Action: action, Action: action,
@ -1402,7 +1402,7 @@ func (portal *Portal) handleMatrixMessageRedaction(ctx context.Context, sender *
} else if msg == nil { } else if msg == nil {
return errTargetNotFound return errTargetNotFound
} }
resp, err := sender.Client.Messages.Delete(msg.ID) resp, err := sender.Client.DeleteMessage(msg.ID)
if err != nil { if err != nil {
return fmt.Errorf("failed to send message removal: %w", err) return fmt.Errorf("failed to send message removal: %w", err)
} else if !resp.Success { } else if !resp.Success {
@ -1425,7 +1425,7 @@ func (portal *Portal) handleMatrixReactionRedaction(ctx context.Context, sender
return errTargetNotFound return errTargetNotFound
} }
resp, err := sender.Client.Messages.React(&binary.SendReactionPayload{ resp, err := sender.Client.SendReaction(&binary.SendReactionPayload{
MessageID: existingReaction.MessageID, MessageID: existingReaction.MessageID,
ReactionData: binary.MakeReactionData(existingReaction.Reaction), ReactionData: binary.MakeReactionData(existingReaction.Reaction),
Action: binary.Reaction_REMOVE, Action: binary.Reaction_REMOVE,