37 ** |
37 ** |
38 ** $QT_END_LICENSE$ |
38 ** $QT_END_LICENSE$ |
39 ** |
39 ** |
40 ****************************************************************************/ |
40 ****************************************************************************/ |
41 #include "qmessageservice.h" |
41 #include "qmessageservice.h" |
|
42 #include "qmessageservice_maemo_p.h" |
|
43 |
|
44 #include "maemohelpers_p.h" |
42 #include "modestengine_maemo_p.h" |
45 #include "modestengine_maemo_p.h" |
43 #include "telepathyengine_maemo_p.h" |
46 #include "telepathyengine_maemo_p.h" |
44 #include <QDebug> |
47 #include "eventloggerengine_maemo_p.h" |
45 |
48 |
46 QTM_BEGIN_NAMESPACE |
49 QTM_BEGIN_NAMESPACE |
47 |
|
48 class QMessageServicePrivate : public QObject |
|
49 { |
|
50 public: |
|
51 QMessageServicePrivate(QMessageService* parent); |
|
52 ~QMessageServicePrivate(); |
|
53 |
|
54 void setFinished(bool successful); |
|
55 |
|
56 public: |
|
57 QMessageService* q_ptr; |
|
58 QMessageService::State _state; |
|
59 bool _active; |
|
60 QMessageManager::Error _error; |
|
61 }; |
|
62 |
50 |
63 QMessageServicePrivate::QMessageServicePrivate(QMessageService* parent) |
51 QMessageServicePrivate::QMessageServicePrivate(QMessageService* parent) |
64 : q_ptr(parent), |
52 : q_ptr(parent), |
65 _state(QMessageService::InactiveState), |
53 _state(QMessageService::InactiveState), |
66 _active(false) |
54 _error(QMessageManager::NoError), |
|
55 _active(false), _actionId(-1), |
|
56 _pendingRequestCount(0) |
67 { |
57 { |
68 } |
58 } |
69 |
59 |
70 QMessageServicePrivate::~QMessageServicePrivate() |
60 QMessageServicePrivate::~QMessageServicePrivate() |
71 { |
61 { |
72 } |
62 } |
|
63 |
|
64 QMessageServicePrivate* QMessageServicePrivate::implementation(const QMessageService &service) |
|
65 { |
|
66 return service.d_ptr; |
|
67 } |
|
68 |
|
69 bool QMessageServicePrivate::queryMessages(QMessageService &messageService, |
|
70 const QMessageFilter &filter, |
|
71 const QMessageSortOrder &sortOrder, |
|
72 uint limit, uint offset, |
|
73 EnginesToCall enginesToCall) |
|
74 { |
|
75 qDebug() << "QMessageServicePrivate::queryMessages 1"; |
|
76 if (_active) { |
|
77 return false; |
|
78 } |
|
79 |
|
80 _ids.clear(); |
|
81 _sorted = true; |
|
82 _filtered = true; |
|
83 |
|
84 _active = true; |
|
85 _error = QMessageManager::NoError; |
|
86 bool modestEngineCalled=false; |
|
87 |
|
88 if (enginesToCall & EnginesToCallTelepathy) { |
|
89 _ids= EventLoggerEngine::instance()->filterAndOrderMessages(filter,sortOrder,QString(),QMessageDataComparator::MatchFlags()); |
|
90 qDebug() << "QMessageServicePrivate::queryMessages filterAndOrderMessages:"; |
|
91 } |
|
92 |
|
93 _pendingRequestCount = 0; |
|
94 if (enginesToCall & EnginesToCallModest) { |
|
95 qDebug() << "QMessageServicePrivate::queryMessages modest"; |
|
96 modestEngineCalled=true; |
|
97 if (ModestEngine::instance()->queryMessages(messageService, filter, sortOrder, limit, offset)) { |
|
98 qDebug() << "QMessageServicePrivate::queryMessages modest done"; |
|
99 _pendingRequestCount++; |
|
100 |
|
101 } |
|
102 qDebug() << "QMessageServicePrivate::queryMessages modest done 2"; |
|
103 } |
|
104 |
|
105 if (!modestEngineCalled && enginesToCall & EnginesToCallTelepathy && _pendingRequestCount==0 ) { |
|
106 qDebug() << "QMessageServicePrivate::queryMessages only eventloggerengine"; |
|
107 if (!_sorted) { |
|
108 MessagingHelper::orderMessages(_ids, sortOrder); |
|
109 } |
|
110 MessagingHelper::applyOffsetAndLimitToMessageIdList(_ids, limit, offset); |
|
111 |
|
112 emit q_ptr->messagesFound(_ids); |
|
113 |
|
114 qDebug() << "QMessageServicePrivate::queryMessages setFinished(true)"; |
|
115 setFinished(true); |
|
116 |
|
117 _ids.clear(); |
|
118 qDebug() << "QMessageServicePrivate::queryMessages return true"; |
|
119 return true; // Operation initialized and completed |
|
120 } |
|
121 |
|
122 |
|
123 if (_pendingRequestCount > 0) { |
|
124 _filter = filter; |
|
125 _sortOrder = sortOrder; |
|
126 _limit = limit; |
|
127 _offset = offset; |
|
128 |
|
129 _state = QMessageService::ActiveState; |
|
130 emit messageService.stateChanged(_state); |
|
131 } else { |
|
132 qDebug() << "QMessageServicePrivate::queryMessages setFinixhed() active=" << _active; |
|
133 if(_active)setFinished(false); |
|
134 } |
|
135 |
|
136 return _active; |
|
137 } |
|
138 |
|
139 bool QMessageServicePrivate::queryMessages(QMessageService &messageService, |
|
140 const QMessageFilter &filter, |
|
141 const QString &body, |
|
142 QMessageDataComparator::MatchFlags matchFlags, |
|
143 const QMessageSortOrder &sortOrder, |
|
144 uint limit, uint offset, |
|
145 EnginesToCall enginesToCall) |
|
146 { |
|
147 qDebug() << "QMessageServicePrivate::queryMessages 2"; |
|
148 if (_active) { |
|
149 return false; |
|
150 } |
|
151 |
|
152 _ids.clear(); |
|
153 _sorted = true; |
|
154 _filtered = true; |
|
155 |
|
156 _active = true; |
|
157 _error = QMessageManager::NoError; |
|
158 |
|
159 _pendingRequestCount = 0; |
|
160 |
|
161 bool modestEngineCalled=false; |
|
162 |
|
163 if (enginesToCall & EnginesToCallTelepathy) { |
|
164 _ids= EventLoggerEngine::instance()->filterAndOrderMessages(filter,sortOrder,body,matchFlags); |
|
165 } |
|
166 |
|
167 if (enginesToCall & EnginesToCallModest) { |
|
168 modestEngineCalled=true; |
|
169 if (ModestEngine::instance()->queryMessages(messageService, filter, body, matchFlags, |
|
170 sortOrder, limit, offset)) { |
|
171 _pendingRequestCount++; |
|
172 } |
|
173 } |
|
174 |
|
175 if (!modestEngineCalled && enginesToCall & EnginesToCallTelepathy && _pendingRequestCount==0 ) { |
|
176 if (!_sorted) { |
|
177 MessagingHelper::orderMessages(_ids, sortOrder); |
|
178 } |
|
179 MessagingHelper::applyOffsetAndLimitToMessageIdList(_ids, limit, offset); |
|
180 |
|
181 emit q_ptr->messagesFound(_ids); |
|
182 setFinished(true); |
|
183 |
|
184 _ids.clear(); |
|
185 qDebug() << "QMessageServicePrivate::queryMessages return true"; |
|
186 return true; // Operation initialized and completed |
|
187 } |
|
188 |
|
189 if (_pendingRequestCount > 0) { |
|
190 _filter = filter; |
|
191 _sortOrder = sortOrder; |
|
192 _limit = limit; |
|
193 _offset = offset; |
|
194 |
|
195 _state = QMessageService::ActiveState; |
|
196 emit stateChanged(_state); |
|
197 } else { |
|
198 if(_active)setFinished(false); |
|
199 } |
|
200 |
|
201 return _active; |
|
202 } |
|
203 |
|
204 bool QMessageServicePrivate::countMessages(QMessageService &messageService, |
|
205 const QMessageFilter &filter, |
|
206 EnginesToCall enginesToCall) |
|
207 { |
|
208 if (_active) { |
|
209 return false; |
|
210 } |
|
211 |
|
212 _count = 0; |
|
213 |
|
214 _active = true; |
|
215 _error = QMessageManager::NoError; |
|
216 |
|
217 _pendingRequestCount = 0; |
|
218 if (enginesToCall & EnginesToCallModest) { |
|
219 if (ModestEngine::instance()->countMessages(messageService, filter)) { |
|
220 _pendingRequestCount++; |
|
221 } |
|
222 } |
|
223 |
|
224 //TODO: SMS count support |
|
225 //if (enginesToCall & EnginesToCallTelepathy) { |
|
226 //} |
|
227 |
|
228 if (_pendingRequestCount > 0) { |
|
229 _state = QMessageService::ActiveState; |
|
230 emit stateChanged(_state); |
|
231 } else { |
|
232 setFinished(false); |
|
233 } |
|
234 |
|
235 return _active; |
|
236 } |
|
237 |
|
238 |
|
239 void QMessageServicePrivate::setFinished(bool successful) |
|
240 { |
|
241 qDebug() << "setFinished" << successful; |
|
242 if (!successful && _pendingRequestCount > 0) { |
|
243 _pendingRequestCount--; |
|
244 } |
|
245 |
|
246 if (_pendingRequestCount == 0) { |
|
247 if (!successful && (_error == QMessageManager::NoError)) { |
|
248 // We must report an error of some sort |
|
249 _error = QMessageManager::RequestIncomplete; |
|
250 } |
|
251 qDebug() << "emit stateChanged(FinishedState)"; |
|
252 _state = QMessageService::FinishedState; |
|
253 _active = false; |
|
254 emit q_ptr->stateChanged(_state); |
|
255 } |
|
256 } |
|
257 |
|
258 void QMessageServicePrivate::stateChanged(QMessageService::State state) |
|
259 { |
|
260 _state = state; |
|
261 qDebug() <<" StateChanged" << state; |
|
262 emit q_ptr->stateChanged(_state); |
|
263 } |
|
264 |
|
265 void QMessageServicePrivate::messagesFound(const QMessageIdList &ids, bool isFiltered, bool isSorted) |
|
266 { |
|
267 qDebug() <<" MessagesFound"; |
|
268 _pendingRequestCount--; |
|
269 |
|
270 if (!isFiltered) { |
|
271 _filtered = false; |
|
272 } |
|
273 |
|
274 if (!isSorted) { |
|
275 _sorted = false; |
|
276 } else { |
|
277 if ((ids.count() > 0) && (_ids.count() > 0)) { |
|
278 _sorted = false; |
|
279 } |
|
280 } |
|
281 |
|
282 _ids.append(ids); |
|
283 |
|
284 if (_pendingRequestCount == 0) { |
|
285 if (!_filtered) { |
|
286 MessagingHelper::filterMessages(_ids, _filter); |
|
287 } |
|
288 if (!_sorted) { |
|
289 MessagingHelper::orderMessages(_ids, _sortOrder); |
|
290 } |
|
291 MessagingHelper::applyOffsetAndLimitToMessageIdList(_ids, _limit, _offset); |
|
292 |
|
293 emit q_ptr->messagesFound(_ids); |
|
294 |
|
295 setFinished(true); |
|
296 |
|
297 _ids.clear(); |
|
298 _filter = QMessageFilter(); |
|
299 _sortOrder = QMessageSortOrder(); |
|
300 } |
|
301 } |
|
302 |
|
303 void QMessageServicePrivate::messagesCounted(int count) |
|
304 { |
|
305 _pendingRequestCount--; |
|
306 _count += count; |
|
307 if (_pendingRequestCount == 0) { |
|
308 emit q_ptr->messagesCounted(_count); |
|
309 |
|
310 setFinished(true); |
|
311 |
|
312 _count = 0; |
|
313 } |
|
314 } |
|
315 |
|
316 void QMessageServicePrivate::progressChanged(uint value, uint total) |
|
317 { |
|
318 emit q_ptr->progressChanged(value, total); |
|
319 } |
|
320 |
|
321 |
73 |
322 |
74 QMessageService::QMessageService(QObject *parent) |
323 QMessageService::QMessageService(QObject *parent) |
75 : QObject(parent), |
324 : QObject(parent), |
76 d_ptr(new QMessageServicePrivate(this)) |
325 d_ptr(new QMessageServicePrivate(this)) |
77 { |
326 { |
78 } |
327 EventLoggerEngine::instance(); |
79 |
328 TelepathyEngine::instance(); |
80 void QMessageServicePrivate::setFinished(bool successful) |
|
81 { |
|
82 if (!successful && (_error == QMessageManager::NoError)) { |
|
83 // We must report an error of some sort |
|
84 _error = QMessageManager::RequestIncomplete; |
|
85 } |
|
86 |
|
87 _state = QMessageService::FinishedState; |
|
88 emit q_ptr->stateChanged(_state); |
|
89 _active = false; |
|
90 } |
329 } |
91 |
330 |
92 QMessageService::~QMessageService() |
331 QMessageService::~QMessageService() |
93 { |
332 { |
94 } |
333 } |
95 |
334 |
96 bool QMessageService::queryMessages(const QMessageFilter &filter, const QMessageSortOrder &sortOrder, uint limit, uint offset) |
335 bool QMessageService::queryMessages(const QMessageFilter &filter, const QMessageSortOrder &sortOrder, uint limit, uint offset) |
97 { |
336 { |
|
337 return d_ptr->queryMessages(*this, filter, sortOrder, limit, offset); |
|
338 } |
|
339 |
|
340 bool QMessageService::queryMessages(const QMessageFilter &filter, const QString &body, QMessageDataComparator::MatchFlags matchFlags, const QMessageSortOrder &sortOrder, uint limit, uint offset) |
|
341 { |
|
342 return d_ptr->queryMessages(*this, filter, body, matchFlags, sortOrder, limit, offset); |
|
343 } |
|
344 |
|
345 bool QMessageService::countMessages(const QMessageFilter &filter) |
|
346 { |
|
347 return d_ptr->countMessages(*this, filter); |
|
348 } |
|
349 |
|
350 bool QMessageService::send(QMessage &message) |
|
351 { |
|
352 // qDebug() << "QMessageService::send"; |
98 if (d_ptr->_active) { |
353 if (d_ptr->_active) { |
99 return false; |
354 return false; |
100 } |
355 } |
101 |
356 |
102 d_ptr->_active = true; |
357 d_ptr->_active = true; |
103 d_ptr->_error = QMessageManager::NoError; |
358 d_ptr->_error = QMessageManager::NoError; |
104 |
359 |
105 if (ModestEngine::instance()->queryMessages(*this, filter, sortOrder, limit, offset)) { |
|
106 d_ptr->_state = QMessageService::ActiveState; |
|
107 emit stateChanged(d_ptr->_state); |
|
108 } else { |
|
109 d_ptr->setFinished(false); |
|
110 } |
|
111 |
|
112 return d_ptr->_active; |
|
113 } |
|
114 |
|
115 bool QMessageService::queryMessages(const QMessageFilter &filter, const QString &body, QMessageDataComparator::MatchFlags matchFlags, const QMessageSortOrder &sortOrder, uint limit, uint offset) |
|
116 { |
|
117 if (d_ptr->_active) { |
|
118 return false; |
|
119 } |
|
120 |
|
121 d_ptr->_active = true; |
|
122 d_ptr->_error = QMessageManager::NoError; |
|
123 |
|
124 if (ModestEngine::instance()->queryMessages(*this, filter, body, matchFlags, sortOrder, limit, offset)) { |
|
125 d_ptr->_state = QMessageService::ActiveState; |
|
126 emit stateChanged(d_ptr->_state); |
|
127 } else { |
|
128 d_ptr->setFinished(false); |
|
129 } |
|
130 |
|
131 return d_ptr->_active; |
|
132 } |
|
133 |
|
134 bool QMessageService::countMessages(const QMessageFilter &filter) |
|
135 { |
|
136 if (d_ptr->_active) { |
|
137 return false; |
|
138 } |
|
139 |
|
140 d_ptr->_active = true; |
|
141 d_ptr->_error = QMessageManager::NoError; |
|
142 |
|
143 if (ModestEngine::instance()->countMessages(*this, filter)) { |
|
144 d_ptr->_state = QMessageService::ActiveState; |
|
145 emit stateChanged(d_ptr->_state); |
|
146 } else { |
|
147 d_ptr->setFinished(false); |
|
148 } |
|
149 |
|
150 return d_ptr->_active; |
|
151 } |
|
152 |
|
153 bool QMessageService::send(QMessage &message) |
|
154 { |
|
155 if (d_ptr->_active) { |
|
156 return false; |
|
157 } |
|
158 |
|
159 d_ptr->_active = true; |
|
160 d_ptr->_error = QMessageManager::NoError; |
|
161 |
|
162 bool retVal = true; |
360 bool retVal = true; |
163 |
361 |
164 d_ptr->_state = QMessageService::ActiveState; |
362 d_ptr->_state = QMessageService::ActiveState; |
165 emit stateChanged(d_ptr->_state); |
363 emit stateChanged(d_ptr->_state); |
166 |
364 |
|
365 QMessageAccountId accountId = message.parentAccountId(); |
|
366 QMessage::Type msgType = QMessage::NoType; |
|
367 |
167 // Check message type |
368 // Check message type |
168 if(message.type() == QMessage::AnyType || message.type() == QMessage::NoType) { |
369 if (message.type() == QMessage::AnyType || message.type() == QMessage::NoType) { |
169 d_ptr->_error = QMessageManager::ConstraintFailure; |
370 QMessage::TypeFlags types = QMessage::NoType; |
170 retVal = false; |
371 if (accountId.isValid()) { |
171 } |
372 // ParentAccountId was defined => Message type can be read |
172 |
373 // from parent account |
173 QMessageAccountId accountId = message.parentAccountId(); |
374 QMessageAccount account = QMessageAccount(accountId); |
|
375 QMessage::TypeFlags types = account.messageTypes(); |
|
376 if (types & QMessage::Sms) { |
|
377 msgType = QMessage::Sms; |
|
378 } else if (account.messageTypes() & QMessage::InstantMessage) { |
|
379 msgType = QMessage::InstantMessage; |
|
380 } else if (types & QMessage::Mms) { |
|
381 msgType = QMessage::Mms; |
|
382 } else if (types & QMessage::Email) { |
|
383 msgType = QMessage::Email; |
|
384 } |
|
385 } |
|
386 if (msgType == QMessage::NoType) { |
|
387 d_ptr->_error = QMessageManager::ConstraintFailure; |
|
388 retVal = false; |
|
389 } |
|
390 } |
|
391 |
174 if (retVal) { |
392 if (retVal) { |
175 // Check account |
393 // Check account |
176 if (!accountId.isValid()) { |
394 if (!accountId.isValid()) { |
177 accountId = QMessageAccount::defaultAccount(message.type()); |
395 accountId = QMessageAccount::defaultAccount(message.type()); |
178 if (!accountId.isValid()) { |
396 if (!accountId.isValid()) { |