git / purple-line

Blame view

libpurple/poller.cpp 6.4 KB
Edit Raw Normal View History Permalink
9d4cbc44   Matti Virkkunen   Split fetchOperat... 
1
2
3
4
 
  #include <time.h>
  
  #include <debug.h>
0ac35486   Matti Virkkunen   Use libpurple HTT... 
5
 
  #include "constants.hpp"
9d4cbc44   Matti Virkkunen   Split fetchOperat... 
6
7
8
9
10
11
 
  #include "poller.hpp"
  #include "purpleline.hpp"
  
  Poller::Poller(PurpleLine &parent)
      : parent(parent)
  {
0ac35486   Matti Virkkunen   Use libpurple HTT... 
12
 
      client = boost::make_shared<ThriftClient>(parent.acct, parent.conn, LINE_POLL_PATH);
348be4bd   Matti Virkkunen   Added better reco... 
13
 
      client->set_auto_reconnect(true);
9d4cbc44   Matti Virkkunen   Split fetchOperat... 
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
  }
  
  Poller::~Poller() {
      client.reset();
  }
  
  void Poller::start() {
      fetch_operations();
  }
  
  void Poller::fetch_operations() {
      client->send_fetchOperations(local_rev, 50);
      client->send([this]() {
          int status = client->status_code();
  
          if (status == -1) {
              // Plugin closing
              return;
          } else if (status == 410) {
              // Long poll timeout, resend
              fetch_operations();
              return;
          } else if (status != 200) {
26f65110   Matti Virkkunen   Add missing linef... 
37
38
 
              purple_debug_warning("line", "fetchOperations error %d. TODO: Retry after a timeout.\n",
                  status);
9d4cbc44   Matti Virkkunen   Split fetchOperat... 
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
              return;
          }
  
          std::vector<line::Operation> operations;
          client->recv_fetchOperations(operations);
  
          for (line::Operation &op: operations) {
              switch (op.type) {
                  case line::OpType::END_OF_OPERATION: // 0
                      break;
  
                  case line::OpType::ADD_CONTACT: // 4
                      parent.blist_update_buddy(op.param1);
                      break;
  
                  case line::OpType::BLOCK_CONTACT: // 6
                      parent.blist_remove_buddy(op.param1);
                      break;
  
                  case line::OpType::UNBLOCK_CONTACT: // 7
                      parent.blist_update_buddy(op.param1);
                      break;
  
                  case line::OpType::CREATE_GROUP: // 9
                  case line::OpType::UPDATE_GROUP: // 10
                  case line::OpType::NOTIFIED_UPDATE_GROUP: // 11
                  case line::OpType::INVITE_INTO_GROUP: // 12
                      parent.blist_update_chat(op.param1, ChatType::GROUP);
                      break;
43975ee1   Matti Virkkunen   Implement accepti... 
69
70
71
 
                  case line::OpType::NOTIFIED_INVITE_INTO_GROUP: // 13
                      op_notified_invite_into_group(op);
                      break;
9d4cbc44   Matti Virkkunen   Split fetchOperat... 
72
73
74
75
76
77
78
79
80
81
 
  
                  case line::OpType::LEAVE_GROUP: // 14
                      parent.blist_remove_chat(op.param1, ChatType::GROUP);
                      break;
  
                  case line::OpType::NOTIFIED_LEAVE_GROUP: // 15
                      parent.blist_update_chat(op.param1, ChatType::GROUP);
                      break;
  
                  case line::OpType::ACCEPT_GROUP_INVITATION: // 16
9d4cbc44   Matti Virkkunen   Split fetchOperat... 
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
 
                      parent.blist_update_chat(op.param1, ChatType::GROUP);
                      break;
  
                  case line::OpType::NOTIFIED_ACCEPT_GROUP_INVITATION: // 17
                  case line::OpType::KICKOUT_FROM_GROUP: // 18
                      parent.blist_update_chat(op.param1, ChatType::GROUP);
                      break;
  
                  case line::OpType::NOTIFIED_KICKOUT_FROM_GROUP: // 19
                      op_notified_kickout_from_group(op);
                      break;
  
                  case line::OpType::CREATE_ROOM: // 20
                  case line::OpType::INVITE_INTO_ROOM: // 21
                      parent.blist_update_chat(op.param1, ChatType::ROOM);
                      break;
  
                  case line::OpType::NOTIFIED_INVITE_INTO_ROOM: // 22
                      // TODO: Perhaps show who invited the user (param2)
                      parent.blist_update_chat(op.param1, ChatType::ROOM);
                      break;
  
                  case line::OpType::LEAVE_ROOM: // 23
                      parent.blist_remove_chat(op.param1, ChatType::ROOM);
                      break;
  
                  case line::OpType::NOTIFIED_LEAVE_ROOM: // 24
                      parent.blist_update_chat(op.param1, ChatType::ROOM);
  
                  case line::OpType::SEND_MESSAGE: // 25
9d4cbc44   Matti Virkkunen   Split fetchOperat... 
112
 
                  case line::OpType::RECEIVE_MESSAGE: // 26
61ed212d   Matti Virkkunen   Split purpleline.... 
113
 
                      parent.write_message(op.message, false);
9d4cbc44   Matti Virkkunen   Split fetchOperat... 
114
115
 
                      break;
43975ee1   Matti Virkkunen   Implement accepti... 
116
117
118
119
120
 
                  case line::OpType::CANCEL_INVITATION_GROUP: // 31
                  case line::OpType::NOTIFIED_CANCEL_INVITATION_GROUP: // 32
                      parent.blist_update_chat(op.param1, ChatType::GROUP);
                      break;
9d4cbc44   Matti Virkkunen   Split fetchOperat... 
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
 
                  case line::OpType::DUMMY: // 48;
                      break;
  
                  case line::OpType::UPDATE_CONTACT: // 49
                      parent.blist_update_buddy(op.param1);
                      break;
  
                  default:
                      purple_debug_warning("line", "Unhandled operation type: %d\n", op.type);
                      break;
              }
  
              if (op.revision > local_rev)
                  local_rev = op.revision;
          }
  
          fetch_operations();
      });
  }
  
  void Poller::op_notified_kickout_from_group(line::Operation &op) {
      std::string msg;
  
      if (op.param3 == parent.profile.mid) {
          msg = "You were removed from the group by ";
          parent.blist_remove_chat(op.param1, ChatType::GROUP);
      } else {
          msg = "Removed from the group by ";
          parent.blist_update_chat(op.param1, ChatType::GROUP);
      }
  
      if (parent.contacts.count(op.param2) == 1)
          msg += parent.contacts[op.param2].displayName;
      else
          msg += "(unknown contact)";
  
      PurpleConversation *conv = purple_find_conversation_with_account(
          PURPLE_CONV_TYPE_CHAT,
          op.param1.c_str(),
          parent.acct);
  
      if (conv) {
          purple_conversation_write(
              conv,
              op.param3.c_str(),
              msg.c_str(),
43975ee1   Matti Virkkunen   Implement accepti... 
167
 
              PURPLE_MESSAGE_SYSTEM,
9d4cbc44   Matti Virkkunen   Split fetchOperat... 
168
169
170
 
              time(NULL));
      }
  }
43975ee1   Matti Virkkunen   Implement accepti... 
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
 
  
  void Poller::op_notified_invite_into_group(line::Operation &op) {
      // TODO: Maybe use cached objects instead of re-requesting every time
  
      parent.c_out->send_getGroup(op.param1);
      parent.c_out->send([this, op]{
          line::Group group;
          parent.c_out->recv_getGroup(group);
  
          if (!group.__isset.id) {
              purple_debug_warning("line", "Invited into unknown group: %s\n", op.param1.c_str());
              return;
          }
  
          parent.c_out->send_getContact(op.param2);
          parent.c_out->send([this, group, op]() mutable {
              line::Contact inviter;
              parent.c_out->recv_getContact(inviter);
  
              parent.c_out->send_getContact(op.param3);
              parent.c_out->send([this, group, inviter, op]() mutable {
                  line::Contact invitee;
                  parent.c_out->recv_getContact(invitee);
  
                  parent.handle_group_invite(group, invitee, inviter);
              });
          });
      });
  }