|
1 /* |
|
2 * Copyright (c) 2009 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 * class to manage differnt messaging views. |
|
16 * |
|
17 */ |
|
18 |
|
19 #include "msgviewmanager.h" |
|
20 |
|
21 #include <HbMainWindow> |
|
22 #include <HbAction> |
|
23 #include <xqserviceutil.h> |
|
24 #include <QSqlQuery> |
|
25 #include <QSqlError> |
|
26 #include <HbApplication> |
|
27 #include <HbNotificationDialog> |
|
28 |
|
29 #include "conversationsengine.h" |
|
30 #include "msglistview.h" |
|
31 #include "msgunieditorview.h" |
|
32 #include "msgconversationbaseview.h" |
|
33 #include "unifiedviewer.h" |
|
34 #include "draftslistview.h" |
|
35 #include "msgsettingsview.h" |
|
36 #include "convergedmessageid.h" |
|
37 |
|
38 // LOCALIZATION |
|
39 #define LOC_SAVED_TO_DRAFTS ("Saved to Drafts") |
|
40 |
|
41 const qint64 NULL_CONVERSATIONID = -1; |
|
42 |
|
43 MsgViewManager::MsgViewManager(bool serviceRequest, HbMainWindow* mainWindow, QObject* parent) : |
|
44 QObject(parent), mMainWindow(mainWindow), mUniEditor(0), mListView(0), mConversationView(0), |
|
45 mUniViewer(0), mDraftsListView(0), mSettingsView(0), mBackAction(0), mServiceRequest( |
|
46 serviceRequest), mConversationId(-1) |
|
47 { |
|
48 //creating back action. |
|
49 mBackAction = new HbAction(Hb::BackAction, this); |
|
50 connect(mBackAction, SIGNAL(triggered()), this, SLOT(onBackAction())); |
|
51 |
|
52 //create clv as first view if not a service request. |
|
53 if (!mServiceRequest) { |
|
54 QVariantList param; |
|
55 param << MsgBaseView::CLV; |
|
56 param << MsgBaseView::CLV; |
|
57 switchView(param); |
|
58 } |
|
59 } |
|
60 |
|
61 MsgViewManager::~MsgViewManager() |
|
62 { |
|
63 // TODO Auto-generated destructor stub |
|
64 } |
|
65 |
|
66 void MsgViewManager::onBackAction() |
|
67 { |
|
68 switch (mCurrentView) { |
|
69 case MsgBaseView::CLV: |
|
70 { |
|
71 if (!mServiceRequest) { |
|
72 HbApplication::quit(); |
|
73 } |
|
74 else { |
|
75 completeServiceRequest(); |
|
76 } |
|
77 |
|
78 break; |
|
79 } |
|
80 |
|
81 case MsgBaseView::CV: |
|
82 { |
|
83 //Save content to drafts before switching to clv |
|
84 bool result = mConversationView->saveContentToDrafts(); |
|
85 |
|
86 //marking messages as red in CV. |
|
87 mConversationView->markMessagesAsRead(); |
|
88 |
|
89 //clearing content of cv. |
|
90 mConversationView->clearContent(); |
|
91 |
|
92 if (mServiceRequest) { |
|
93 completeServiceRequest(); |
|
94 } |
|
95 else { |
|
96 //switch to clv. |
|
97 QVariantList param; |
|
98 param << MsgBaseView::CLV; |
|
99 param << MsgBaseView::CV; |
|
100 switchView(param); |
|
101 if (result) { |
|
102 HbNotificationDialog::launchDialog(LOC_SAVED_TO_DRAFTS); |
|
103 } |
|
104 } |
|
105 |
|
106 break; |
|
107 } |
|
108 |
|
109 case MsgBaseView::DLV: |
|
110 { |
|
111 if (mServiceRequest) { |
|
112 completeServiceRequest(); |
|
113 } |
|
114 else { |
|
115 //switch to clv. |
|
116 QVariantList param; |
|
117 param << MsgBaseView::CLV; |
|
118 param << MsgBaseView::DLV; |
|
119 switchView(param); |
|
120 } |
|
121 |
|
122 break; |
|
123 } |
|
124 |
|
125 case MsgBaseView::UNIEDITOR: |
|
126 { |
|
127 //Save content to drafts before switching to clv |
|
128 bool result = mUniEditor->saveContentToDrafts(); |
|
129 |
|
130 //switch to clv. |
|
131 if (mServiceRequest) { |
|
132 completeServiceRequest(); |
|
133 } |
|
134 else { |
|
135 //switch to clv. |
|
136 QVariantList param; |
|
137 param << MsgBaseView::CLV; |
|
138 param << MsgBaseView::UNIEDITOR; |
|
139 switchView(param); |
|
140 if (result) { |
|
141 HbNotificationDialog::launchDialog(LOC_SAVED_TO_DRAFTS); |
|
142 } |
|
143 } |
|
144 |
|
145 break; |
|
146 } |
|
147 |
|
148 case MsgBaseView::UNIVIEWER: |
|
149 { |
|
150 //swich to cv. |
|
151 QVariantList param; |
|
152 param << MsgBaseView::CV; |
|
153 param << MsgBaseView::UNIVIEWER; |
|
154 param << mConversationId; |
|
155 switchView(param); |
|
156 |
|
157 mUniViewer->clearContent(); |
|
158 |
|
159 break; |
|
160 } |
|
161 |
|
162 default: |
|
163 { |
|
164 break; |
|
165 } |
|
166 } |
|
167 } |
|
168 |
|
169 void MsgViewManager::switchView(const QVariantList& data) |
|
170 { |
|
171 int viewId = data.at(0).toInt(); |
|
172 switch (viewId) { |
|
173 case MsgBaseView::DEFAULT: |
|
174 { |
|
175 handleDefault(data); |
|
176 break; |
|
177 } |
|
178 case MsgBaseView::CLV: |
|
179 { |
|
180 switchToClv(data); |
|
181 break; |
|
182 } |
|
183 |
|
184 case MsgBaseView::CV: |
|
185 { |
|
186 switchToCv(data); |
|
187 break; |
|
188 } |
|
189 |
|
190 case MsgBaseView::DLV: |
|
191 { |
|
192 switchToDlv(data); |
|
193 break; |
|
194 } |
|
195 |
|
196 case MsgBaseView::UNIEDITOR: |
|
197 { |
|
198 switchToUniEditor(data); |
|
199 break; |
|
200 } |
|
201 |
|
202 case MsgBaseView::UNIVIEWER: |
|
203 { |
|
204 switchToUniViewer(data); |
|
205 break; |
|
206 } |
|
207 |
|
208 case MsgBaseView::MSGSETTINGS: |
|
209 { |
|
210 switchToMsgSettings(data); |
|
211 break; |
|
212 } |
|
213 } |
|
214 } |
|
215 |
|
216 void MsgViewManager::send(const qint32 contactId, const QString phoneNumber, |
|
217 const QString displayName) |
|
218 { |
|
219 qint64 conversationId = ConversationsEngine::instance()-> getConversationIdFromContactId( |
|
220 contactId); |
|
221 |
|
222 //set mode to viewer, if conversations found else send mode. |
|
223 QVariantList param; |
|
224 if (conversationId > 0) { |
|
225 param << MsgBaseView::CV; |
|
226 param << MsgBaseView::SERVICE; |
|
227 param << conversationId; |
|
228 } |
|
229 else { |
|
230 ConvergedMessage message; |
|
231 ConvergedMessageAddress address; |
|
232 address.setAddress(phoneNumber); |
|
233 address.setAlias(displayName); |
|
234 message.addToRecipient(address); |
|
235 |
|
236 QByteArray dataArray; |
|
237 QDataStream messageStream(&dataArray, QIODevice::WriteOnly | QIODevice::Append); |
|
238 message.serialize(messageStream); |
|
239 |
|
240 param << MsgBaseView::UNIEDITOR; |
|
241 param << MsgBaseView::SERVICE; |
|
242 param << dataArray; |
|
243 } |
|
244 switchView(param); |
|
245 XQServiceUtil::toBackground(false); |
|
246 } |
|
247 |
|
248 void MsgViewManager::setServiceRequest(bool request) |
|
249 { |
|
250 mServiceRequest = request; |
|
251 mViewAtServiceRequest = mCurrentView; |
|
252 } |
|
253 |
|
254 void MsgViewManager::switchToLastSavedView() |
|
255 { |
|
256 QVariantList param; |
|
257 |
|
258 switch (mViewAtServiceRequest) { |
|
259 case MsgBaseView::CV: |
|
260 { |
|
261 param << MsgBaseView::CV; |
|
262 param << MsgBaseView::SERVICE; |
|
263 param << mConversationId; |
|
264 break; |
|
265 } |
|
266 case MsgBaseView::UNIVIEWER: |
|
267 { |
|
268 param << MsgBaseView::UNIVIEWER; |
|
269 param << MsgBaseView::SERVICE; |
|
270 break; |
|
271 } |
|
272 default: |
|
273 { |
|
274 param << MsgBaseView::CLV; |
|
275 param << MsgBaseView::SERVICE; |
|
276 break; |
|
277 } |
|
278 } |
|
279 switchView(param); |
|
280 } |
|
281 |
|
282 void MsgViewManager::open(qint64 conversationId) |
|
283 { |
|
284 QVariantList param; |
|
285 |
|
286 if (conversationId < 0) { |
|
287 param << MsgBaseView::CLV; |
|
288 param << MsgBaseView::SERVICE; |
|
289 } |
|
290 else { |
|
291 param << MsgBaseView::CV; |
|
292 param << MsgBaseView::SERVICE; |
|
293 param << conversationId; |
|
294 } |
|
295 |
|
296 switchView(param); |
|
297 XQServiceUtil::toBackground(false); |
|
298 } |
|
299 |
|
300 void MsgViewManager::send(QVariant data) |
|
301 { |
|
302 ConvergedMessage message; |
|
303 ConvergedMessageAttachmentList attachmentList; |
|
304 QString path = data.toString(); |
|
305 ConvergedMessageAttachment *attachment = new ConvergedMessageAttachment(path); |
|
306 |
|
307 attachmentList.append(attachment); |
|
308 message.addAttachments(attachmentList); |
|
309 |
|
310 QByteArray dataArray; |
|
311 QDataStream messageStream(&dataArray, QIODevice::WriteOnly | QIODevice::Append); |
|
312 message.serialize(messageStream); |
|
313 |
|
314 QVariantList param; |
|
315 param << MsgBaseView::UNIEDITOR; |
|
316 param << MsgBaseView::SERVICE; |
|
317 param << dataArray; |
|
318 |
|
319 switchView(param); |
|
320 XQServiceUtil::toBackground(false); |
|
321 } |
|
322 |
|
323 qint64 MsgViewManager::findConversationId(const QString phoneNum) |
|
324 { |
|
325 return ConversationsEngine::instance()-> getConversationIdFromAddress(phoneNum); |
|
326 } |
|
327 |
|
328 //will be depricated in future. |
|
329 void MsgViewManager::openEditor(QString phoneNumber, QString name) |
|
330 { |
|
331 ConvergedMessage message; |
|
332 ConvergedMessageAddress address; |
|
333 address.setAddress(phoneNumber); |
|
334 address.setAlias(name); |
|
335 message.addToRecipient(address); |
|
336 |
|
337 QByteArray dataArray; |
|
338 QDataStream messageStream(&dataArray, QIODevice::WriteOnly | QIODevice::Append); |
|
339 message.serialize(messageStream); |
|
340 |
|
341 QVariantList param; |
|
342 param << MsgBaseView::UNIEDITOR; |
|
343 param << MsgBaseView::SERVICE; |
|
344 param << dataArray; |
|
345 |
|
346 switchView(param); |
|
347 XQServiceUtil::toBackground(false); |
|
348 } |
|
349 |
|
350 void MsgViewManager::completeServiceRequest() |
|
351 { |
|
352 mServiceRequest = false; |
|
353 XQServiceUtil::toBackground(true); |
|
354 switchToLastSavedView(); |
|
355 } |
|
356 |
|
357 void MsgViewManager::switchToClv(const QVariantList& data) |
|
358 { |
|
359 //switch to CLV. |
|
360 mCurrentView = MsgBaseView::CLV; |
|
361 mPreviousView = data.at(1).toInt(); |
|
362 |
|
363 //delete uni editor. |
|
364 if (mUniEditor) { |
|
365 mMainWindow->removeView(mUniEditor); |
|
366 delete mUniEditor; |
|
367 mUniEditor = NULL; |
|
368 } |
|
369 //remove the settings view from main window |
|
370 if (mSettingsView) { |
|
371 mMainWindow->removeView(mSettingsView); |
|
372 mSettingsView->setNavigationAction(mBackAction); |
|
373 connect(mBackAction, SIGNAL(triggered()), this, SLOT(onBackAction()), Qt::UniqueConnection); |
|
374 } |
|
375 if (mConversationView) { |
|
376 //clearing content of cv. |
|
377 mConversationView->clearContent(); |
|
378 } |
|
379 |
|
380 if (!mListView) { |
|
381 mListView = new MsgListView(); |
|
382 mListView->setNavigationAction(mBackAction); |
|
383 connect(mListView, SIGNAL(switchView(const QVariantList&)), this, |
|
384 SLOT(switchView(const QVariantList&))); |
|
385 mMainWindow->addView(mListView); |
|
386 mListView->activateView(); |
|
387 } |
|
388 mMainWindow->setCurrentView(mListView); |
|
389 } |
|
390 |
|
391 void MsgViewManager::switchToCv(const QVariantList& data) |
|
392 { |
|
393 //switch to CV. |
|
394 mCurrentView = MsgBaseView::CV; |
|
395 mPreviousView = data.at(1).toInt(); |
|
396 |
|
397 //delete uni editor. |
|
398 if (mUniEditor) { |
|
399 mMainWindow->removeView(mUniEditor); |
|
400 delete mUniEditor; |
|
401 mUniEditor = NULL; |
|
402 } |
|
403 |
|
404 QVariant var = data.at(2); |
|
405 qint64 conversationId; |
|
406 if (var.type() == QVariant::String) { |
|
407 QString phoneNumber = var.toString(); |
|
408 conversationId = findConversationId(phoneNumber); |
|
409 |
|
410 if (conversationId == NULL_CONVERSATIONID) { |
|
411 QVariantList param; |
|
412 param << MsgBaseView::CLV; |
|
413 param << MsgBaseView::CV; |
|
414 switchView(param); |
|
415 return; |
|
416 } |
|
417 } |
|
418 else if (var.type() == QVariant::Invalid) { |
|
419 // this case comes when a message is deleted from |
|
420 // Unified viewer set curent view as conversation view |
|
421 // and return |
|
422 mMainWindow->setCurrentView(mConversationView, false); |
|
423 mUniViewer->clearContent(); |
|
424 return; |
|
425 } |
|
426 else { |
|
427 conversationId = var.toLongLong(); |
|
428 } |
|
429 //switch to CV. |
|
430 mConversationId = conversationId; |
|
431 |
|
432 if (!mConversationView) { |
|
433 mConversationView = new MsgConversationBaseView(); |
|
434 mConversationView->setNavigationAction(mBackAction); |
|
435 connect(mConversationView, SIGNAL(switchView(const QVariantList&)), this, |
|
436 SLOT(switchView(const QVariantList&))); |
|
437 |
|
438 mMainWindow->addView(mConversationView); |
|
439 } |
|
440 |
|
441 mConversationView->openConversation(conversationId); |
|
442 |
|
443 if (mServiceRequest) { |
|
444 mMainWindow->setCurrentView(mConversationView, false); |
|
445 } |
|
446 else { |
|
447 mMainWindow->setCurrentView(mConversationView, false); |
|
448 } |
|
449 } |
|
450 |
|
451 void MsgViewManager::switchToDlv(const QVariantList& data) |
|
452 { |
|
453 //switch to DLV. |
|
454 mCurrentView = MsgBaseView::DLV; |
|
455 mPreviousView = data.at(1).toInt(); |
|
456 |
|
457 //delete uni editor. |
|
458 if (mUniEditor) { |
|
459 mMainWindow->removeView(mUniEditor); |
|
460 delete mUniEditor; |
|
461 mUniEditor = NULL; |
|
462 } |
|
463 |
|
464 if (!mDraftsListView) { |
|
465 mDraftsListView = new DraftsListView(); |
|
466 mDraftsListView->setNavigationAction(mBackAction); |
|
467 connect(mDraftsListView, SIGNAL(switchView(const QVariantList&)), this, |
|
468 SLOT(switchView(const QVariantList&))); |
|
469 |
|
470 mMainWindow->addView(mDraftsListView); |
|
471 } |
|
472 mMainWindow->setCurrentView(mDraftsListView); |
|
473 } |
|
474 |
|
475 void MsgViewManager::switchToUniEditor(const QVariantList& data) |
|
476 { |
|
477 mCurrentView = MsgBaseView::UNIEDITOR; |
|
478 mPreviousView = data.at(1).toInt(); |
|
479 |
|
480 if (mConversationView) { |
|
481 //clearing content of cv. |
|
482 mConversationView->clearContent(); |
|
483 } |
|
484 |
|
485 //swich to unieditor. |
|
486 if (!mUniEditor) { |
|
487 mUniEditor = new MsgUnifiedEditorView(); |
|
488 mMainWindow->addView(mUniEditor); |
|
489 mUniEditor->setNavigationAction(mBackAction); |
|
490 connect(mUniEditor, SIGNAL(switchView(const QVariantList&)), this, |
|
491 SLOT(switchView(const QVariantList&))); |
|
492 } |
|
493 |
|
494 if (data.length() > 2) { |
|
495 QByteArray dataArray = data.at(2).toByteArray(); |
|
496 ConvergedMessage *message = new ConvergedMessage; |
|
497 QDataStream stream(&dataArray, QIODevice::ReadOnly); |
|
498 message->deserialize(stream); |
|
499 |
|
500 if (data.length() > 3) { |
|
501 mUniEditor->populateContent(*message, data.at(3).toInt()); |
|
502 } |
|
503 else { |
|
504 if (MsgBaseView::DLV == mPreviousView) { |
|
505 mUniEditor->openDraftsMessage(*(message->id()), message->messageType()); |
|
506 } |
|
507 else { |
|
508 mUniEditor->populateContent(*message); |
|
509 } |
|
510 } |
|
511 delete message; |
|
512 } |
|
513 |
|
514 if (mServiceRequest) { |
|
515 mMainWindow->setCurrentView(mUniEditor, false); |
|
516 } |
|
517 else { |
|
518 mMainWindow->setCurrentView(mUniEditor); |
|
519 } |
|
520 } |
|
521 |
|
522 void MsgViewManager::switchToUniViewer(const QVariantList& data) |
|
523 { |
|
524 mCurrentView = MsgBaseView::UNIVIEWER; |
|
525 mPreviousView = data.at(1).toInt(); |
|
526 |
|
527 //switch to univiewer. |
|
528 if (data.length() > 2) { |
|
529 qint32 contactId = data.at(2).toLongLong(); |
|
530 QByteArray dataArray = data.at(3).toByteArray(); |
|
531 int msgCount = data.at(4).toInt(); |
|
532 |
|
533 ConvergedMessage *message = new ConvergedMessage; |
|
534 QDataStream stream(&dataArray, QIODevice::ReadOnly); |
|
535 message->deserialize(stream); |
|
536 qint32 messageId = message->id()->getId(); |
|
537 if (!mUniViewer) { |
|
538 mUniViewer = new UnifiedViewer(messageId); |
|
539 mUniViewer->setNavigationAction(mBackAction); |
|
540 mMainWindow->addView(mUniViewer); |
|
541 connect(mUniViewer, SIGNAL(switchView(const QVariantList&)), this, |
|
542 SLOT(switchView(const QVariantList&))); |
|
543 } |
|
544 mUniViewer->populateContent(messageId, true, msgCount); |
|
545 delete message; |
|
546 } |
|
547 mMainWindow->setCurrentView(mUniViewer); |
|
548 } |
|
549 void MsgViewManager::switchToMsgSettings(const QVariantList& data) |
|
550 { |
|
551 mCurrentView = MsgBaseView::MSGSETTINGS; |
|
552 mPreviousView = data.at(1).toInt(); |
|
553 |
|
554 if (!mSettingsView) { |
|
555 mSettingsView = new MsgSettingsView(); |
|
556 connect(mSettingsView, SIGNAL(switchView(const QVariantList&)), this, |
|
557 SLOT(switchView(const QVariantList&))); |
|
558 } |
|
559 else { |
|
560 //re-connect the back action |
|
561 mSettingsView->connectCloseAction(); |
|
562 } |
|
563 |
|
564 mMainWindow->addView(mSettingsView); |
|
565 disconnect(mBackAction, SIGNAL(triggered()), this, SLOT(onBackAction())); |
|
566 mMainWindow->setCurrentView(mSettingsView); |
|
567 } |
|
568 |
|
569 void MsgViewManager::handleDefault(const QVariantList& data) |
|
570 { |
|
571 //special handling incase we switch from settings-view |
|
572 int previousViewId = data.at(1).toInt(); |
|
573 if (MsgBaseView::MSGSETTINGS == previousViewId) { |
|
574 //switch to view, where from settings view was launched |
|
575 mCurrentView = mPreviousView; |
|
576 mPreviousView = previousViewId; |
|
577 //remove the settings view from main window |
|
578 if (mSettingsView) { |
|
579 mMainWindow->removeView(mSettingsView); |
|
580 mSettingsView->setNavigationAction(mBackAction); |
|
581 connect(mBackAction, SIGNAL(triggered()), this, SLOT(onBackAction())); |
|
582 } |
|
583 switch (mCurrentView) { |
|
584 case MsgBaseView::CLV: |
|
585 { |
|
586 if (mListView) |
|
587 mMainWindow->setCurrentView(mListView); |
|
588 break; |
|
589 } |
|
590 case MsgBaseView::CV: |
|
591 { |
|
592 if (mConversationView) |
|
593 mMainWindow->setCurrentView(mConversationView, false); |
|
594 break; |
|
595 } |
|
596 case MsgBaseView::DLV: |
|
597 { |
|
598 if (mDraftsListView) |
|
599 mMainWindow->setCurrentView(mDraftsListView); |
|
600 break; |
|
601 } |
|
602 case MsgBaseView::UNIEDITOR: |
|
603 { |
|
604 if (mServiceRequest) { |
|
605 mMainWindow->setCurrentView(mUniEditor, false); |
|
606 } |
|
607 else { |
|
608 mMainWindow->setCurrentView(mUniEditor); |
|
609 } |
|
610 break; |
|
611 } |
|
612 } |
|
613 } |
|
614 } |