messagingapp/msgui/msgapp/src/msgviewmanager.cpp
changeset 76 60a8a215b0ec
parent 62 fdbe8253b596
equal deleted inserted replaced
73:ecf6a73a9186 76:60a8a215b0ec
    25 #include <QSqlError>
    25 #include <QSqlError>
    26 #include <HbApplication>
    26 #include <HbApplication>
    27 #include <xqappmgr.h>
    27 #include <xqappmgr.h>
    28 #include <hbmessagebox.h>
    28 #include <hbmessagebox.h>
    29 #include <HbView>
    29 #include <HbView>
       
    30 #include <tstasksettings.h>
       
    31 #include <hbinstance.h>
       
    32 #include <xqserviceutil.h>
       
    33 #include <apgtask.h>
       
    34 #include <eikenv.h>
       
    35 #include <afactivitystorage.h>
    30 
    36 
    31 #include "conversationsengine.h"
    37 #include "conversationsengine.h"
    32 #include "msglistview.h"
    38 #include "msglistview.h"
    33 #include "msgunieditorview.h"
    39 #include "msgunieditorview.h"
    34 #include "msgconversationbaseview.h"
    40 #include "msgconversationbaseview.h"
    38 #include "convergedmessageid.h"
    44 #include "convergedmessageid.h"
    39 #include "ringbc.h"
    45 #include "ringbc.h"
    40 #include "unidatamodelloader.h"
    46 #include "unidatamodelloader.h"
    41 #include "unidatamodelplugininterface.h"
    47 #include "unidatamodelplugininterface.h"
    42 #include "msgcontacthandler.h"
    48 #include "msgcontacthandler.h"
       
    49 #include "msgactivityhandler.h"
    43 #include "debugtraces.h"
    50 #include "debugtraces.h"
    44 
    51 
    45 // LOCALIZATION
    52 // LOCALIZATION
    46 #define LOC_DELETE_MESSAGE hbTrId("txt_messaging_dialog_delete_message")
    53 #define LOC_DELETE_MESSAGE hbTrId("txt_messaging_dialog_delete_message")
    47 #define LOC_DIALOG_SAVE_RINGTONE hbTrId("txt_conversations_dialog_save_ringing_tone")
    54 #define LOC_DIALOG_SAVE_RINGTONE hbTrId("txt_conversations_dialog_save_ringing_tone")
    48 
    55 
    49 const qint64 NULL_CONVERSATIONID = -1;
    56 const qint64 NULL_CONVERSATIONID = -1;
    50 
    57 const int INVALID_MSGID = -1;
    51 MsgViewManager::MsgViewManager(bool serviceRequest, HbMainWindow* mainWindow, QObject* parent,int activityMsgId) :
    58 
    52     QObject(parent), mMainWindow(mainWindow), mUniEditor(0), mListView(0), mConversationView(0),
    59 MsgViewManager::MsgViewManager(bool serviceRequest, HbMainWindow* mainWindow,
    53         mUniViewer(0), mDraftsListView(0), mSettingsView(0), mBackAction(0),
    60     QObject* parent, int activityMsgId) :
    54         mServiceRequest(serviceRequest), mConversationId(-1), mViewServiceRequest(false),mMessageId(-1)
    61     QObject(parent), mMainWindow(mainWindow), mUniEditor(0), mListView(0),
       
    62             mConversationView(0), mUniViewer(0), mDraftsListView(0),
       
    63             mSettingsView(0), mBackAction(0), mActivityHandler(0), mClient(0),
       
    64             mServiceRequest(serviceRequest), mConversationId(-1),
       
    65             mViewServiceRequest(false), mMessageId(-1),
       
    66             mBringtoForground(false)
    55 {
    67 {
    56     //creating back action.
    68     //creating back action.
    57     mBackAction = new HbAction(Hb::BackNaviAction, this);
    69     mBackAction = new HbAction(Hb::BackNaviAction, this);
    58     connect(mBackAction, SIGNAL(triggered()), this, SLOT(onBackAction()));
    70     connect(mBackAction, SIGNAL(triggered()), this, SLOT(onBackAction()));
    59 
    71 
    81     }
    93     }
    82 }
    94 }
    83 
    95 
    84 MsgViewManager::~MsgViewManager()
    96 MsgViewManager::~MsgViewManager()
    85 {
    97 {
    86     // TODO Auto-generated destructor stub
       
    87     mEditorData.clear();
       
    88 }
    98 }
    89 
    99 
    90 void MsgViewManager::onBackAction()
   100 void MsgViewManager::onBackAction()
    91 {
   101 {
    92     switch (mCurrentView) {
   102     switch (mCurrentView) {
    97             HbApplication::quit();
   107             HbApplication::quit();
    98             break;
   108             break;
    99         }
   109         }
   100 
   110 
   101         if (!mServiceRequest) {
   111         if (!mServiceRequest) {
   102             HbApplication::quit();
   112             handleSendToBackGround();
   103         }
   113         }
   104         else {
   114         else {
   105             completeServiceRequest();
   115             completeServiceRequest();
   106         }
   116         }
   107 
   117 
   399 
   409 
   400 void MsgViewManager::open(qint64 conversationId)
   410 void MsgViewManager::open(qint64 conversationId)
   401 {
   411 {
   402     QVariantList param;
   412     QVariantList param;
   403 
   413 
       
   414     mClient->setVisibility(true);
       
   415     mActivityHandler->clearActivities();
       
   416     mBringtoForground = false;    
       
   417     
   404     if (conversationId < 0) {
   418     if (conversationId < 0) {
   405         param << MsgBaseView::CLV;
   419         param << MsgBaseView::CLV;
   406         param << MsgBaseView::SERVICE;
   420         param << MsgBaseView::SERVICE;
   407 
   421 
   408         if( mCurrentView == MsgBaseView::CV && mConversationView)
   422         if( mCurrentView == MsgBaseView::CV && mConversationView)
   706         for (int i = 2; i < data.length(); i++) {
   720         for (int i = 2; i < data.length(); i++) {
   707             editorData << data.at(i);
   721             editorData << data.at(i);
   708         }
   722         }
   709 
   723 
   710         if (MsgBaseView::DLV == mPreviousView) {
   724         if (MsgBaseView::DLV == mPreviousView) {
   711             //Populate editor after view ready indication 
   725             mUniEditor->openDraftsMessage(editorData);
   712             populateUniEditorAfterViewReady(editorData);
       
   713         }
   726         }
   714         else {
   727         else {
   715             mUniEditor->populateContent(editorData);
   728             mUniEditor->populateContent(editorData);
   716         }
   729         }
   717     }
   730     }
   988         connect(mMainWindow, SIGNAL(viewReady()), this, SLOT(deletePreviousView()), Qt::UniqueConnection);
  1001         connect(mMainWindow, SIGNAL(viewReady()), this, SLOT(deletePreviousView()), Qt::UniqueConnection);
   989     }
  1002     }
   990 }
  1003 }
   991 
  1004 
   992 // ----------------------------------------------------------------------------
  1005 // ----------------------------------------------------------------------------
   993 // MsgViewManager::populateEditorAfterViewReady
       
   994 // @see header
       
   995 // ----------------------------------------------------------------------------
       
   996 void MsgViewManager::populateUniEditorAfterViewReady(const QVariantList& editorData)
       
   997 	{
       
   998     QCRITICAL_WRITE("MsgViewManager::populateUniEditorAfterViewReady start.");
       
   999 	 //Save the editor data and use it in ViewReady handler
       
  1000 	 mEditorData = editorData;	 
       
  1001 	 connect(mMainWindow, SIGNAL(viewReady()), this, SLOT(populateUniEditorView()));
       
  1002 	QCRITICAL_WRITE("MsgViewManager::populateUniEditorAfterViewReady end.");
       
  1003 	}
       
  1004 
       
  1005 // ----------------------------------------------------------------------------
       
  1006 // MsgViewManager::populateUniEditorView
       
  1007 // @see header
       
  1008 // ----------------------------------------------------------------------------
       
  1009 void MsgViewManager::populateUniEditorView()
       
  1010     {
       
  1011     QCRITICAL_WRITE("MsgViewManager::populateUniEditorView start.");
       
  1012     if (mUniEditor)
       
  1013         {
       
  1014         mUniEditor->openDraftsMessage(mEditorData);
       
  1015         }
       
  1016     mEditorData.clear();
       
  1017     
       
  1018     disconnect(mMainWindow, SIGNAL(viewReady()), this,
       
  1019             SLOT(populateUniEditorView()));
       
  1020     QCRITICAL_WRITE("MsgViewManager::populateUniEditorView end.");
       
  1021 }
       
  1022 
       
  1023 // ----------------------------------------------------------------------------
       
  1024 // MsgViewManager::onDialogDeleteMsg
  1006 // MsgViewManager::onDialogDeleteMsg
  1025 // @see header
  1007 // @see header
  1026 // ----------------------------------------------------------------------------
  1008 // ----------------------------------------------------------------------------
  1027 void MsgViewManager::onDialogDeleteMsg(HbAction* action)
  1009 void MsgViewManager::onDialogDeleteMsg(HbAction* action)
  1028 {
  1010 {
  1164                                                          count);
  1146                                                          count);
  1165 
  1147 
  1166         return localId;
  1148         return localId;
  1167     }
  1149     }
  1168 
  1150 
       
  1151 // ----------------------------------------------------------------------------
       
  1152 // MsgViewManager::handleSendToBackGround
       
  1153 // @see header
       
  1154 // ----------------------------------------------------------------------------
       
  1155 void MsgViewManager::handleSendToBackGround()
       
  1156     {
       
  1157     if(mBringtoForground == false)
       
  1158         {
       
  1159         if (!mClient)
       
  1160             mClient = new TsTaskSettings;
       
  1161         mClient->setVisibility(false);
       
  1162 
       
  1163 
       
  1164         mServiceRequest = false;
       
  1165         mMainWindow->lower();
       
  1166 
       
  1167         mActivityHandler->saveActivity();
       
  1168 
       
  1169         mMainWindow->removeView(mListView);
       
  1170         delete mListView;
       
  1171         mListView = NULL;
       
  1172 
       
  1173         if(mConversationView)
       
  1174             {
       
  1175             mMainWindow->removeView(mConversationView);
       
  1176             delete mConversationView;
       
  1177             mConversationView = NULL;
       
  1178             }
       
  1179         
       
  1180         if(mUniEditor)
       
  1181             {
       
  1182             mMainWindow->removeView(mUniEditor);
       
  1183             delete mUniEditor;
       
  1184             mUniEditor = NULL;
       
  1185             }
       
  1186 
       
  1187         mBringtoForground = true;
       
  1188 
       
  1189         TUid appUid = RProcess().SecureId();
       
  1190         TApaTaskList taskList(CEikonEnv::Static()->WsSession());
       
  1191         TApaTask task = taskList.FindApp(appUid);
       
  1192         if(task.Exists())
       
  1193             {
       
  1194             task.SendToBackground();
       
  1195             }
       
  1196         }
       
  1197     mPreviousView = MsgBaseView::DEFAULT;
       
  1198     mCurrentView = MsgBaseView::DEFAULT;      
       
  1199     }
       
  1200 
       
  1201 // ----------------------------------------------------------------------------
       
  1202 // MsgViewManager::handleApplicationActive
       
  1203 // @see header
       
  1204 // ----------------------------------------------------------------------------
       
  1205 void MsgViewManager::handleApplicationActive()
       
  1206     {
       
  1207     if(mBringtoForground)
       
  1208         {
       
  1209         mServiceRequest = false;
       
  1210         mClient->setVisibility(true);
       
  1211         mActivityHandler->clearActivities();
       
  1212 
       
  1213         mBringtoForground = false;        
       
  1214 
       
  1215         QVariantList param;
       
  1216         param << MsgBaseView::CLV;
       
  1217         param << MsgBaseView::CLV;
       
  1218         switchView(param);
       
  1219         }
       
  1220     }
       
  1221 
       
  1222 // ----------------------------------------------------------------------------
       
  1223 // MsgViewManager::setActivityHandler
       
  1224 // @see header
       
  1225 // ----------------------------------------------------------------------------
       
  1226 void MsgViewManager::setActivityHandler(MsgActivityHandler* activityHandler)
       
  1227     {
       
  1228     mActivityHandler = activityHandler;
       
  1229     connect(mActivityHandler, 
       
  1230         SIGNAL(activated(Af::ActivationReason, QString, QVariantHash)), 
       
  1231         this, 
       
  1232         SLOT(handleActivated(Af::ActivationReason, QString, QVariantHash)));
       
  1233     }
       
  1234 
       
  1235 // ----------------------------------------------------------------------------
       
  1236 // MsgViewManager::handleActivated
       
  1237 // @see header
       
  1238 // ----------------------------------------------------------------------------
       
  1239 void MsgViewManager::handleActivated(Af::ActivationReason reason, 
       
  1240         QString name, 
       
  1241         QVariantHash parameters)
       
  1242     {
       
  1243         Q_UNUSED(parameters)
       
  1244         mClient->setVisibility(true);
       
  1245         mBringtoForground = false;        
       
  1246         mServiceRequest = false;
       
  1247 
       
  1248         if( reason == Af::ActivationReasonActivity)
       
  1249             {
       
  1250             QVariant data;
       
  1251             if(name == EditorActivityName)
       
  1252                 {               
       
  1253                 bool ok = QMetaObject::invokeMethod(
       
  1254                     mActivityHandler->activitiyStorage(),"activityData",
       
  1255                     Q_RETURN_ARG(QVariant,data),Q_ARG(QString,name));
       
  1256                 }
       
  1257             int activityMsgId = mActivityHandler->parseActivityData(data);
       
  1258             if(activityMsgId == INVALID_MSGID)
       
  1259                 {
       
  1260                 QVariantList param;
       
  1261                 param << MsgBaseView::CLV;
       
  1262                 param << MsgBaseView::CLV;
       
  1263                 switchView(param);
       
  1264                 }
       
  1265             else 
       
  1266                 {
       
  1267                 openUniEditorActivity(activityMsgId);
       
  1268                 }
       
  1269             }        
       
  1270         mActivityHandler->clearActivities();
       
  1271     }
       
  1272 
  1169 //EOF
  1273 //EOF