|
1 /* |
|
2 * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: |
|
15 * |
|
16 */ |
|
17 |
|
18 #include "nmmailagentheaders.h" |
|
19 #include "nmmailagent.h" |
|
20 |
|
21 // CONSTS |
|
22 const int maxUnreadCount = 1; // 1 is enough |
|
23 |
|
24 |
|
25 /*! |
|
26 \class NmMailAgent |
|
27 |
|
28 \brief Main class for receiving email events and passing them to the HbIndicator |
|
29 */ |
|
30 |
|
31 /*! |
|
32 Creates list of folder paths where plug-ins can be loaded from. |
|
33 \return folder path list. |
|
34 */ |
|
35 QStringList NmMailAgent::pluginFolders() |
|
36 { |
|
37 const QString nmPluginPath("resource/plugins"); |
|
38 QStringList pluginDirectories; |
|
39 QFileInfoList driveList = QDir::drives(); |
|
40 |
|
41 foreach(const QFileInfo &driveInfo, driveList) { |
|
42 QString pluginDirectory = |
|
43 driveInfo.absolutePath() + nmPluginPath; |
|
44 |
|
45 if (QFileInfo(pluginDirectory).exists()) { |
|
46 pluginDirectories.append(pluginDirectory); |
|
47 } |
|
48 } |
|
49 |
|
50 return pluginDirectories; |
|
51 } |
|
52 |
|
53 NmMailboxInfo::NmMailboxInfo() |
|
54 { |
|
55 mId = 0; |
|
56 mSyncState = SyncComplete; |
|
57 mConnectState = Disconnected; |
|
58 mUnreadMails = 0; |
|
59 mActive = false; |
|
60 } |
|
61 |
|
62 NmMailAgent::NmMailAgent() : |
|
63 mAdapter(NULL), |
|
64 mActiveIndicators(0) |
|
65 { |
|
66 NMLOG("NmMailAgent::NmMailAgent"); |
|
67 } |
|
68 |
|
69 /*! |
|
70 Initialise the agent. \return true if succesfully started. |
|
71 */ |
|
72 bool NmMailAgent::init() |
|
73 { |
|
74 if (!loadAdapter()) { |
|
75 // Failed to load NmFrameworkAdapter |
|
76 return false; |
|
77 } |
|
78 |
|
79 // Start listening events |
|
80 connect(mAdapter, SIGNAL(mailboxEvent(NmMailboxEvent, const QList<NmId>&)), |
|
81 this, SLOT(handleMailboxEvent(NmMailboxEvent, const QList<NmId> &))); |
|
82 |
|
83 connect(mAdapter, SIGNAL(messageEvent( |
|
84 NmMessageEvent, const NmId &, const QList<NmId> &, const NmId&)), |
|
85 this, SLOT(handleMessageEvent( |
|
86 NmMessageEvent, const NmId &, const QList<NmId> &, const NmId&))); |
|
87 |
|
88 connect(mAdapter, SIGNAL(syncStateEvent(NmSyncState, const NmId)), |
|
89 this, SLOT(handleSyncStateEvent(NmSyncState, const NmId))); |
|
90 |
|
91 connect(mAdapter, SIGNAL(connectionEvent(NmConnectState, const NmId)), |
|
92 this, SLOT(handleConnectionEvent(NmConnectState, const NmId))); |
|
93 |
|
94 // load all current mailboxes |
|
95 initMailboxStatus(); |
|
96 |
|
97 updateStatus(); |
|
98 return true; |
|
99 } |
|
100 |
|
101 NmMailAgent::~NmMailAgent() |
|
102 { |
|
103 delete mAdapter; |
|
104 qDeleteAll(mMailboxes); |
|
105 } |
|
106 |
|
107 /*! |
|
108 Initialize the mailbox list with the current state |
|
109 */ |
|
110 void NmMailAgent::initMailboxStatus() |
|
111 { |
|
112 NMLOG("NmMailAgent::initMailboxStatus"); |
|
113 QList<NmMailbox*> mailboxes; |
|
114 mAdapter->listMailboxes(mailboxes); |
|
115 foreach (const NmMailbox* mailbox, mailboxes) { |
|
116 if (mailbox) { |
|
117 NmMailboxInfo *mailboxInfo = createMailboxInfo(*mailbox); |
|
118 if (mailboxInfo) { |
|
119 mailboxInfo->mUnreadMails = getUnreadCount(mailbox->id(),maxUnreadCount); |
|
120 updateMailboxActivity(mailbox->id(), isMailboxActive(*mailboxInfo)); |
|
121 } |
|
122 } |
|
123 } |
|
124 qDeleteAll(mailboxes); |
|
125 } |
|
126 |
|
127 /*! |
|
128 Get mailbox unread count in inbox folder |
|
129 \param mailboxId id of the mailbox |
|
130 \param maxCount max number of unread mails that is needed |
|
131 \return number of unread mails in the mailbox |
|
132 */ |
|
133 int NmMailAgent::getUnreadCount(const NmId &mailboxId, int maxCount) |
|
134 { |
|
135 NMLOG("NmMailAgent::getUnreadCount"); |
|
136 int count(0); |
|
137 |
|
138 // get inbox folder ID |
|
139 NmId inboxId = mAdapter->getStandardFolderId( |
|
140 mailboxId, NmFolderInbox ); |
|
141 |
|
142 // get list of messages in inbox |
|
143 QList<NmMessageEnvelope*> messageList; |
|
144 mAdapter->listMessages(mailboxId, inboxId, messageList); |
|
145 |
|
146 foreach (const NmMessageEnvelope* envelope, messageList) { |
|
147 // if the message is not read, it is "unread" |
|
148 if (!envelope->isRead()) { |
|
149 count++; |
|
150 |
|
151 // No more unread mails are needed |
|
152 if (count >= maxCount) { |
|
153 break; |
|
154 } |
|
155 } |
|
156 } |
|
157 qDeleteAll(messageList); |
|
158 NMLOG(QString("NmMailAgent::getUnreadCount count=%1").arg(count)); |
|
159 |
|
160 return count; |
|
161 } |
|
162 |
|
163 /*! |
|
164 Load NmFrameworkAdapter from plugins. |
|
165 \return true if adapter is loaded succesfully. |
|
166 */ |
|
167 bool NmMailAgent::loadAdapter() |
|
168 { |
|
169 QStringList directories(pluginFolders()); |
|
170 |
|
171 foreach (const QString &pluginPath, directories) { |
|
172 QPluginLoader *loader = |
|
173 new QPluginLoader(pluginPath + "/nmframeworkadapter.qtplugin"); |
|
174 if (loader) { |
|
175 mAdapter = static_cast<NmFrameworkAdapter *>(loader->instance()); |
|
176 if (mAdapter) { |
|
177 return true; |
|
178 } |
|
179 } |
|
180 } |
|
181 NMLOG("NmMailAgent::loadAdapter failed"); |
|
182 return false; |
|
183 } |
|
184 |
|
185 /*! |
|
186 Update the mailbox visibility |
|
187 \param mailboxId id of the mailbox |
|
188 \param active visibility state of the mailbox |
|
189 \return true if the mailbox state was changed |
|
190 */ |
|
191 bool NmMailAgent::updateMailboxActivity(const NmId &mailboxId, bool active) |
|
192 { |
|
193 NmMailboxInfo *mailboxInfo = getMailboxInfo(mailboxId); |
|
194 bool changed = false; |
|
195 if (mailboxInfo->mActive != active) { |
|
196 mailboxInfo->mActive = active; |
|
197 changed = true; |
|
198 if (active) { |
|
199 // Mailbox becomes active again. Move to the bottom of the list. |
|
200 mMailboxes.removeAll(mailboxInfo); |
|
201 mMailboxes.append(mailboxInfo); |
|
202 } |
|
203 } |
|
204 return changed; |
|
205 } |
|
206 |
|
207 /*! |
|
208 Updates status according to current information |
|
209 */ |
|
210 void NmMailAgent::updateStatus() |
|
211 { |
|
212 NMLOG("NmMailAgent::updateStatus"); |
|
213 |
|
214 int activeIndicators = 0; |
|
215 |
|
216 // Update the indicators |
|
217 foreach (NmMailboxInfo *mailboxInfo, mMailboxes) { |
|
218 // Show only active mailboxes |
|
219 if (mailboxInfo->mActive) { |
|
220 updateIndicator(activeIndicators,true,*mailboxInfo); |
|
221 activeIndicators++; |
|
222 } |
|
223 } |
|
224 |
|
225 // Hide the indicator that are not needed anymore |
|
226 for (int i=activeIndicators;i<mActiveIndicators;i++) { |
|
227 NmMailboxInfo mailboxInfo; |
|
228 updateIndicator(i,false,mailboxInfo); |
|
229 } |
|
230 mActiveIndicators = activeIndicators; |
|
231 } |
|
232 |
|
233 /*! |
|
234 Check if the mailbox indicator should be active, according to current state |
|
235 \param mailboxInfo information of the mailbox |
|
236 \return true if indicator should be now active |
|
237 */ |
|
238 bool NmMailAgent::isMailboxActive(const NmMailboxInfo& mailboxInfo) |
|
239 { |
|
240 if (mailboxInfo.mUnreadMails>0) { |
|
241 return true; |
|
242 } |
|
243 return false; |
|
244 } |
|
245 |
|
246 /*! |
|
247 Updates indicator status |
|
248 \param mailboxIndex index of the item shown in indicator menu |
|
249 \param active indicator visibility state |
|
250 \param mailboxInfo information of the mailbox |
|
251 \return true if indicator was updated with no errors |
|
252 */ |
|
253 bool NmMailAgent::updateIndicator(int mailboxIndex, bool active, |
|
254 const NmMailboxInfo& mailboxInfo) |
|
255 { |
|
256 NMLOG(QString("NmMailAgent::updateIndicator index=%1 active=%2 unread=%3"). |
|
257 arg(mailboxIndex).arg(active).arg(mailboxInfo.mUnreadMails)); |
|
258 |
|
259 bool ok = false; |
|
260 QString name = QString("com.nokia.nmail.indicatorplugin_")+mailboxIndex+"/1.0"; |
|
261 |
|
262 QList<QVariant> list; |
|
263 list.append(mailboxInfo.mId.id()); |
|
264 list.append(mailboxInfo.mName); |
|
265 list.append(mailboxInfo.mUnreadMails); |
|
266 list.append(mailboxInfo.mSyncState); |
|
267 list.append(mailboxInfo.mConnectState); |
|
268 |
|
269 HbIndicator indicator; |
|
270 if (active) { |
|
271 ok = indicator.activate(name,list); |
|
272 } |
|
273 else { |
|
274 ok = indicator.deactivate(name,list); |
|
275 } |
|
276 return ok; |
|
277 } |
|
278 |
|
279 /*! |
|
280 Received from NmFrameworkAdapter mailboxEvent signal |
|
281 \sa NmFrameworkAdapter |
|
282 */ |
|
283 void NmMailAgent::handleMailboxEvent(NmMailboxEvent event, const QList<NmId> &mailboxIds) |
|
284 { |
|
285 NMLOG(QString("NmMailAgent::handleMailboxEvent %1").arg(event)); |
|
286 bool updateNeeded(false); |
|
287 |
|
288 switch(event) { |
|
289 case NmMailboxCreated: |
|
290 foreach (NmId mailboxId, mailboxIds) { |
|
291 getMailboxInfo(mailboxId); // create a new mailbox if needed |
|
292 updateNeeded = true; |
|
293 } |
|
294 break; |
|
295 case NmMailboxChanged: |
|
296 // Mailbox name may have been changed |
|
297 foreach (NmId mailboxId, mailboxIds) { |
|
298 NmMailboxInfo *mailboxInfo = getMailboxInfo(mailboxId); |
|
299 NmMailbox *mailbox(NULL); |
|
300 mAdapter->getMailboxById(mailboxId,mailbox); |
|
301 if (mailbox && mailboxInfo) { |
|
302 if(mailbox->name() != mailboxInfo->mName) { |
|
303 mailboxInfo->mName = mailbox->name(); |
|
304 updateNeeded = true; |
|
305 } |
|
306 } |
|
307 delete mailbox; |
|
308 } |
|
309 break; |
|
310 case NmMailboxDeleted: |
|
311 foreach (NmId mailboxId, mailboxIds) { |
|
312 if (removeMailboxInfo(mailboxId)) { |
|
313 updateNeeded = true; |
|
314 } |
|
315 } |
|
316 break; |
|
317 default: |
|
318 break; |
|
319 } |
|
320 |
|
321 if (updateNeeded) { |
|
322 updateStatus(); |
|
323 } |
|
324 } |
|
325 |
|
326 /*! |
|
327 Received from NmFrameworkAdapter messageEvent signal |
|
328 \sa NmFrameWorkAdapter |
|
329 */ |
|
330 void NmMailAgent::handleMessageEvent( |
|
331 NmMessageEvent event, |
|
332 const NmId &folderId, |
|
333 const QList<NmId> &messageIds, |
|
334 const NmId& mailboxId) |
|
335 { |
|
336 NMLOG(QString("NmMailAgent::handleMessageEvent %1 %2").arg(event).arg(mailboxId.id())); |
|
337 Q_UNUSED(folderId); |
|
338 Q_UNUSED(messageIds); |
|
339 |
|
340 switch (event) { |
|
341 case NmMessageChanged: { |
|
342 NmMailboxInfo *mailboxInfo = getMailboxInfo(mailboxId); |
|
343 // If not currently syncronizing the mailbox, this may mean |
|
344 // that a message was read/unread |
|
345 if (mailboxInfo && mailboxInfo->mSyncState==SyncComplete) { |
|
346 // check the unread status here again |
|
347 mailboxInfo->mUnreadMails = getUnreadCount(mailboxId,maxUnreadCount); |
|
348 if(updateMailboxActivity(mailboxId, isMailboxActive(*mailboxInfo))) { |
|
349 updateStatus(); |
|
350 } |
|
351 } |
|
352 break; |
|
353 } |
|
354 default: |
|
355 break; |
|
356 } |
|
357 |
|
358 // Do not perform an update here, just in handleSyncState |
|
359 } |
|
360 |
|
361 /*! |
|
362 Received from NmFrameworkAdapter syncStateEvent signal |
|
363 \sa NmFrameWorkAdapter |
|
364 */ |
|
365 void NmMailAgent::handleSyncStateEvent( |
|
366 NmSyncState state, |
|
367 const NmId mailboxId) |
|
368 { |
|
369 NMLOG(QString("NmMailAgent::handleSyncStateEvent %1 %2").arg(state).arg(mailboxId.id())); |
|
370 NmMailboxInfo *info = getMailboxInfo(mailboxId); |
|
371 if (info) { |
|
372 info->mSyncState = state; |
|
373 |
|
374 if (state==SyncComplete) { |
|
375 // check the unread status here again |
|
376 info->mUnreadMails = getUnreadCount(mailboxId,maxUnreadCount); |
|
377 if(updateMailboxActivity(mailboxId, isMailboxActive(*info))) { |
|
378 updateStatus(); |
|
379 } |
|
380 } |
|
381 } |
|
382 } |
|
383 |
|
384 /*! |
|
385 Received from NmFrameworkAdapter connectionState signal |
|
386 \sa NmFrameWorkAdapter |
|
387 */ |
|
388 void NmMailAgent::handleConnectionEvent(NmConnectState state, const NmId mailboxId) |
|
389 { |
|
390 NMLOG(QString("NmMailAgent::handleConnectionEvent %1 %2").arg(state).arg(mailboxId.id())); |
|
391 NmMailboxInfo *mailboxInfo = getMailboxInfo(mailboxId); |
|
392 if (mailboxInfo) { |
|
393 // Connecting, Connected, Disconnecting, Disconnected |
|
394 mailboxInfo->mConnectState = state; |
|
395 } |
|
396 updateStatus(); |
|
397 } |
|
398 |
|
399 /*! |
|
400 Remove a mailbox info entry |
|
401 \return true if mailbox info was found |
|
402 */ |
|
403 bool NmMailAgent::removeMailboxInfo(const NmId &id) |
|
404 { |
|
405 bool found = false; |
|
406 foreach (NmMailboxInfo *mailbox, mMailboxes) { |
|
407 if (mailbox->mId == id) { |
|
408 found = true; |
|
409 mMailboxes.removeAll(mailbox); |
|
410 } |
|
411 } |
|
412 return found; |
|
413 } |
|
414 |
|
415 /*! |
|
416 Create a new mailbox info entry |
|
417 \return new mailbox info object |
|
418 */ |
|
419 NmMailboxInfo *NmMailAgent::createMailboxInfo(const NmId &id) |
|
420 { |
|
421 // get information of the mailbox |
|
422 NmMailbox *mailbox = NULL; |
|
423 mAdapter->getMailboxById(id, mailbox); |
|
424 if (mailbox) { |
|
425 return createMailboxInfo(*mailbox); |
|
426 } |
|
427 return NULL; |
|
428 } |
|
429 |
|
430 /*! |
|
431 Create a new mailbox info with given parameters |
|
432 \return new mailbox info object |
|
433 */ |
|
434 NmMailboxInfo *NmMailAgent::createMailboxInfo(const NmMailbox& mailbox) |
|
435 { |
|
436 NmMailboxInfo *mailboxInfo = new NmMailboxInfo(); |
|
437 mailboxInfo->mId = mailbox.id(); |
|
438 mailboxInfo->mName = mailbox.name(); |
|
439 |
|
440 mMailboxes.append(mailboxInfo); |
|
441 |
|
442 // Subscribe to get all mailbox events |
|
443 mAdapter->subscribeMailboxEvents(mailboxInfo->mId); |
|
444 return mailboxInfo; |
|
445 } |
|
446 |
|
447 /*! |
|
448 Return mailbox info class with mailbox id. If no class is found, create a new instance with given id. |
|
449 \return mailbox info object |
|
450 */ |
|
451 NmMailboxInfo *NmMailAgent::getMailboxInfo(const NmId &id) |
|
452 { |
|
453 foreach (NmMailboxInfo *mailbox, mMailboxes) { |
|
454 if (mailbox->mId == id) { |
|
455 return mailbox; |
|
456 } |
|
457 } |
|
458 |
|
459 // Not found. Create a new mailbox info. |
|
460 return createMailboxInfo(id); |
|
461 } |
|
462 |
|
463 // End of file |
|
464 |