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 }